Generación de firma EIP-721 fuera de la cadena utilizando Ruby y validación en la cadena utilizando Solidity.

Answer

1. 

   davy.ai

   August 2, 2023 at 7:38 am

   Para generar firmas EIP-712 en un backend de Ruby on Rails, se puede utilizar la gema ethers-ruby, la cual proporciona una forma de crear y verificar firmas EIP-712.

   Aquí tienes una implementación de ejemplo:

   1. Instala la gema ethers-ruby:

   gem 'ethers-ruby'
   

   1. Requiere las librerías necesarias:

   require 'eth'
   require 'eth/signer'
   require 'eth/abi/encoder'
   

   1. Define el separador de dominio y el esquema del mensaje:

   domain_separator = {
     name: 'Nombre del Proyecto',
     version: '1',
     chainId: 1,
     verifyingContract: '0x1234...'
   }
   
   message_schema = {
     'address' => 'address',
     'amount' => 'uint256',
     'nonce' => 'uint256'
   }
   

   1. Define una función para generar el hash EIP-712:

   def generate_eip712_hash(domain_separator, message_schema, data)
     Eth::Utils.keccak256(
       [
         '0x1901', # Encabezado EIP-191
         Eth::Utils.keccak256(
           Eth::ABI::Encoder.encode(
             [
               {
                 type: 'bytes32',
                 name: 'DomainSeparator'
               },
               {
                 type: 'bytes32',
                 name: 'Message'
               }
             ],
             [
               Eth::Utils.keccak256(
                 Eth::ABI::Encoder.encode(
                   [
                     {
                       type: 'string',
                       name: 'name'
                     },
                     {
                       type: 'string',
                       name: 'version'
                     },
                     {
                       type: 'uint256',
                       name: 'chainId'
                     },
                     {
                       type: 'address',
                       name: 'verifyingContract'
                     }
                   ],
                   [
                     domain_separator[:name],
                     domain_separator[:version],
                     domain_separator[:chainId],
                     domain_separator[:verifyingContract]
                   ]
                 )
               ),
               Eth::Utils.keccak256(
                 Eth::ABI::Encoder.encode(
                   Eth::ABI::Types::Utils.camelize(message_schema),
                   data
                 )
               )
             ]
           )
         )
       ]
     )
   end
   

   1. Define una función para firmar el hash EIP-712:

   def sign_eip712_hash(private_key, domain_separator, message_schema, data)
     signer = Eth::Signer.new(private_key)
     eip712_hash = generate_eip712_hash(domain_separator, message_schema, data)
     signature = signer.sign(eip712_hash)
     {
       v: signature.v,
       r: signature.r,
       s: signature.s
     }
   end
   

   1. Llama a la función sign_eip712_hash con la clave privada, el separador de dominio, el esquema del mensaje y los datos:

   private_key = Eth::Key.new(priv: '...')
   data = {
     'address' => '0x1234...',
     'amount' => 100,
     'nonce' => 0
   }
   signature = sign_eip712_hash(private_key, domain_separator, message_schema, data)
   

   El objeto signature resultante se puede pasar como argumento signature a la función claim del contrato inteligente para su validación.

Comments are closed.