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 dive into creating EIP-1271 signatures using Safe-Safe, a popular library for interacting with the Gnosis Safe off-chain wallet.

What is EIP-1271?

EIP-1271 (Ethereum Improvement Proposal 1271) is an extension to the ERC-721 non-fungible token standard that enables multi-signature transactions. This enables secure and decentralized data storage, making it ideal for applications such as 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 to interact with various wallets, including Gnosis Safe. One of its main 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 need to follow these steps:

• Install the required library: Make sure that the safe-core and safe-safe libraries are installed in your project.

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

• Set up 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 = wait SafeCore.signers.create('myEIP1271Signature'); const sig = wait signer.sign({ de: '0x...', data: ... });

• Store and retrieve signature

  

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

Here is a sample code snippet to illustrate this process:

import { SafeCore } from '@gnosisprotocol/safe-core';
import { SafeApiClient } from 'gnosis-safe';
const safeAccount = wait SafeWallet.createAccount();
const signer = wait SafeCore.signers.create('myEIP1271Signature');
const sig = wait signer.sign({ from: '0x...', data: ... });
// Store the signature in your on-chain contract
await SafeApiClient.storeOnChainContract('myAddress', sig);
// Retrieve the stored signature
const retrievedSig = wait SafeApiClient.retrieveOnChainContract('myAddress');

Transaction Proposal with Safe-API-Kit

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

import { SafeApi } from 'safe-api-kit';
const safeAccount = wait SafeWallet.createAccount();
const signer = wait SafeCore.signers.create('myEIP1271Signature');
const contractAddress = '0x...';
const data = Buffer.from([...]);
const gasprice = 20;
const gaslimit = 100;
const proposal = {
from: '0x...' // Your address in the channel
};
const transaction = wait SafeApi.executeProposal({
SafeAccount,
Signal,
ContractAddress,
Data,
GasPrice,
GasLimit,
Proposal
});

Conclusion

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

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