Multi-Sig

Create a Safe multi-signature wallet on peaq with the Safe Protocol Kit. Add owners and execute transactions with multiple approvals.

A multi-signature (multi-sig) wallet requires several owners to approve a transaction before it executes. Safe, formerly Gnosis Safe, is the most widely used multi-sig implementation on EVM chains, and its contracts are deployed on peaq. This guide creates a Safe programmatically with the Safe Protocol Kit, adds an owner, and executes a transaction.

Prerequisites

• Basic knowledge of blockchain development and JavaScript/TypeScript.
• Familiarity with ethers.js.
• An RPC URL for the peaq network.
• Private keys for at least two owners, so you can meet the approval threshold.

Instructions

1. Set up your environment

• Install the dependencies:

npm install ethers @safe-global/protocol-kit dotenv

• Add the following to your package.json so the imports below work as ESM:

"type": "module",

• Configure a .env file:

RPC_URL=https://quicknode1.peaq.xyz
PRIVATE_KEY=first_owner_private_key
SECOND_OWNER_PRIVATE_KEY=second_owner_private_key

2. Predict the Safe address

Initialize the Protocol Kit with the owners and the threshold. Safe addresses are deterministic, so you get the address before the Safe exists on chain. Replace 0xAddress1 and 0xAddress2 with the addresses derived from PRIVATE_KEY and SECOND_OWNER_PRIVATE_KEY, so both signing keys belong to owners:

import { ethers } from 'ethers';
import Safe from '@safe-global/protocol-kit';
import dotenv from 'dotenv';

dotenv.config();

const owners = [
    '0xAddress1',
    '0xAddress2',
    '0xAddress3'
];
const threshold = 2; // Number of approvals required

const predictedSafe = await Safe.init({
    provider: process.env.RPC_URL,
    signer: process.env.PRIVATE_KEY,
    predictedSafe: {
        safeAccountConfig: { owners, threshold }
    }
});

const safeAddress = await predictedSafe.getAddress();
console.log(`Safe address: ${safeAddress}`);

3. Deploy the Safe

createSafeDeploymentTransaction builds the deployment transaction. Send it with your own signer, then connect the Protocol Kit to the deployed address:

const deploymentTransaction = await predictedSafe.createSafeDeploymentTransaction();

const provider = new ethers.JsonRpcProvider(process.env.RPC_URL);
const signer = new ethers.Wallet(process.env.PRIVATE_KEY, provider);

const response = await signer.sendTransaction({
    to: deploymentTransaction.to,
    value: BigInt(deploymentTransaction.value),
    data: deploymentTransaction.data
});
await response.wait();

const protocolKit = await predictedSafe.connect({ safeAddress, signer: process.env.PRIVATE_KEY });
console.log(`Multi-sig wallet deployed at: ${safeAddress}`);

4. Add an owner

Adding an owner is a Safe transaction, so it needs the same number of approvals as any other. With a threshold of 2, a second owner signs and the first owner executes:

const safeTransaction = await protocolKit.createAddOwnerTx({
    ownerAddress: '0xNewOwnerAddress',
    threshold: 2
});

const secondOwnerKit = await Safe.init({
    provider: process.env.RPC_URL,
    signer: process.env.SECOND_OWNER_PRIVATE_KEY,
    safeAddress
});
const signedTransaction = await secondOwnerKit.signTransaction(safeTransaction);

const result = await protocolKit.executeTransaction(signedTransaction);
console.log(`Transaction hash: ${result.hash}`);

executeTransaction counts the executing owner’s own approval. If the signatures still fall short of the threshold, it throws There are X signatures missing.

5. Fund the Safe

Send at least 0.1 PEAQ to the Safe before the transfer in the next step. The sending owner also needs PEAQ to pay transaction fees. Using the signer and Safe address from step 3:

const fundingTransaction = await signer.sendTransaction({
    to: safeAddress,
    value: ethers.parseEther('0.1')
});
await fundingTransaction.wait();

6. Execute a transaction

Sending PEAQ out of the funded Safe follows the same pattern:

const transferTransaction = await protocolKit.createTransaction({
    transactions: [
        {
            to: '0xRecipientAddress',
            value: ethers.parseEther('0.1').toString(), // Amount in PEAQ
            data: '0x'
        }
    ]
});

const signedTransfer = await secondOwnerKit.signTransaction(transferTransaction);
const transferResult = await protocolKit.executeTransaction(signedTransfer);
console.log(`Transaction executed. Hash: ${transferResult.hash}`);

Summary

You created a Safe on peaq, added an owner, and executed a transfer, all from code. The same Safe can be opened in a front end or driven from a script, and every transaction keeps needing the number of owner approvals you set as the threshold.