Parceros
  • 👽Recursos
    • 💻Nodos validadores
      • Buenas prácticas y seguridad de un validador
      • Montaje de nodo validador de Stargaze
      • Montaje de nodo validador de Tgrade
      • Montaje de nodo validador de Juno
      • Instalacion del Cosmovisor
      • Instalación de AutoCompound
      • Guía de instalación Prometheus y Grafana para un Validador
    • 🎓Desarrollo
      • Fundamentos en Gnu/Linux
      • Fundamentos en Blockchain
      • Billeteras
      • Introducción a Cosmos Hub
      • Guia de Inicio en Rust
      • Clases de CosmWasm
        • Introducción a CosmWasm
        • Puntos de entrada de un contrato vacio
        • Consultas - Query
      • Clases de Rust
        • Introducción a Rust
        • Ciclos
        • Funciones
        • Manejo de la memoria
        • Tipos de datos avanzados
        • Macros
        • Manejo de paquetes
        • Manejo de errores
      • Guia Archway
        • Instalación de requisitos
        • Configuración del proyecto
        • Solicitud de tokens Testnet
        • Mi primera app
          • Configuracion
          • Produciendo ejecutables wasm
          • Despliegue e instanciación de contratos en la cadena
          • Interactuar con su contrato
          • Construir el frontend de la dApp
        • Proyecto NFT
          • Creando un proyecto NFT
          • Despliegue del contrato de tokens
          • Acuñación y envío de tokens
          • Construye la Dapp NFT
        • Fee Grant
          • Comprendiendo los Fee grant
          • Grant asignación
          • Utilizando asignaciones grant
        • Multifirmas
          • Archway multi firma hub
          • Navegar por la interfaz multi firmas
      • Cosmwasm Documentacion
        • Introducción
        • Primeros pasos
          • Introducción
          • Configuración del entorno
          • Elaborar un contrato
          • Test Unitarios
          • Despliegue e interacción
          • Integración con contratos inteligentes
          • Próximos pasos
        • Arquitectura
          • ¿Qué son los contratos multicadena?
          • Modelo de actor para las convocatorias de contratos
          • Nombres y direcciones
          • Consulta del estado del contrato
          • Formatos de serialización
          • Composición del contrato
          • Comparación con los contratos de solidity
        • Contratos inteligentes
          • Semántica contractual
          • Message
            • Messages
            • Submensajes
          • State
            • Simple state
            • Complex state y maps
          • Result y option
          • Entry points
          • Query
          • Events
          • Math
          • Verificación de contratos inteligentes
          • Migration
          • Migrar una dapp a una red diferente
          • Testing
          • Ejecución Sudo
          • CosmWasm y CIB
        • Tutoriales
          • Opcion simple
            • Testing
          • Storage
            • ¿Cómo funciona el almacenamiento de valores clave?
            • Índices
            • Modelización avanzada de estados
          • Cosmwasm con ejemplos
            • Operaciones matemáticas de Cosmowasm
            • Crear una instancia de un contrato CosmWasm
            • Timelock
            • Contrato Crowdfunding
            • Respuestas y atributos en Cosmwasm
            • Lee y escribe
            • Envío de tokens
            • Token Vaults
            • Creador de mercado automático de productos constantes (AMM)
      • Guia Celestia
        • Descripcion general de celestia
          • Introduccion
          • Blockchains monolíticos vs modulares
          • Capa de disponibilidad de datos
            • La capa de disponibilidad de datos de Celestia
            • El ciclo de vida de una transacción celestia-app
            • Recuperabilidad de datos y poda
            • Disponibilidad de datos FAQ
          • Recursos adicionales
            • Aprende modular
            • Glosario de Celestia
            • Especificaciones de aplicación de celestes
            • Documentación API de nodo celestial
        • Ejecutar un nodo
          • Descripción general de los nodos en ejecución en Celestia
          • Guía de inicio rápido
            • Decidir qué nodo ejecutar
            • Entorno de desarrollo
            • Instalar celestia-node
            • Instalar celestia-app
            • 🐳 Configuración de Docker
          • Redes
            • Resumen de redes
            • Mainnet Beta
            • Mocha testnet
            • Arábica devnet
          • Tipos de nodos
            • Disponibilidad de datos
              • Nodo ligero
              • Nodo completo
              • Nodo puente
            • Consenso
            • Relay de IBC
              • Guía de retransmisión IBC
              • Relays de IBC
          • Recursos
            • nodo-celestia
              • Metricas
              • guía config.toml
              • Redes y valores personalizados
              • Solución de problemas
            • celestia-app
              • Especificaciones
              • Métricas, visualización y alertas
              • Mecánica de corte
              • Crear un testnet Celestia
              • Comandos CLI útiles
              • Monitor de Actualización
              • Carteras en celestia-app
              • Multisig
              • Crea una cuenta de adquisición
            • SystemD
            • Proceso de hardfork
        • Desarrolladores
          • Construir modular
          • Envío de blobs de datos a Celestia
          • Directrices de reenvío de transacciones
          • API de nodo
            • Celestia-node RPC CLI tutorial
            • Documentación de la API RPC de Celestia-Node
            • Rápido Scavenger
            • Page
          • Integrar con Blobstream
            • Descripción general de Blobstream
            • Integrarse con contratos de Blobstream
            • Integrar con el cliente Blobstream
            • Consultando las pruebas de Blobstream
            • Operadores locales de Blobstream X
              • Solicitar rangos de compromiso de datos
              • Nuevas implementaciones de Blobstream X
          • Implementar un rollup
            • L2s Ethereum
              • Ethereum fallback
              • Arbitro
                • Introducción a los rollups de Arbitrum con Celestia como DA
                • Implementar un arbitrum rollup devnet
                • Testnet de nitrógeno
                • Implementar un contrato inteligente sobre la implementación de Arbitrum
                • Implemente un dapp en su devnet Arbitrum rollup
                • Optimismo
                  • Introducción a la integración de OP Stack
                  • Bubs testnet
                  • Implemente un contrato inteligente en Bubs testnet
                  • Implemente un dapp en Bubs testnet
                  • Implemente un devnet OP Stack
                  • Implemente un devnet OP Stack en Celestia
                  • Auditoría
                  • Implemente un dapp con thirdweb
                  • Rollups-as-a-Servicio
                    • Caldera
            • Rollkit
            • Astria
              • Documentación
              • Implementar a Dusknet
            • SDK Soberano
            • Vistara
            • Dimensión
          • Carteras
            • Crea una billetera con celestia-node
            • Integraciones de billeteras con Celestia
          • Integre Celestia para proveedores de servicios
      • Unión
        • Arquitectura
          • CometBLS
          • Galois
          • Voyager
        • Conceptos
          • BLS Firmas
          • Clientes de Luz Condicional
          • Verificación de Consenso
          • Tecnología de validador distribuido
          • IBC
          • Sin permiso versus sin confianza
        • Infraestructura
          • Operador de nodo
            • Empezando
            • Docker Compose
            • Kubernetes
            • NixOS
            • Configuración del Nodo
        • Integracion
          • IBC Enabled Solidity
        • Demostrar
          • Dirigiendo el Union Devnet
          • PingPong
        • Unirse al testnet
          • Empezando
          • Ejecutar el binario cliente
          • Ejecución de Unionvisor
          • Obteniendo Tokens Testnet
          • Crear un Validador
          • Endpoints publicos
          • Sincronización de estado
          • Liberar un validador
          • Preguntas frecuentes
          • Historial de actualizaciones
        • Guia de estilo
          • Lista de palabras
      • Avail
        • Introducción a Avail
          • Aprovechar DA
          • Aprovechar Nexus
          • Aprovechar la fusión
        • Informacion de red
        • Más información sobre disponibilidad
          • El conseso
            • BABE
            • GRANDPA
            • NPoS
          • EIP-4844 y disponible
        • Guia de nuevo usuario
          • Cómo crear y administrar una cuenta disponible
          • Cómo utilizar el Explorador Goldberg Testnet
          • Cómo utilizar el faucet Testnet
          • Cómo establecer una identidad en cadena
          • Cómo generar una identificación de aplicación disponible
          • Cómo realizar transferencias de saldo disponibles
          • Cómo crear grupos de nominaciones disponibles
        • Construir con disponibilidad
          • Cree un paquete acumulativo con Avail
          • Comience con Avail
          • Optimium
            • OP Stack
            • Aprovechando la pila OP con Avail
            • Cómo utilizar la pila OP con Avail
            • Adaptador de pila OP 🔗
          • Validium
            • Polygon zkEVM
              • Construyendo sobre Polygon zkEVM con Avail
              • Cómo utilizar Polygon zkEVM con Avail
              • Nodo Validium 🔗
              • Contratos de Validium 🔗
              • Puente Validium 🔗
            • Madara Starknet
              • Construyendo sobre Madara Stack con Avail
              • Cómo utilizar Madara con Avail
              • Madara Starknet🔗
            • Referencia
          • Sovereign Rollups
            • Sovereign SDK 🔗
            • Rollkit 🔗
            • OpEVM 🔗
        • Glosario
        • Preguntas generales frecuentes
      • Dymension
        • Aprender
          • ELI5
          • RollApps
            • RollApps
            • Tokens
            • Gobernancia
            • Puente
            • En profundidad
              • Dymension RDK
                • Dymint
              • Gobernanza
                • Gobernador
                  • Descripción general
                  • Crear gobernador
                  • Otros comandos
                • Votación
                  • Parámetros ajustables
                  • Gasto comunitario
                  • Registro de tokens ERC-20
              • IBC Puente
                • Visión general
                • Seguridad
                • Retransmisores
          • Dymension
            • Visión general
            • DYM
              • Supply
              • Demanda
              • Crecimiento
              • Distribución
            • Seguridad
              • Estándares
              • Actualizable
              • Disponibilidad de datos
              • Pruebas de fraude
              • Resistencia a la censura
              • Page 1
            • Puentes
              • IBC
              • eIBC
            • Liquidez
              • Descripción general
              • Depositar tokens
              • Vinculación de tokens LP
              • Incentivos
              • Comisiones
            • Gobernanza
              • Descripción general
              • Preparando una propuesta
              • Proponiendo a la dimocracia
        • Construir
          • Descripción general
          • Testnet
            • EVM
              • Descripción general
            • CosmWasm
              • Descripción general
              • Información
              • Ejemplo de cosmoWasm
          • Roller CLI
            • Descripción general
            • Comenzar
              • Instalar
              • Inicializar RollApp
              • Registro
              • Correr
                • Simple
                • Avanzado
                  • Cliente ligero DA
                  • Secuenciador
                  • Retransmisor
            • Nodo en ejecución
              • Ejecutando en producción
              • Supervisión
              • Información de RollApp
              • Exportar claves
              • Mejora
              • Editar la configuración de RollApp
              • Sincronización de estado
            • Solución de problemas
              • Descripción general
              • Saldos
              • Hardware
              • Rollapp de importación/exportación
              • Acceso externo
              • Estado
              • Archivos de registro
            • RollApp local
              • Ejecute la aplicación EVM RollApp
              • Ejecute la aplicación CosmWasm RollApp
        • Validar
          • Preguntas frecuentes sobre nodos
          • Construir dimensión
          • Configuración de nodo
          • Únase a una red
          • Nodo de sincronización
          • Validador
          • Actualizaciones
          • Solución de problemas
          • Programa de delegación
            • objetivos del programa
            • Parámetros de evaluación
            • Solicitud
      • Movement
        • Desarrolladores
          • Inicio rápido
          • Configuración
            • Usando contenedores
            • Usando el instalador
          • Tutoriales
            • Desplegar
              • Módulo Aptos
              • Módulo Sui
              • Contratos EVM
                • Implementación de contratos de solidez en movimiento utilizando Foundry y Fractal
                • Implementación de contratos de solidez en M1 usando Hardhat y Fractal
                • Implementación de contratos inteligentes de Solidity en M1 utilizando el tiempo de ejecución Fractal
            • Ejecute MoveVM
              • Ejecutando M1 usted mismo
            • Construir dApp
              • Aptos Move dApp
              • Aplicación Sui Move
              • DApp de solidity
            • Interoperar
              • AptosVM<>MEVM
          • Herramientas de desarrollo
            • Movement CLI
              • Movement aptos
                • cuenta
                  • crear
                  • crear-cuenta-de-recursos
                    • derivar-dirección-de-cuenta-de-recursos
                  • fondo-con-grifo
                  • lista
                  • dirección de búsqueda
                  • rotar llave
                  • transferir
                • configuración
                  • generar-compleciones-de-shell
                  • configurar-global-config
                  • show-global-config
                  • mostrar-perfiles
                • génesis
                  • generar-admin-escritura-conjunto
                  • generar-génesis
                  • obtener direcciones de grupo
                  • generar-claves
                  • generar-plantilla-de-diseño
                  • configuración-git
                  • configuración-del-validador-de-conjuntos
                • gobernancia
                  • proponer
                  • votar
                  • propuesta de show
                  • lista-propuestas
                  • verificar-propuesta
                  • ejecutar propuesta
                  • generar-propuesta-de-actualización
                  • aprobar-ejecución-hash
                • información
                • init
                • llave
                  • generar
                  • extraer-peer
                • mover
                  • construir-publicar-carga útil
                  • limpio
                  • compilar
                  • script de compilación
                  • cobertura
                    • resumen
                    • fuente
                    • código de bytes
                  • crear-cuenta-de-recursos-y-publicar-paquete
                  • desmontar
                  • documento
                  • descargar
                  • init
                  • list
                  • probar
                  • publicar
                  • correr
                  • ejecutar guión
                  • prueba
                  • prueba transaccional
                  • verificar-paquete
                  • vista
                • multifirma
                  • aprobar
                  • crear
                  • crear-transacción
                  • ejecutar
                  • ejecutar-rechazar
                  • ejecutar con carga útil
                  • rechazar
                  • verificar-propuesta
                • nodo
                  • analizar-validador-rendimiento
                  • arranque-db
                  • verificar-conectividad-de-red
                  • conseguir-participación-pool
                  • inicializar-validador
                  • conjunto de validadores de unión
                  • conjunto de validadores de licencia
                  • mostrar-información-de-época
                  • mostrar-validador-config
                  • mostrar-conjunto-validador
                  • mostrar-validador-participación
                  • ejecutar-testnet-local
                  • actualización-clave-de-consenso
                  • actualizar-validador-direcciones-de-red
                • apostar
                  • agregar apuesta
                  • crear-contrato-de-participación
                  • distribuir-monedas-adquiridas
                  • aumentar-bloqueo
                  • inicializar-propietario de la participación
                  • solicitud-comisión
                  • establecer-votante-delegado
                  • operador de conjunto
                  • desbloquear-apuesta
                  • desbloquear-monedas-adquiridas
                  • retirar-apuesta
                • actualizar
              • movement sui
                • comenzar
                • génesis
                • ceremonia-genesis
                  • init
                  • estado de validación
                  • agregar-validador
                  • validadores de lista
                  • punto de control de compilación sin firmar
                  • examinar-punto-de-control-génesis
                  • verificar y firmar
                  • finalizar
                • herramienta clave
                  • convertir
                  • decodificar-tx-bytes
                  • decodificar-multi-sig
                  • generar
                  • importar
                  • lista
                  • par de claves de carga
                  • dirección multifirma
                  • multi-sig-combinar-sig-parcial
                  • herencia-sig-parcial-combinada-multi-sig
                  • espectáculo
                  • firmar
                  • señal-kms
                  • deshacer
                  • zk-login-firmar-y-ejecutar-tx
                  • zk-login-ingresar-token
                  • zk-login-sig-verificar
                  • zk-login-signo-inseguro-mensaje-personal
                • consola
                • cliente
                  • dirección activa
                  • entorno-activo
                  • direcciones
                  • llamar
                  • identificador de cadena
                  • campo dinámico
                  • env
                  • ejecutar-tx firmado
                  • gas
                  • fusionar moneda
                  • nueva direccion
                  • nuevo-ambiente
                  • objeto
                  • objetos
                  • pagar
                  • pago todo-sui
                  • pay-sui
                  • publicar
                  • moneda dividida
                  • cambiar
                  • bloque tx
                  • transferir
                  • transferencia-sui
                  • mejora
                  • verificar-bytecode-metro
                  • verificar-fuente
                  • transacción-repetición
                  • lote de repetición
                  • punto de control de repetición
                • validador
                  • hacer-información-validador
                  • convertirse en candidato
                  • comité conjunto
                  • comité de licencia
                  • metadatos de visualización
                  • actualizar-metadatos
                    • nombre
                    • descripción
                    • URL de la imagen
                    • URL del proyecto
                    • dirección de red
                    • dirección primaria
                    • dirección-trabajador
                    • dirección-p2p
                    • clave-pub-de-red
                    • clave-pub-trabajador
                    • protocolo-pub-clave
                  • actualizar-precio-de-gas
                  • validador de informes
                  • serializar-carga útil-pop
                  • mostrar-actualización-del-precio-del-gas-raw-txn
                • move
                  • construir
                  • cobertura
                    • resumen
                    • fuente
                    • código de bytes
                  • desmontar
                  • nuevo
                  • probar
                  • prueba
                • simulacro de incendio
                  • rotación de metadatos
              • movement ctl
              • movement manage
            • fractales
              • marco evm
          • Desarrolladores Aptos
            • Configurar la CLI de Aptos
            • Usando la CLI de Aptos
          • Desarrolladores Sui
            • Configurar Sui CLI
            • Usando Sui CLI
          • Preguntas más frecuentes
        • Ecosistema
          • Wallets
          • Tokens
          • Faucet
          • Move idioma
            • Módulos y scripts
            • Tipos primitivos
              • Enteros
              • booleano
              • DIRECCIÓN
              • Vector
              • Firmante
              • Referencias
              • Tuplas y unidad
          • Recursos de aprendizaje
          • Techpedia
            • Paralelización
            • Mover recursos
            • SDK de movement
      • Initia
        • ACERCA DE
          • Bienvenido a Inicia
          • Arquitectura Omnitia
            • Inicia (Capa 1)
            • Minitia (Capa 2)
          • Ciclo de vida de la transacción
          • Liquidez y apuestas consagradas
            • IniciaDEX
          • Programa de intereses adquiridos
        • CONSTRUIR SOBRE LA INICIATIVA
          • iniciado
          • inicia.js
          • Creando cuenta
          • Tutoriales específicos de VM
            • MoverVM
              • Implementación de módulos de movimiento
              • Creando moneda de movimiento
              • Envío de moneda de movimiento
              • Creando movimiento NFT
              • Módulos relacionados con el replanteo
              • Interactuar con Oracle en MoveVM
              • Mover ganchos IBC
            • WASMVM
              • Implementación del contrato CosmWasm
              • Interactuando con Oracle en WasmVM
              • Ganchos Wasm IBC
              • Fábrica de fichas
            • EVM
              • Implementación del contrato de solidez
              • Crear un token ERC-20 personalizado
              • Consultar estados del cosmos
              • Ejecutando mensajes de Cosmos
              • Conversión de direcciones entre EVM y Cosmos
              • Conversión entre direcciones Denom y ERC-20
              • Interactuar con Oracle en EVM
              • Ganchos EVM IBC
              • Ethereum JSON-RPC
          • Tutoriales generales
            • Oráculo: Furtivo
            • Mensajes entre cadenas
            • Saltar API
            • Miniswap
              • Interactuando con Minitswap
            • Conversión entre nombres de usuario y direcciones
            • Usando el Explorador local de Initia
            • Interactuando con InitiaDEX
            • Usando el widget de billetera Initia
        • IMPLEMENTAR MINITIA
          • Empezando
            • Implementación de su propia Minitia (Capa 2)
          • Configuración
          • Implementación de una Minitia independiente
          • Implementación completa de Minitia
            • Dirigiendo la Minitia
            • Pila de OPinit
              • Módulo OPinit: OPhost y OPchild
              • Configurar robots OPinit
                • Ejecutor del puente
                • Remitente de salida
                • Desafiador
                • Envío por lotes
                  • Envío de lotes a Inicia L1
                  • Envío de lotes a Celestia
            • Relé Hermes (IBC)
            • Habilitando oráculos
          • Retroceder
          • Agregar tokens a Initia Wallet
          • Personalizando Minitia
        • EJECUTAR EL NODO DE INICIO
          • Ejecutando el nodo de inicio
          • Arrancar un nodo de inicio
          • Conéctese a la red Inicial
          • Oráculo
          • Automatización de actualizaciones de software con Cosmovisor
          • Convertirse en un validador
        • RECURSOS
          • Registro de Iniciación
          • Información de la cadena Testnet
          • Parámetros de cadena
          • Documentación de la API
          • Documentos API (MiniMove)
          • Documentos API (MiniWasm)
          • Documentos API (MiniEVM)
      • Internet Computer
        • ¡Hola, mundo!
        • Descripción general del ICP
Powered by GitBook
On this page
  1. Recursos
  2. Desarrollo
  3. Avail
  4. Construir con disponibilidad
  5. Validium

Referencia

PreviousCómo utilizar Madara con AvailNextSovereign Rollups

Last updated 1 year ago

Verificar la disponibilidad de datos en Ethereum

Para verificar la disponibilidad de datos en Ethereum, primero es necesario enviar datos a Avail como una transacción de envío de datos. Los datos enviados de esta manera se incluirán en los bloques de disponibilidad, pero no se interpretarán ni ejecutarán de ninguna manera. El envío se puede realizar utilizando Polkadot-JSuna colección de herramientas para la comunicación con cadenas basadas en Substrate (que ahora forma parte del SDK de Polkadot).

El ejemplo completo se puede encontrar en .

Ejemplo de envío de datos a Avail:

async function submitData(availApi, data, account) {  let submit = await availApi.tx.dataAvailability.submitData(data);  return await sendTx(availApi, account, submit);}

La función submitDatarecibe availApila instancia de API, dataque se enviará y accountque envía la transacción. Para crear una cuenta es necesario crear un par de llaveros para la cuenta que desea enviar los datos. Esto se puede hacer con lo que crea un par de llaveros mediante suri (el secreto puede ser una cadena hexadecimal, una frase mnemotécnica o una cadena). Después de crear un par de llaveros, es posible enviar datos en una transacción a la red Avail con . Una vez que la transacción se incluye en un bloque de disponibilidad, es posible iniciar el envío de la raíz de datos creando una transacción de envío con los parámetros:keyring.addFromUri(secret)availApi.tx.dataAvailability.submitData(data);availApi.tx.daBridge.tryDispatchDataRoot(destinationDomain, bridgeRouterEthAddress, header);

destinationDomainDominio de destino 1000.

bridgeRouterEthAddressDirección del contrato principal de enrutador de disponibilidad de datos implementado en la red Sepolia para Goldberg ( 0x305222c4DdB86FfA9fa9Aa0A479705577E3c4d33), para Kate 0xbD824890A51ed8bda53F51F27303b14EFfEbC152.

headerProporcionado desde el bloque cuando se envían los datos.

async function dispatchDataRoot(availApi, blockHash, account) {  const header = await availApi.rpc.chain.getHeader(blockHash);  let tx = await availApi.tx.daBridge.tryDispatchDataRoot(    process.env.DESTINATION_DOMAIN,    process.env.DA_BRIDGE_ADDRESS,    header,  );  return await sendTx(availApi, account, tx);}

Ejemplo de envío de datos a Avail y envío de la raíz de datos mediante Polkadot-JS.

Variables de entorno:

AVAIL_RPC= # avail network websocket urlSURI= # mnemonicDA_BRIDGE_ADDRESS= # main da bridge contract address deployed to Sepolia test network in format (Kate) 0x000000000000000000000000bD824890A51ed8bda53F51F27303b14EFfEbC152 (Goldberg) 0x000000000000000000000000305222c4DdB86FfA9fa9Aa0A479705577E3c4d33DESTINATION_DOMAIN= # destination domain is 1000DATA= # data sending to avail
Ejemplo de JavaScript raíz de datos de envío
import { ApiPromise, Keyring, WsProvider } from '@polkadot/api';import * as dotenv from 'dotenv'; dotenv.config(); /** * Creates api instance. * * @param url websocket address */async function createApi(url) {  const provider = new WsProvider(url);  return ApiPromise.create({    provider,    rpc: {      kate: {        queryDataProof: {          description: 'Generate the data proof for the given `index`',          params: [            {              name: 'transaction_index',              type: 'u32',            },            {              name: 'at',              type: 'Hash',              isOptional: true,            },          ],          type: 'DataProof',        },      },    },    types: {      AppId: 'Compact<u32>',      DataLookupIndexItem: {        appId: 'AppId',        start: 'Compact<u32>',      },      DataLookup: {        size: 'Compact<u32>',        index: 'Vec<DataLookupIndexItem>',      },      KateCommitment: {        rows: 'Compact<u16>',        cols: 'Compact<u16>',        dataRoot: 'H256',        commitment: 'Vec<u8>',      },      V1HeaderExtension: {        commitment: 'KateCommitment',        appLookup: 'DataLookup',      },      VTHeaderExtension: {        newField: 'Vec<u8>',        commitment: 'KateCommitment',        appLookup: 'DataLookup',      },      HeaderExtension: {        _enum: {          V1: 'V1HeaderExtension',          VTest: 'VTHeaderExtension',        },      },      DaHeader: {        parentHash: 'Hash',        number: 'Compact<BlockNumber>',        stateRoot: 'Hash',        extrinsicsRoot: 'Hash',        digest: 'Digest',        extension: 'HeaderExtension',      },      Header: 'DaHeader',      CheckAppIdExtra: {        appId: 'AppId',      },      CheckAppIdTypes: {},      CheckAppId: {        extra: 'CheckAppIdExtra',        types: 'CheckAppIdTypes',      },      DataProof: {        root: 'H256',        proof: 'Vec<H256>',        numberOfLeaves: 'Compact<u32>',        leafIndex: 'Compact<u32>',        leaf: 'H256',      },      Cell: {        row: 'u32',        col: 'u32',      },    },    signedExtensions: {      CheckAppId: {        extrinsic: {          appId: 'AppId',        },        payload: {},      },    },  });} /** * Sends transaction to Avail. * * @param api instance of the api * @param account sending the transaction * @param tx transaction */async function sendTx(api, account, tx) {  return new Promise(async (resolve) => {    try {      const res = await tx.signAndSend(account, (result) => {        if (result.status.isReady) {          console.log(`Txn has been sent to the mempool`);        }        if (result.status.isInBlock) {          console.log(            `Tx hash: ${result.txHash} is in block ${result.status.asInBlock}`,          );          res();          resolve(result);        }      });    } catch (e) {      console.log(e);      process.exit(1);    }  });} /** * Submitting data to Avail as a transaction. * * @param availApi api instance * @param data payload to send * @param account that is sending transaction * @returns {Promise<unknown>} */async function submitData(availApi, data, account) {  let submit = await availApi.tx.dataAvailability.submitData(data);  return await sendTx(availApi, account, submit);} /** * Sending dispatch data root transaction. * * @param availApi api instance * @param blockHash hash of the block * @param account sending transaction * @returns {Promise<unknown>} */async function dispatchDataRoot(availApi, blockHash, account) {  const destinationDomain = process.env.DESTINATION_DOMAIN;  const bridgeRouterEthAddress = process.env.DA_BRIDGE_ADDRESS;  const header = await availApi.rpc.chain.getHeader(blockHash);  console.log(`Block Number: ${header.number}`);  console.log(`State Root: ${header.stateRoot}`);  let tx = await availApi.tx.daBridge.tryDispatchDataRoot(    destinationDomain,    bridgeRouterEthAddress,    header,  );  return await sendTx(availApi, account, tx);} /** * Returns data root for the particular block. * * @param availApi api instance * @param blockHash hash of the block * @returns {Promise<(*)[]>} */async function getDataRoot(availApi, blockHash) {  const header = JSON.parse(await availApi.rpc.chain.getHeader(blockHash));  return [header.extension.v1.commitment.dataRoot, header.number];} (async function dataRootDispatch() {  const availApi = await createApi(process.env.AVAIL_RPC);  const keyring = new Keyring({ type: 'sr25519' });  const account = keyring.addFromMnemonic(process.env.SURI);  console.log('Submitting data to Avail...');   let result = await submitData(availApi, process.env.DATA, account);  const txIndex = JSON.parse(result.events[0].phase).applyExtrinsic;  const blockHash = result.status.asInBlock;  console.log(    `Transaction: ${result.txHash}. Block hash: ${blockHash}. Transaction index: ${txIndex}.`,  );   console.log('Triggering Home...');  result = await dispatchDataRoot(availApi, blockHash, account);  console.log(`Sent txn on Avail. Txn Hash: ${result.txHash}.`);  let [root, blockNum] = await getDataRoot(availApi, blockHash);  console.log('Data Root:' + root + ' and Block number: ' + blockNum);   await availApi.disconnect();})()  .then(() => {    console.log('Done');  })  .catch((err) => {    console.error(err);    process.exit(1);  });

El envío de la raíz de datos activará un puente optimista que conectará la raíz de datos con la red Ethereum. Dado que el puente es optimista, es necesario esperar 30 minutos antes de que la raíz de datos esté disponible en Ethereum.

Después de conectar con éxito la raíz de datos con el contrato principal de certificación de disponibilidad de datos en Ethereum, es posible demostrar que los datos están disponibles en la red Avail enviando una prueba Merkle al contrato de verificación. La obtención de pruebas de Avail se puede realizar mediante una llamada RPC, kate_queryDataProofpor ejemplo, availApi.rpc.kate.queryDataProof(transactionIndex, hashBlock); dónde transactionIndexestá el índice de la transacción en el bloque y hashBlockcuál es un hash del bloque en el que se incluyen los datos. Este punto final RPC devuelve DataProofun objeto que se puede utilizar para demostrar en Ethereum que los datos están disponibles en la red Avail. Ejemplo:

async function getProof(availApi, hashBlock, transactionIndex) {  const dataProof = await availApi.rpc.kate.queryDataProof(    transactionIndex,    hashBlock,  );  return dataProof;}

Datos devueltos:

DataProof: {   root: 'H256',   proof: 'Vec<H256>',   numberOfLeaves: 'Compact<u32>',   leafIndex: 'Compact<u32>',   leaf: 'H256'}

rootHash de raíz del árbol merkle generado.

proofArtículos a prueba de Merkle (no contiene el hash de hoja ni la raíz).

numberOfLeavesNúmero de hojas del árbol original.

leafIndexÍndice de la hoja para la que es la prueba (comienza desde 0).

leafHoja de la cual es la prueba.

EJEMPLO

Ejemplo de contrato de verificación
// SPDX-License-Identifier: Apache-2.0// Modified from https://github.com/QEDK/solidity-misc/blob/master/contracts/Merkle.solpragma solidity ^0.8.21; import "@openzeppelin/contracts/access/Ownable.sol";// or for foundry:// import "openzeppelin-contracts/contracts/access/Ownable.sol"; interface IDataAvailabilityRouter {    function roots(uint32 blockNumber) external view returns (bytes32 root);} contract ValidiumContract is Ownable {    IDataAvailabilityRouter private router;     function setRouter(        IDataAvailabilityRouter _router    ) public virtual onlyOwner {        router = _router;    }     function checkDataRootMembership(        uint32 blockNumber,        bytes32[] calldata proof,        uint256 width, // number of leaves        uint256 index,        bytes32 leaf    ) public view virtual returns (bool isMember) {        bytes32 rootHash = router.roots(blockNumber);        // if root hash is 0, block does not have a root (yet)        require(rootHash != bytes32(0), "INVALID_ROOT");        assembly ("memory-safe") {            if proof.length {                let end := add(proof.offset, shl(5, proof.length))                let i := proof.offset                 for {} 1 {} {                    let leafSlot := shl(5, and(0x1, index))                    if eq(add(index, 1), width) {                        leafSlot := 0x20                    }                    mstore(leafSlot, leaf)                    mstore(xor(leafSlot, 32), calldataload(i))                    leaf := keccak256(0, 64)                    index := shr(1, index)                    i := add(i, 32)                    width := add(shr(1, sub(width, 1)), 1)                    if iszero(lt(i, end)) {                        break                    }                }            }        // checks if the calculated root matches the expected root            isMember := eq(leaf, rootHash)        }    }}

Al presentar prueba al contrato de verificación es posible verificar que los datos están disponibles en Avail. La prueba de Merkle es una lista de hashes que se pueden usar para demostrar que una hoja determinada es miembro del árbol de Merkle. Se puede consultar un ejemplo de envío de una prueba al contrato de verificación implementado en la red Sepolia para Kate ( 0xA06386C65B1f56De57CE6aB9CeEB2552fa811529) y Goldberg ( 0x67044689F7e274a4aC7b818FDea64Cb4604c6875) llamando a la función de membresía raíz de datos async function checkProof(sepoliaApi, blockNumber, proof, numberOfLeaves, leafIndex, leafHash);donde

sepoliaApiInstancia de API de red Sepolia.

blockNumberNúmero de bloque de disponibilidad.

proofPrueba de Merkle para la hoja.

numberOfLeavesNúmero de hojas del árbol original.

leafIndexÍndice de la hoja del árbol Merkle.

leafHashHachís de la hoja del árbol Merkle.

Esto llamará a la función de los contratos implementados verificationContract.checkDataRootMembership(blockNumber, proof, numberOfLeaves, leafIndex, leafHash) y devolverá trueo falsedependiendo de la prueba proporcionada.

EJEMPLO DE OBTENER LA PRUEBA Y VERIFICARLA CON EL CONTRATO DE VERIFICACIÓN UTILIZANDO POLKADOT-JSY ETHERS.JS. Variables de entorno:

AVAIL_RPC= # avail websocket addressINFURA_KEY= # rpc provider key if neededVALIDIUM_ADDRESS= # address of the verification contract, one such is deployed on Sepolia network for Kate 0xA06386C65B1f56De57CE6aB9CeEB2552fa811529 or Goldberg 0x67044689F7e274a4aC7b818FDea64Cb4604c6875VALIDIYM_ABI_PATH= # path to abi file e.g. abi/ValidiumContract.jsonBLOCK_NUMBER= # number of the block for which to get Merkle proofBLOCK_HASH= # hash of the block for which to get Merkle proofTRANSACTION_INDEX= # index of the transaction in the block
Enviar ejemplo de prueba
import { ethers } from 'ethers';import * as dotenv from 'dotenv';import { hexlify } from 'ethers/lib/utils.js';import { readFileSync } from 'fs';import { ApiPromise, WsProvider } from '@polkadot/api'; dotenv.config(); /** * Creates api instance. * * @param url websocket address * @returns {Promise<ApiPromise>} */async function createApi(url) {  const provider = new WsProvider(url);   // Create the API and wait until ready  return ApiPromise.create({    provider,    rpc: {      kate: {        queryDataProof: {          description: 'Generate the data proof for the given `index`',          params: [            {              name: 'data_index',              type: 'u32',            },            {              name: 'at',              type: 'Hash',              isOptional: true,            },          ],          type: 'DataProof',        },      },    },    types: {      DataProof: {        root: 'H256',        proof: 'Vec<H256>',        numberOfLeaves: 'Compact<u32>',        leafIndex: 'Compact<u32>',        leaf: 'H256',      },    },  });} /** * Returns Merkle proof for the particular data. * * @param availApi Api instance * @param hashBlock Hash of the block * @param transactionIndex Index of the transaction in the block * @returns {Promise<*>} */async function getProof(availApi, hashBlock, transactionIndex) {  const daHeader = await availApi.rpc.kate.queryDataProof(    transactionIndex,    hashBlock,  );  console.log(    `Fetched proof from Avail for txn index ${transactionIndex} inside block ${hashBlock}`,  );  return daHeader;} /** * Checks if the provided Merkle proof is valid by checking on Ethereum deployed validation contract. * * @param sepoliaApi Sepolia network api instance * @param blockNumber Avail block number * @param proof Merkle proof for the leaf * @param numberOfLeaves Number of leaves in the original tree * @param leafIndex Index of the leaf in the Merkle tree * @param leafHash Hash of the leaf in the Merkle tree * @returns {Promise<*>} */async function checkProof(  sepoliaApi,  blockNumber,  proof,  numberOfLeaves,  leafIndex,  leafHash,) {  const abi = JSON.parse(    readFileSync(process.env.VALIDIYM_ABI_PATH).toString(),  );  const verificationContract = new ethers.Contract(    process.env.VALIDIUM_ADDRESS,    abi,    sepoliaApi,  );  return await verificationContract.checkDataRootMembership(    BigInt(blockNumber),    proof,    BigInt(numberOfLeaves),    BigInt(leafIndex),    leafHash,  );} (async function submitProof() {  // connect to Sepolia through Infura but can be used any other available provider  const sepoliaApi = new ethers.providers.InfuraProvider.getWebSocketProvider(    'sepolia',    process.env.INFURA_KEY,  );  const availApi = await createApi(process.env.AVAIL_RPC);   console.log(    `Getting proof for transaction index ${process.env.TRANSACTION_INDEX} block number ${process.env.BLOCK_NUMBER} and block hash ${process.env.BLOCK_HASH}`,  );  const daHeader = await getProof(    availApi,    process.env.BLOCK_HASH,    process.env.TRANSACTION_INDEX,  );   console.log(`Data Root: ${hexlify(daHeader.root)}`);  console.log(`Proof: ${daHeader.proof}`);  console.log(`Leaf to prove: ${hexlify(daHeader.leaf)}`);  console.log(`Leaf index : ${daHeader.leafIndex}`);  console.log(`Number of leaves: ${daHeader.numberOfLeaves}`);   const isDataAccepted = await checkProof(    sepoliaApi,    process.env.BLOCK_NUMBER,    daHeader.proof,    daHeader.numberOfLeaves,    daHeader.leafIndex,    daHeader.leaf,  );  console.log('Data is: ' + (isDataAccepted ? 'available' : 'not available'));  await availApi.disconnect();  await sepoliaApi.destroy();})()  .then(() => {    console.log('Done');  })  .catch((err) => {    console.error(err);    process.exit(1);  });
👽
🎓
github.(se abre en una nueva pestaña)