Cree una dapp en Tezos (edición 2023)
Parte 4 de 4-> Agregar y quitar liquidez
¡Este va a ser grande, pero un poco menos complicado que el intercambio de tokens!
¡La parte más compleja de agregar liquidez al contrato Liquidity Baking es obtener las cantidades correctas de tokens! Después de eso, será un paseo por el parque.
Primero, entendamos lo que estamos haciendo aquí: LB DEX le brinda la capacidad de proporcionar un par de tokens (solo 2 opciones aquí, XTZ y tzBTC) como liquidez para habilitar la función de intercambio. A cambio, obtiene tokens SIRS para representar su inversión. Estos tokens aumentan de valor con el tiempo, por lo que si espera lo suficiente, puede obtener ganancias cuando elimine su liquidez, lo cual se explicará a continuación.
La interfaz aquí se parecerá mucho a la interfaz de intercambio, con algunas diferencias clave:
Como antes, tenemos 2 campos de entrada, pero esta vez, no hay un botón central para cambiar entre los 2 tokens y ambas entradas son editables.
Al ingresar un número en uno de los campos, el dapp debe calcular la cantidad correspondiente del otro token, así como la cantidad esperada en SIRS que se recibirá.
¡Ahora, veamos cómo se hace todo eso!
Convertir la entrada
Cuando el usuario va a ingresar un número en uno de los campos, la entrada enviará un nuevo evento al componente de la interfaz con el nombre del token involucrado y la cantidad que se ingresó. Estos datos serán leídos por la saveInputfunción:
const saveInput = ev => {
const { token, val }: { token: token; val: number | null } = ev.detail;
...
}
if (token === "XTZ" && val && val > 0) {
inputXtz = val.toString();
let tzbtcAmount = addLiquidityTokenIn({
xtzIn: val * 10 ** 6,
xtzPool: $store.dexInfo.xtzPool,
tokenPool: $store.dexInfo.tokenPool
});
if (tzbtcAmount) {
inputTzbtc = tzbtcAmount.dividedBy(10 ** 8).toPrecision(6);
} else {
inputTzbtc = "";
}
...
}
El valor se convierte en una cadena y se almacena en la inputXtzvariable para su uso posterior. La cantidad correspondiente de tzBTC se calcula con la addLiquidityTokenInfunción, otra de esas funciones útiles para calcular diferentes cantidades de token para el LB DEX, aquí está como referencia:
const addLiquidityTokenIn = (p: {
xtzIn: BigNumber | number;
xtzPool: BigNumber | number;
tokenPool: BigNumber | number;
}): BigNumber | null => {
const { xtzIn, xtzPool, tokenPool } = p;
let xtzIn_ = new BigNumber(0);
let xtzPool_ = new BigNumber(0);
let tokenPool_ = new BigNumber(0);
try {
xtzIn_ = new BigNumber(xtzIn);
xtzPool_ = creditSubsidy(xtzPool);
tokenPool_ = new BigNumber(tokenPool);
} catch (err) {
return null;
}
if (
xtzIn_.isGreaterThan(0) &&
xtzPool_.isGreaterThan(0) &&
tokenPool_.isGreaterThan(0)
) {
return ceilingDiv(xtzIn_.times(tokenPool_), xtzPool_);
} else {
return null;
}
};
Si el usuario ingresa una cantidad en tzBTC, los pasos serán muy similares para calcular la cantidad correspondiente en XTZ:
else if (token === "tzBTC" && val && val > 0) {
inputTzbtc = val.toString();
let xtzAmount = tokenToXtzXtzOutput({
tokenIn: val * 10 ** 8,
xtzPool: $store.dexInfo.xtzPool,
tokenPool: $store.dexInfo.tokenPool
});
if (xtzAmount) {
inputXtz = xtzAmount.dividedBy(10 ** 6).toPrecision(8);
...
} else {
inputXtz = "";
}
}
const tokenToXtzXtzOutput = (p: {
tokenIn: BigNumber | number;
xtzPool: BigNumber | number;
tokenPool: BigNumber | number;
}): BigNumber | null => {
const { tokenIn, xtzPool: _xtzPool, tokenPool } = p;
let xtzPool = creditSubsidy(_xtzPool);
let tokenIn_ = new BigNumber(0);
let xtzPool_ = new BigNumber(0);
let tokenPool_ = new BigNumber(0);
try {
tokenIn_ = new BigNumber(tokenIn);
xtzPool_ = new BigNumber(xtzPool);
tokenPool_ = new BigNumber(tokenPool);
} catch (err) {
return null;
}
if (
tokenIn_.isGreaterThan(0) &&
xtzPool_.isGreaterThan(0) &&
tokenPool_.isGreaterThan(0)
) {
let numerator = new BigNumber(tokenIn)
.times(new BigNumber(xtzPool))
.times(new BigNumber(998001));
let denominator = new BigNumber(tokenPool)
.times(new BigNumber(1000000))
.plus(new BigNumber(tokenIn).times(new BigNumber(999000)));
return numerator.dividedBy(denominator);
} else {
return null;
}
};
Cálculo de la cantidad esperada de SIRS
Ahora, tenemos que calcular la cantidad correspondiente de SIRS que se creará si inputXtzy inputTzbtcse proporcionan como parámetros para agregar liquidez. La addLiquidityLiquidityCreatedfunción hace todo el trabajo duro por nosotros:
const addLiquidityLiquidityCreated = (p: {
xtzIn: BigNumber | number;
xtzPool: BigNumber | number;
totalLiquidity: BigNumber | number;
}): BigNumber | null => {
const { xtzIn, xtzPool, totalLiquidity } = p;
let xtzIn_ = new BigNumber(0);
let xtzPool_ = new BigNumber(0);
let totalLiquidity_ = new BigNumber(0);
try {
xtzIn_ = new BigNumber(xtzIn);
xtzPool_ = new BigNumber(xtzPool);
totalLiquidity_ = new BigNumber(totalLiquidity);
} catch (err) {
return null;
}
xtzPool_ = creditSubsidy(xtzPool_);
if (xtzIn_.isGreaterThan(0) && xtzPool_.isGreaterThan(0)) {
if (totalLiquidity_.isEqualTo(0)) {
return new BigNumber(xtzIn)
.times(new BigNumber(totalLiquidity))
.dividedBy(new BigNumber(xtzPool));
} else if (totalLiquidity_.isGreaterThan(0)) {
return new BigNumber(xtzIn)
.times(new BigNumber(totalLiquidity))
.dividedBy(new BigNumber(xtzPool));
}
return null;
} else {
return null;
}
};
- la cantidad de XTZ que desea agregar como liquidez
- el estado actual del grupo XTZ
- la cantidad total de liquidez disponible en el contrato (es decir, los tokens SIRS)
Enviando las fichas
Después de calcular todos los valores que necesitamos para agregar liquidez al contrato Liquidity Baking, ¡es hora de forjar la transacción!
const addLiquidity = async () => {
try {
if (inputXtz && inputTzbtc && sirsOutput) {
addLiquidityStatus = TxStatus.Loading;
store.updateToast(
true,
"Adding liquidity, waiting for confirmation..."
);
const tzbtcForLiquidity = Math.floor(
+inputTzbtc * 10 ** tzBTC.decimals
);
const lbContract = await $store.Tezos.wallet.at(dexAddress);
const tzBtcContract = await $store.Tezos.wallet.at(tzbtcAddress);
...
}
Después de eso, convertimos la cantidad de tzBTC que obtuvimos en su valor "real", es decir, el valor sin puntos decimales almacenado en su contrato.
Luego, creamos el ContractAbstractioncontrato LB DEX y el ContractAbstractioncontrato tzBTC, ya que interactuaremos con ambos.
Nota: recuerde, cada vez que sus usuarios quieran usar tzBTC con LB DEX, la cantidad de tokens que se usarán debe aprobarse a nivel de contrato de tzBTC, lo que requiere 3 operaciones diferentes.
En este punto, habrás adivinado que tenemos que crear una transacción por lotes, pero hagámoslo de una manera diferente al capítulo anterior, para que puedas elegir la forma que prefieras:
const batch = $store.Tezos.wallet.batch([
{
kind: OpKind.TRANSACTION,
...tzBtcContract.methods.approve(dexAddress, 0).toTransferParams()
},
{
kind: OpKind.TRANSACTION,
...tzBtcContract.methods
.approve(dexAddress, tzbtcForLiquidity)
.toTransferParams()
},
{
kind: OpKind.TRANSACTION,
...lbContract.methodsObject
.addLiquidity({
owner: $store.userAddress,
minLqtMinted: sirsOutput,
maxTokensDeposited: tzbtcForLiquidity,
deadline: calcDeadline()
})
.toTransferParams(),
amount: +inputXtz
},
{
kind: OpKind.TRANSACTION,
...tzBtcContract.methods.approve(dexAddress, 0).toTransferParams()
}
]);
const batchOp = await batch.send();
await batchOp.confirmation();
La primera operación:
{
kind: OpKind.TRANSACTION,
...tzBtcContract.methods.approve(dexAddress, 0).toTransferParams()
}
La segunda operación:
{
kind: OpKind.TRANSACTION,
...tzBtcContract.methods
.approve(dexAddress, tzbtcForLiquidity)
.toTransferParams()
}
La tercera operación:
{
kind: OpKind.TRANSACTION,
...lbContract
.methodsObject
.addLiquidity({
owner: $store.userAddress,
minLqtMinted: sirsOutput,
maxTokensDeposited: tzbtcForLiquidity,
deadline: calcDeadline()
})
.toTransferParams(),
amount: +inputXtz
}
- la dirección de la cuenta que recibirá los tokens SIRS
- la cantidad mínima de tokens SIRS que se espera recibir
- la cantidad de tzBTC depositada
- la fecha límite
La cuarta operación:
{
kind: OpKind.TRANSACTION,
...tzBtcContract.methods.approve(dexAddress, 0).toTransferParams()
}
Luego, como cualquier otra transacción falsificada a través de Taquito, llamas .send()y .confirmation()en el objeto de la operación para esperar una confirmación.
Una vez que se confirma la transacción, borra la interfaz de usuario antes de obtener los nuevos saldos de XTZ, tzBTC y SIRS.
Si la transacción falla, actualiza la interfaz de usuario y proporciona comentarios visuales a los usuarios:
addLiquidityStatus = TxStatus.Error;
store.updateToast(true, "An error has occurred");
setTimeout(() => {
addLiquidityStatus = TxStatus.NoTransaction;
store.showToast(false);
}, 3000);
Eliminando liquidez
Podría decirse que eliminar la liquidez del contrato Liquidity Baking es la más fácil de todas las tareas realizadas por nuestra interfaz. La interfaz solo necesita una entrada para recibir la cantidad de SIRS que el usuario desea desenvolver para obtener XTZ y tzBTC.
Luego, la dapp calculará la cantidad correspondiente de XTZ y tzBTC que se espera recibir por la cantidad de SIRS en el campo de entrada.
En el lbUtils.tsarchivo, encontrará la removeLiquidityXtzTzbtcOutfunción para calcular estas cantidades:
const outputRes = removeLiquidityXtzTzbtcOut({
liquidityBurned: val,
totalLiquidity: $store.dexInfo.lqtTotal.toNumber(),
xtzPool: $store.dexInfo.xtzPool.toNumber(),
tokenPool: $store.dexInfo.tokenPool.toNumber()
});
if (outputRes) {
const { xtzOut, tzbtcOut } = outputRes;
xtzOutput = xtzOut
.decimalPlaces(0, 1)
.dividedBy(10 ** 6)
.decimalPlaces(6)
.toNumber();
tzbtcOutput = tzbtcOut
.decimalPlaces(0, 1)
.dividedBy(10 ** 8)
.decimalPlaces(8)
.toNumber();
}
liquidityBurned-> la cantidad de SIRS a quemartotalLiquidity-> la cantidad total de tokens SIRS en el contratoxtzPool-> la cantidad total de tokens XTZ en el contratotokenPool-> la cantidad total de tokens tzBTC en el contrato
Ahora, veamos cómo interactuar con el removeLiquiditypunto de entrada del contrato. Primero, creamos una removeLiquidityfunción dentro de nuestro código TypeScript que se activará cuando el usuario haga clic en el Remove liquiditybotón:
const removeLiquidity = async () => {
try {
if (inputSirs) {
removeLiquidityStatus = TxStatus.Loading;
store.updateToast(
true,
"Removing liquidity, waiting for confirmation..."
);
const lbContract = await $store.Tezos.wallet.at(dexAddress);
...
};
A continuación, se crea una ContractAbstractionpara el LB DEX para poder interactuar con él desde Taquito.
Ahora, podemos falsificar la transacción real:
const op = await lbContract.methodsObject
.removeLiquidity({
to: $store.userAddress,
lqtBurned: inputSirs,
minXtzWithdrawn: Math.floor(xtzOutput * 10 ** XTZ.decimals),
minTokensWithdrawn: Math.floor(tzbtcOutput * 10 ** tzBTC.decimals),
deadline: calcDeadline()
})
.send();
await op.confirmation();
to-> la cuenta que recibirá los XTZ y tzBTClqtBurned-> la cantidad de SIRS a quemarminXtzWithdrawn-> la cantidad mínima de XTZ que se espera recibirminTokensWithdrawn-> la cantidad mínima de tzBTC que se espera recibirdeadline-> al igual que el otro punto de entrada, se debe proporcionar una fecha límite para la transacción
Si la transacción fue exitosa, actualizamos la interfaz de usuario y restablecemos los valores del token para informar al usuario:
removeLiquidityStatus = TxStatus.Success;
inputSirs = "";
xtzOutput = 0;
tzbtcOutput = 0;
// fetches user's XTZ, tzBTC and SIRS balances
const res = await fetchBalances($store.Tezos, $store.userAddress);
if (res) {
store.updateUserBalance("XTZ", res.xtzBalance);
store.updateUserBalance("tzBTC", res.tzbtcBalance);
store.updateUserBalance("SIRS", res.sirsBalance);
} else {
store.updateUserBalance("XTZ", null);
store.updateUserBalance("tzBTC", null);
store.updateUserBalance("SIRS", null);
}
store.updateToast(true, "Liquidity successfully removed!");
removeLiquidityStatus = TxStatus.Error;
store.updateToast(true, "An error has occurred");
Conclusión
Has llegado hasta el final de este tutorial
Este dapp muy simple introdujo muchos conceptos diferentes que son fundamentales para desarrollar aplicaciones en Tezos, pero también para comprender cómo funciona Tezos en general.
Taquito es una biblioteca increíble para desarrollar en Tezos, ya sea que desee crear prototipos de ideas rápidamente o desee crear aplicaciones descentralizadas completas. Proporciona una biblioteca principal con todo lo que necesita para leer de la cadena de bloques de Tezos, interactuar con contratos inteligentes y usar billeteras, y varios paquetes más pequeños para uso específico, por ejemplo, lectura de metadatos de tokens u operaciones de procesamiento por lotes.
Ya sea que desee crear una aplicación de front-end, back-end o incluso una aplicación de escritorio, siempre que use JavaScript/NodeJS, ¡podrá usar Taquito!
Este tutorial también presentó diferentes herramientas que puede necesitar en su viaje para desarrollar dapps en Tezos, The Beacon SDK para interactuar con billeteras, la API TzKT para obtener más datos de la cadena de bloques, etc.
Aunque este tutorial usa Svelte como su marco de trabajo elegido, las habilidades que aprendió son transferibles a otros marcos, ya que se basan en muchos de los mismos conceptos (los ciclos de vida de los componentes son muy similares, etc.). Le brinda todo lo que necesita para construir. increíbles dapps en Tezos y no puedo esperar a ver lo que construirás a continuación.

![¿Qué es una lista vinculada, de todos modos? [Parte 1]](https://post.nghiatu.com/assets/images/m/max/724/1*Xokk6XOjWyIGCBujkJsCzQ.jpeg)



































