Ethereum: EIP-1271 signatures with Gnosis Safe off-chain

Creating EIP-1271 Signatures with Safe-Safe: A Guide to Off-Chain Execution

As the Ethereum ecosystem continues to evolve, understanding how to deploy and execute smart contracts remains essential. In this article, we’ll delve into creating EIP-1271 signatures using Safe-Safe, a popular library for interacting with Gnosis Safe’s off-chain wallet.

What is EIP-1271?

EIP-1271 (Ethereum Improvement Proposal 1271) is an extension of the ERC-721 non-fungible token standard that allows for multi-signature transactions. This enables secure and decentralized storage of data, making it ideal for applications like identity verification, governance models, or decentralized finance (DeFi) protocols.

Safe-Safe: A Simple Library

Safe-Safe is a widely adopted off-chain wallet that provides a user-friendly interface for interacting with various wallets, including Gnosis Safe. One of its key features is the ability to sign transactions using EIP-1271 signatures.

Creating EIP-1271 Signatures Using Safe-Core

To create an EIP-1271 signature using Safe-Safe off-chain, you’ll need to follow these steps:

• Install the necessary library

  : Ensure you have the safe-core and safe-safe libraries installed in your project.

• Create a safe account: Generate a new safe account using the SafeWallet library.

• Configure Gnosis Safe: Set up Gnosis Safe as an external wallet by following these steps:

* Install the gnosis-safe package: npm install gnisosafe

* Initialize the Gnosis Safe API client: import { SafeApiClient } from 'gnosis-safe'; const safeApi = new SafeApiClient();

• Generate an EIP-1271 signature

  

  : Use the safe-core library to generate an EIP-1271 signature for a specific address:

* const signer = await SafeCore.signers.create('myEIP1271Signature'); const sig = await signer.sign({ from: '0x...', data: ... });

• Store and retrieve the signature: Store the generated signature in your on-chain contract or use it as needed.

Here’s a sample code snippet to demonstrate this process:

import { SafeCore } from '@gnosisprotocol/safe-core';

import { SafeApiClient } from 'gnosis-safe';


const safeAccount = await SafeWallet.createAccount();

const signer = await SafeCore.signers.create('myEIP1271Signature');

const sig = await signer.sign({ from: '0x...', data: ... });


// Store the signature in your on-chain contract

await SafeApiClient.storeOnChainContract('myAddress', sig);


// Retrieve the stored signature

const retrievedSig = await SafeApiClient.retrieveOnChainContract('myAddress');

Transaction Proposal with Safe-API-Kit

To execute a transaction using these EIP-1271 signatures off-chain, you’ll need to create a transaction proposal using the safe-api-kit library. Here’s an example:

import { SafeApi } from 'safe-api-kit';


const safeAccount = await SafeWallet.createAccount();

const signer = await SafeCore.signers.create('myEIP1271Signature');

const contractAddress = '0x...';

const data = Buffer.from([...]);

const gasPrice = 20;

const gasLimit = 100;


const proposal = {

  from: '0x...' // Your on-chain address

};


const transaction = await SafeApi.executeProposal({

  safeAccount,

  signer,

  contractAddress,

  data,

  gasPrice,

  gasLimit,

  proposal

});

Conclusion

Creating EIP-1271 signatures using Safe-Safe is a straightforward process that enables secure and decentralized storage of data. By following these steps, you can generate an EIP-1271 signature off-chain and execute transactions using the safe-api-kit library.

Remember to always follow best practices for securing your smart contracts, including using secure wallets and storing sensitive information safely.