Ganchos Wasm IBC

Descripción general

Wasm hook es un middleware de IBC que se utiliza para permitir que las transferencias de tokens ICS20 inicien llamadas de contrato. Esto permite llamadas de contrato entre cadenas que involucran el movimiento de tokens. Esto es útil para una variedad de casos de uso. Uno de importancia primordial son los intercambios entre cadenas, que es un primitivo extremadamente poderoso.

El mecanismo que permite esto es un memocampo en cada paquete de transferencia ICS20 o ICS721 a partir de IBC v3.4.0 . Wasm Hooks es un middleware IBC que analiza una transferencia ICS20 y, si el memocampo tiene una forma particular, ejecuta una llamada de contrato wasm. A continuación detallamos el memoformato de wasmconvocatoria de contratos y las garantías de ejecución brindadas.

Formato de ejecución del contrato Cosmwasm

Antes de sumergirnos en el formato de metadatos de IBC, mostramos el formato del mensaje de ejecución de CosmWasm, para que el lector tenga una idea de cuáles son los campos que debemos configurar. CosmWasm MsgExecuteContractse define aquí como el siguiente tipo:

// HookData defines a wrapper for wasm execute message
// and async callback.
type HookData struct {
 // Message is a wasm execute message which will be executed
 // at `OnRecvPacket` of receiver chain.
 Message *wasmtypes.MsgExecuteContract `json:"message,omitempty"`

 // AsyncCallback is a contract address
 AsyncCallback string `json:"async_callback,omitempty"`
}

type MsgExecuteContract struct {
 // Sender is the actor that committed the message in the sender chain
 Sender string
 // Contract is the address of the smart contract
 Contract string
 // Msg json encoded message to be passed to the contract
 Msg RawContractMessage
 // Funds coins that are transferred to the contract on execution
 Funds sdk.Coins
}

Así que detallamos de dónde queremos obtener cada uno de estos campos:

  • Remitente: No podemos confiar en el remitente de un paquete IBC, la cadena de contraparte tiene plena capacidad de mentir al respecto. No podemos arriesgarnos a que este remitente sea confundido con un usuario o dirección de módulo en particular en Osmosis. Entonces reemplazamos el remitente con una cuenta para representar al remitente con el prefijo del canal y un prefijo de módulo wasm. Esto se hace configurando el remitente en Bech32(Hash("ibc-wasm-hook-intermediary" || channelID || sender)), donde channelId es la identificación del canal en la cadena local.

  • Contrato: este campo debe obtenerse directamente de los metadatos del paquete ICS-20.

  • Mensaje: este campo debe obtenerse directamente de los metadatos del paquete ICS-20.

  • Fondos: este campo está configurado para la cantidad de fondos que se envían en el paquete ICS 20. Un detalle es que el nombre en el paquete es la representación de la cadena de contraparte del nombre, por lo que tenemos que traducirlo a la representación de Osmosis.

Debido a un error en el middleware de reenvío de paquetes, no podemos confiar en el remitente de las cadenas que utilizan PFM. Hasta que esto se solucione, recomendamos a las cadenas que no confíen en el remitente en los contratos ejecutados a través de ganchos IBC.

Entonces nuestro mensaje CosmWasm construido que ejecutamos se verá así:

msg := MsgExecuteContract{
 // Sender is the that actor that signed the messages
 Sender: "init1-hash-of-channel-and-sender",
 // Contract is the address of the smart contract
 Contract: packet.data.memo["wasm"]["contract"],
 // Msg json encoded message to be passed to the contract
 Msg: packet.data.memo["wasm"]["msg"],
 // Funds coins that are transferred to the contract on execution
 Funds: sdk.NewCoin{Denom: ibc.ConvertSenderDenomToLocalDenom(packet.data.Denom), Amount: packet.data.Amount}
}

Estructura del paquete ICS20

Entonces, dados los detalles anteriores, propagamos la estructura de datos del paquete ICS20 implícita. ICS20 es JSON nativo, por lo que usamos JSON para el formato de nota.

{
    //... other ibc fields that we don't care about
    "data":{
     "denom": "denom on counterparty chain (e.g. uatom)",  // will be transformed to the local denom (ibc/...)
        "amount": "1000",
        "sender": "addr on counterparty chain", // will be transformed
        "receiver": "contract addr or blank",
        "memo": {
           "wasm": {
              "contract": "init1contractAddr",
              "msg": {
                "raw_message_fields": "raw_message_data",
              },
              "funds": [
                {"denom": "ibc/denom", "amount": "100"}
              ]
            }
        }
    }
}

Un paquete ICS20 está formateado correctamente para wasmhooks si se cumple lo siguiente:

  • memono esta en blanco

  • memoes JSON válido

  • memotiene al menos una clave, con valor"wasm"

  • memo["wasm"]["message"]tiene exactamente dos entradas "contract", "msg"y"fund"

  • memo["wasm"]["message"]["msg"]es un objeto JSON válido

  • receiver == "" || receiver == memo["wasm"]["contract"]

Consideramos que un paquete ICS20 está dirigido a wasmhooks si se cumple todo lo siguiente:

  • memono esta en blanco

  • memoes JSON válido

  • memotiene al menos una clave, con nombre"wasm"

Si un paquete ICS20 no está dirigido a wasmhooks, wasmhooks no hace nada. Si un paquete ICS20 se dirige a wasmhooks y tiene un formato incorrecto, wasmhooks devuelve un error.

Flujo de ejecución

Ganchos previos al lavado:

  • Asegúrese de que el paquete IBC entrante sea criptográficamente válido

  • Asegúrese de que el paquete IBC entrante no haya agotado el tiempo de espera.

En los ganchos Wasm, ejecución previa del paquete:

  • Asegúrese de que el paquete esté formateado correctamente (como se define anteriormente)

  • Edite el receptor para que sea la cuenta del módulo IBC codificada

En los ganchos wasm, publique la ejecución del paquete:

  • Construya el mensaje wasm como se definió anteriormente

  • Ejecutar mensaje wasm

  • si el mensaje wasm tiene error, devuelve ErrAck

  • de lo contrario, continúe a través del middleware

Confirmar devoluciones de llamada

Es posible que un contrato que envía una transferencia IBC necesite escuchar el ACK de ese paquete. Para permitir que los contratos escuchen el acuse de recibo de paquetes específicos, proporcionamos devoluciones de llamada de acuse de recibo.

Diseño

El remitente de un paquete de transferencia IBC puede especificar una devolución de llamada para cuando se reciba el acuse de recibo de ese paquete en el campo memo del paquete de transferencia.

Fundamentalmente, sólo el remitente del paquete IBC puede configurar la devolución de llamada.

Caso de uso

La implementación de intercambios entre cadenas envía una transferencia IBC. Si la transferencia falla, queremos permitir que el remitente pueda recuperar sus fondos (que de otro modo quedarían atrapados en el contrato). Para hacer esto, permitimos a los usuarios recuperar los fondos después de que haya pasado el tiempo de espera, pero sin la información de confirmación, no podemos garantizar que el envío no haya fallado (es decir, devolvió una confirmación de error notificando que el cambio recibido no lo aceptó). )

Implementación

Información de devolución de llamada en memo

Para que se procese la devolución de llamada, la nota del paquete de transferencia debe contener lo siguiente en su JSON:

{
  "wasm": {
    "async_callback": "init1contractAddr"
  }
}

Cuando se recibe un reconocimiento, notificará al contrato especificado mediante un mensaje sudo.

Interfaz para recibir los Acks y Timeouts

El contrato que espera la devolución de llamada debe implementar la siguiente interfaz para un mensaje sudo:

#[cw_serde]
pub enum IBCLifecycleComplete {
    #[serde(rename = "ibc_ack")]
    IBCAck {
        /// The source channel (miniwasm side) of the IBC packet
        channel: String,
        /// The sequence number that the packet was sent with
        sequence: u64,
        /// String encoded version of the ack as seen by OnAcknowledgementPacket(..)
        ack: String,
        /// Weather an ack is a success of failure according to the transfer spec
        success: bool,
    },
    #[serde(rename = "ibc_timeout")]
    IBCTimeout {
        /// The source channel (miniwasm side) of the IBC packet
        channel: String,
        /// The sequence number that the packet was sent with
        sequence: u64,
    },
}

/// Message type for `sudo` entry_point
#[cw_serde]
pub enum SudoMsg {
    #[serde(rename = "ibc_lifecycle_complete")]
    IBCLifecycleComplete(IBCLifecycleComplete),
}

Conclusión

El gancho Wasm representa un avance en la interoperabilidad, ya que permite funcionalidades perfectas entre cadenas y mejora la utilidad de las transferencias de tokens. Al aprovechar el gancho Wasm, los desarrolladores pueden iniciar interacciones contractuales complejas en diferentes cadenas, fomentando nuevos casos de uso y aplicaciones. Este desarrollo no solo simplifica las barreras técnicas previamente asociadas con las comunicaciones entre cadenas, sino que también allana el camino para ecosistemas blockchain más integrados y eficientes. A medida que esta tecnología madure, sin duda desbloqueará un mayor potencial para aplicaciones descentralizadas, contribuyendo a una adopción más amplia y a la eficacia operativa de las tecnologías blockchain.

PreviousInteractuando con Oracle en WasmVMNextFábrica de fichas

Last updated