Cree una dapp en Tezos (edición 2023)

Feb 25 2023
Parte 3 de 4-> Intercambio de tokens Ahora, vayamos por la madriguera del conejo e implementemos la función más compleja de la dapp: el intercambio de XTZ y tzBTC. Diseño de la interfaz de usuario Digo "la más compleja" porque la interfaz que está a punto de construir incluye muchas partes móviles y cálculos que deben realizarse en el momento de la entrada y confirmación del usuario.

Parte 3 de 4-> Intercambio de fichas

Ahora, vayamos por la madriguera del conejo e implementemos la función más compleja de la dapp: el intercambio de XTZ y tzBTC.

Diseño de la interfaz de usuario

Digo “la más compleja” porque la interfaz que está a punto de construir incluye muchas partes móviles y cálculos que deben realizarse en el momento de la entrada y confirmación del usuario. El contrato Liquidity Baking también es un poco exigente con los datos que debe enviar para intercambiar tokens, por lo que tendrá que ajustar nuestro código para asegurarse de que funcione como un reloj.

Aquí hay una captura de pantalla de la interfaz de usuario que está buscando:

Hay 2 entradas de texto, la de la izquierda es editable y le permitirá al usuario ingresar la cantidad de XTZ o tzBTC que desea intercambiar y la de la derecha estará deshabilitada y mostrará la cantidad correspondiente que obtendrán en el otra ficha. El botón en el medio con las 2 flechas permitirá al usuario cambiar la entrada entre XTZ y tzBTC.

Entrar en los detalles de cómo se implementan las entradas de texto iría más allá del alcance de este tutorial, pero puede verlo en el UserInput.sveltearchivo.

Manejo de la entrada del usuario

En pocas palabras, cada entrada con su ícono de token y maxcampo es el mismo componente, el componente principal rastrea la posición de cada uno para actualizar su interfaz de usuario en consecuencia. Internamente, cada componente de entrada realiza un seguimiento de la entrada del usuario y el saldo disponible para mostrar mensajes de error si el saldo es demasiado bajo. Cada actualización en la entrada se envía al componente principal para ajustar la interfaz de usuario general.

Cada vez que se envía una actualización al componente principal ( SwapView.svelte), los datos proporcionados con la actualización se pasan a la saveInputfunción:

import { 
	xtzToTokenTokenOutput, 
	tokenToXtzXtzOutput, 
	calcSlippageValue 
} from "../lbUtils";
  
const saveInput = ev => {
  const { token, val, insufficientBalance: insufBlnc } = ev.detail;
  insufficientBalance = insufBlnc;
  if (token === tokenFrom && val > 0) {
    inputFrom = val.toString();
    inputTo = "";
    if (tokenFrom === "XTZ") {
      // calculates tzBTC amount
      let tzbtcAmount = xtzToTokenTokenOutput({
        xtzIn: val * 10 ** XTZ.decimals,
        xtzPool: $store.dexInfo.xtzPool,
        tokenPool: $store.dexInfo.tokenPool
      });
      if (tzbtcAmount) {
        inputTo = tzbtcAmount.dividedBy(10 ** tzBTC.decimals).toPrecision(6);
      }
      // calculates minimum output
      minimumOutput = calcSlippageValue("tzBTC", +inputTo, +slippage);
    } else if (tokenFrom === "tzBTC") {
      // calculates XTZ amount
      let xtzAmount = tokenToXtzXtzOutput({
        tokenIn: val * 10 ** tzBTC.decimals,
        xtzPool: $store.dexInfo.xtzPool,
        tokenPool: $store.dexInfo.tokenPool
      });
      if (xtzAmount) {
        inputTo = xtzAmount.dividedBy(10 ** XTZ.decimals).toPrecision(8);
      }
      // calculates minimum output
      minimumOutput = calcSlippageValue("XTZ", +inputTo, +slippage);
    }
  } else {
    inputFrom = "";
    inputTo = "";
  }
};

  • los valores necesarios para los cálculos de las cantidades de token se desestructuran del ev.detailobjeto
  • la función verifica que los valores se reciben del token que está actualmente activo (el de la izquierda)
  • si ese token es XTZ, la cantidad en tzBTC se calcula a través de la xtzToTokenTokenOutputfunción (más sobre eso a continuación)
  • si ese token es tzBTC, la cantidad en XTZ se calcula a través de la tokenToXtzXtzOutputfunción (más sobre eso a continuación)
  • la cantidad mínima esperable según el deslizamiento establecido por el usuario es calculado por la calcSlippagefunción

Intercambio de XTZ por tzBTC y tzBTC por XTZ

Ahora, echemos un vistazo a las funciones que presentamos anteriormente, xtzToTokenTokenOutputy tokenToXtzXtzOutput. Fueron adaptados del código en este repositorio y le permiten calcular cuántos tzBTC obtendrá un usuario de acuerdo con la cantidad de XTZ que ingrese y viceversa.

export const xtzToTokenTokenOutput = (p: {
  xtzIn: BigNumber | number;
  xtzPool: BigNumber | number;
  tokenPool: BigNumber | number;
}): BigNumber | null => {
  let { xtzIn, xtzPool: _xtzPool, tokenPool } = p;
  let xtzPool = creditSubsidy(_xtzPool);
  let xtzIn_ = new BigNumber(0);
  let xtzPool_ = new BigNumber(0);
  let tokenPool_ = new BigNumber(0);
  try {
    xtzIn_ = new BigNumber(xtzIn);
    xtzPool_ = new BigNumber(xtzPool);
    tokenPool_ = new BigNumber(tokenPool);
  } catch (err) {
    return null;
  }
  if (
    xtzIn_.isGreaterThan(0) &&
    xtzPool_.isGreaterThan(0) &&
    tokenPool_.isGreaterThan(0)
  ) {
    const numerator = xtzIn_.times(tokenPool_).times(new BigNumber(998001));
    const denominator = xtzPool_
      .times(new BigNumber(1000000))
      .plus(xtzIn_.times(new BigNumber(998001)));
    return numerator.dividedBy(denominator);
  } else {
    return null;
  }
};

Lo mismo ocurre con tokenToXtzXtzOutput:

export 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;
  }
};

Creación de una transacción de intercambio

El intercambio de fichas es bastante intensivo, ya que son múltiples partes móviles que deben jugar al unísono. Describamos paso a paso lo que sucede después de que el usuario hace clic en el botón Cambiar :

const swap = async () => {
  try {
    if (isNaN(+inputFrom) || isNaN(+inputTo)) {
      return;
    }
  
  ...
  } catch (error) {
    console.log(error);
    swapStatus = TxStatus.Error;
    store.updateToast(true, "An error has occurred");
  }
};

A continuación, actualiza la interfaz de usuario para mostrarle al usuario que la transacción se está preparando:

enum TxStatus {
  NoTransaction,
  Loading,
  Success,
  Error
}

swapStatus = TxStatus.Loading;
store.updateToast(true, "Waiting to confirm the swap...");
const lbContract = await $store.Tezos.wallet.at(dexAddress);
const deadline = calcDeadline();

Después de eso, creas el ContractAbstractiondesde Taquito para interactuar con el DEX y también calculas la fecha límite.

Nota: el contrato Liquidity Baking espera que pase una fecha límite para el intercambio, la transacción será rechazada si la fecha límite vence.

Cambiando tzBTC por XTZ

Ahora, tiene 2 situaciones: el usuario seleccionó XTZ o tzBTC como token para intercambiar. Comencemos con tzBTC ya que la preparación de la transacción es más complicada:

if (tokenFrom === "tzBTC") {
  const tzBtcContract = await $store.Tezos.wallet.at(tzbtcAddress);
  const tokensSold = Math.floor(+inputFrom * 10 ** tzBTC.decimals);
  let batch = $store.Tezos.wallet
    .batch()
    .withContractCall(tzBtcContract.methods.approve(dexAddress, 0))
    .withContractCall(
    tzBtcContract.methods.approve(dexAddress, tokensSold)
    )
    .withContractCall(
    lbContract.methods.tokenToXtz(
        $store.userAddress,
        tokensSold,
        minimumOutput,
        deadline
      )
    )
    .withContractCall(tzBtcContract.methods.approve(dexAddress, 0));
  const batchOp = await batch.send();
  await batchOp.confirmation();
}

Nota 1: puede leer más sobre los comportamientos del contrato tzBTC y otros contratos FA1.2 aquí .

Nota 2: técnicamente hablando, no es necesario volver a establecer el permiso en cero al final de la transacción (pero sí es necesario establecerlo en cero al principio). Es solo una práctica común para evitar cualquier permiso pendiente inesperado.

Primero, crea el ContractAbstractioncontrato tzBTC cuando está a punto de interactuar con él. Una vez hecho esto, calcula la cantidad de tokens que debe aprobar en función de nuestros cálculos anteriores.

Nota: ContractAbstractiones una instancia muy útil proporcionada por Taquito que expone diferentes herramientas y propiedades para obtener detalles sobre un contrato determinado o interactuar con él.

Después de eso, utiliza la API de lotes proporcionada por Taquito. La API Batch permite agrupar múltiples operaciones en una sola transacción, para ahorrar combustible y tiempo de procesamiento. Así es como funciona:

  1. Usted llama al batch()método presente en la propiedad walleto contractde la instancia de laTezosToolkit
  2. Esto devuelve una instancia de lote con diferentes métodos que puede usar para crear transacciones, en nuestro ejemplo, withContractCall()es un método que agregará una nueva llamada de contrato al lote de operaciones.
  3. Como parámetro para withContractCall(), pasa la llamada del contrato como si fuera a llamarla sola, utilizando el nombre del punto de entrada en la methodspropiedad delContractAbstraction
  4. En este caso, lote 1 operación para establecer el permiso del LB DEX dentro del contrato tzBTC a cero, 1 operación para aprobar la cantidad requerida por el intercambio, 1 operación para confirmar el intercambio dentro del contrato LB DEX y 1 operación para establecer el permiso de LB DEX de nuevo a cero
  5. En el lote devuelto, llamas al .send()método para falsificar la transacción, la firmas y la envías al mempool de Tezos, que devuelve una operación.
  6. Puede awaitla confirmación de la transacción llamando .confirmation()a la operación devuelta en el paso anterior.
  • La dirección de la cuenta que recibirá el XTZ
  • La cantidad de tzBTC que se venderá para el intercambio
  • La cantidad esperada de XTZ que se recibirá
  • Una fecha límite después de la cual vence la transacción

Cambiando XTZ a tzBTC

¡Este será un esfuerzo mucho más fácil! Primero revisemos el código:

const op = await lbContract.methods
  .xtzToToken($store.userAddress, minimumOutput, deadline)
  .send({ amount: +inputFrom });
await op.confirmation();

  • La dirección de la cuenta que recibirá los tokens tzBTC
  • La cantidad esperada de tzBTC que se recibirá
  • La fecha límite

¿Recuerda el .send()método al que llama en la salida de la llamada del punto de entrada? Si no lo sabía, puede pasar parámetros a este método, uno de los más importantes es una cantidad de XTZ para enviar junto con la transacción. Simplemente pase un objeto con una amountpropiedad y un valor de la cantidad de tez que desea adjuntar, ¡y eso es todo!

Luego, al igual que cualquier otra transacción, obtiene un objeto de operación y .confirmation()lo llama para esperar a que la operación se incluya en un nuevo bloque.

Actualización de la interfaz de usuario

Ya sea que el intercambio sea exitoso o no, es crucial proporcionar comentarios a sus usuarios.

Si el intercambio tuvo éxito, obtendrá los nuevos saldos del usuario y proporcionará comentarios visuales:

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);
}
// visual feedback
store.updateToast(true, "Swap successful!");

Si el intercambio no tiene éxito, se le redirigirá a la catchrama donde también deberá proporcionar comentarios visuales y actualizar la interfaz de usuario:

swapStatus = TxStatus.Error;
store.updateToast(true, "An error has occurred");

Finalmente (juego de palabras), te mueves a la finallyrama para restablecer la interfaz de usuario después de 3 segundos:

finally {
  setTimeout(() => {
    swapStatus = TxStatus.NoTransaction;
    store.showToast(false);
  }, 3000);
}

Como puede ver por el código involucrado, el intercambio de tokens es una acción bastante compleja y hay algunas cosas que debe tener en cuenta, tanto en el código que escribe como en la interfaz de usuario que crea:

  • Intente estructurar su código en diferentes pasos que no se mezclen, por ejemplo, paso 1: actualizar la interfaz de usuario antes de falsificar la transacción, paso 2: falsificar la transacción, paso 3: emitir la transacción, paso 4: actualizar la interfaz de usuario, etc. .
  • ¡Nunca olvide proporcionar comentarios visuales a sus usuarios! La preparación de una nueva operación puede demorar hasta 30 segundos cuando la red no está congestionada, e incluso más si hay mucho tráfico. Los usuarios se preguntarán qué está pasando si no los haces esperar. Una rueda giratoria o una animación de carga suelen ser una buena idea para indicar que la aplicación está esperando algún tipo de confirmación.
  • ¡Desactive la interfaz de usuario mientras la transacción está en el mempool! No desea que los usuarios hagan clic en el botón Intercambiar por segunda vez (¡o tercera o cuarta!) mientras la cadena de bloques está procesando la transacción que ya crearon. Además de costarles más dinero, también puede confundirlos y crear comportamientos inesperados en su interfaz de usuario.
  • Restablezca la interfaz de usuario al final. Nadie quiere hacer clic en el botón Actualizar después de una interacción con la cadena de bloques porque la interfaz de usuario parece estar atascada en su estado anterior. Asegúrese de que la interfaz esté en el mismo estado (o similar) que cuando el usuario la abrió por primera vez.