@rabby-wallet/gnosis-sdk 1.0.0

package/package.json

@@ -0,0 +1,26 @@
+{
+  "name": "@rabby-wallet/gnosis-sdk",
+  "version": "1.0.0",
+  "description": "",
+  "main": "index.js",
+  "scripts": {
+    "build": "tsc"
+  },
+  "author": "",
+  "license": "ISC",
+  "dependencies": {
+    "@ethersproject/bignumber": "^5.5.0",
+    "@ethersproject/bytes": "^5.5.0",
+    "@ethersproject/contracts": "^5.5.0",
+    "@ethersproject/providers": "^5.5.0",
+    "@ethersproject/solidity": "^5.5.0",
+    "@gnosis.pm/safe-core-sdk": "^1.0.0",
+    "@gnosis.pm/safe-core-sdk-types": "^0.1.1",
+    "@gnosis.pm/safe-deployments": "^1.4.0",
+    "axios": "^0.24.0",
+    "ethereumjs-util": "^7.1.3",
+    "ethers": "^5.5.1",
+    "typescript": "^4.4.4",
+    "web3-core": "^1.6.0"
+  }
+}

package/src/api.ts

@@ -0,0 +1,101 @@
+import axios, { Axios } from "axios";
+import { toChecksumAddress } from "web3-utils";
+
+export interface SafeInfo {
+  address: string;
+  fallbackHandler: string;
+  guard: string;
+  masterCopy: string;
+  modules: string[];
+  nonce: number;
+  owners: string[];
+  threshold: number;
+  version: string;
+}
+
+interface ConfirmationItem {
+  owner: string;
+  submissionDate: string;
+  transactionHash: string | null;
+  signature: string;
+  signatureType: string;
+}
+
+interface SafeTransactionItem {
+  safe: string;
+  to: string;
+  value: string;
+  data: string | null;
+  operation: number;
+  gasToken: string;
+  safeTxGas: number;
+  baseGas: number;
+  gasPrice: string;
+  refundReceiver: string;
+  nonce: number;
+  executionDate: string | null;
+  submissionDate: string;
+  modified: string;
+  blockNumber: number | null;
+  transactionHash: string | null;
+  safeTxHash: string;
+  executor: string | null;
+  isExecuted: boolean;
+  confirmations: ConfirmationItem[];
+  signatures: string | null;
+}
+
+const HOST_MAP = {
+  '1': "https://safe-transaction.gnosis.io/api/v1",
+  '137': 'https://safe-transaction.polygon.gnosis.io/api/v1',
+  '56': 'https://safe-transaction.bsc.gnosis.io/api/v1',
+  '100': 'https://safe-transaction.xdai.gnosis.io/api/v1'
+}
+
+export default class RequestProvider {
+  host: string
+  request: Axios
+
+  constructor(networkId: string) {
+    if (!(networkId in HOST_MAP)) {
+      throw new Error('Wrong networkId')
+    }
+
+    this.host = HOST_MAP[networkId]
+
+    this.request = axios.create({
+      baseURL: this.host
+    })
+
+    this.request.interceptors.response.use((response) => {
+      return response.data;
+    });
+  }
+
+  getPendingTransactions(
+    safeAddress: string,
+    nonce: number
+  ): Promise<{ results: SafeTransactionItem[] }> {
+    return this.request.get(`/safes/${safeAddress}/multisig-transactions/`, {
+      params: {
+        executed: false,
+        nonce__gte: nonce,
+      },
+    });
+  }
+
+  postTransactions(safeAddres: string, data): Promise<void> {
+    return this.request.post(
+      `/safes/${toChecksumAddress(safeAddres)}/multisig-transactions/`,
+      data
+    );
+  }
+
+  getSafeInfo(safeAddress: string): Promise<SafeInfo> {
+    return this.request.get(`/safes/${safeAddress}/`);
+  }
+
+  confirmTransaction(hash: string, data): Promise<void> {
+    return this.request.post(`/multisig-transactions/${hash}/confirmations/`, data);
+  }
+}

package/src/constants.ts

@@ -0,0 +1,3 @@
+export const ZERO_ADDRESS = `0x${"0".repeat(40)}`;
+export const EMPTY_DATA = "0x";
+export const SENTINEL_ADDRESS = "0x0000000000000000000000000000000000000001";

package/src/index.ts

@@ -0,0 +1,260 @@
+import { Contract } from "ethers";
+import { BigNumber } from "@ethersproject/bignumber";
+import { getSafeSingletonDeployment } from "@gnosis.pm/safe-deployments";
+import { providers } from "ethers";
+import { toChecksumAddress } from "web3-utils";
+import {
+  SafeTransactionDataPartial,
+  SafeSignature,
+} from "@gnosis.pm/safe-core-sdk-types";
+import {
+  TransactionResult,
+  TransactionOptions,
+} from "@gnosis.pm/safe-core-sdk/dist/src/utils/transactions/types";
+import SafeTransaction from "@gnosis.pm/safe-core-sdk/dist/src/utils/transactions/SafeTransaction";
+import RequestProvider, { SafeInfo } from "./api";
+import {
+  standardizeSafeTransactionData,
+  sameString,
+  generateSignature,
+  generatePreValidatedSignature,
+  estimateGasForTransactionExecution,
+  toTxResult,
+} from "./utils";
+
+class Safe {
+  contract: Contract;
+  safeAddress: string;
+  owners: string[] = [];
+  version: string;
+  provider: providers.Web3Provider;
+  safeInfo: SafeInfo | null = null;
+  request: RequestProvider;
+  network: string;
+
+  constructor(
+    safeAddress: string,
+    version: string,
+    provider: providers.Web3Provider,
+    network = "1"
+  ) {
+    const contract = getSafeSingletonDeployment({
+      version,
+      network,
+    });
+    if (!contract) {
+      throw new Error("Wrong version or network");
+    }
+    this.provider = provider;
+    this.contract = new Contract(safeAddress, contract.abi, this.provider);
+    this.version = version;
+    this.safeAddress = safeAddress;
+    this.network = network;
+    this.request = new RequestProvider(network);
+    this.init();
+  }
+
+  static getSafeInfo(safeAddress: string, network: string) {
+    const request = new RequestProvider(network);
+    return request.getSafeInfo(safeAddress);
+  }
+
+  async init() {
+    const safeInfo = await Safe.getSafeInfo(this.safeAddress, this.network);
+    this.safeInfo = safeInfo;
+    if (this.version !== safeInfo.version) {
+      throw new Error(
+        `Current version ${this.version} not matched address version ${safeInfo.version}`
+      );
+    }
+    this.version = safeInfo.version;
+    this.owners = safeInfo.owners;
+  }
+
+  async getOwners(): Promise<string[]> {
+    const owners = await this.contract.getOwners();
+
+    return owners;
+  }
+
+  async getThreshold() {
+    const threshold = await this.contract.getThreshold();
+    return threshold.toNumber();
+  }
+
+  async getNonce(): Promise<number> {
+    const nonce = await this.contract.nonce();
+    return nonce.toNumber();
+  }
+
+  async getPendingTransactions() {
+    const nonce = await this.getNonce();
+    const transactions = await this.request.getPendingTransactions(this.safeAddress, nonce);
+
+    return transactions;
+  }
+
+  async buildTransaction(data: SafeTransactionDataPartial) {
+    const transaction = await standardizeSafeTransactionData(
+      this.safeAddress,
+      this.contract,
+      this.provider,
+      data
+    );
+    return new SafeTransaction(transaction);
+  }
+
+  async getTransactionHash(transaction: SafeTransaction) {
+    const transactionData = transaction.data;
+    return this.contract.getTransactionHash(
+      transactionData.to,
+      transactionData.value,
+      transactionData.data,
+      transactionData.operation,
+      transactionData.safeTxGas,
+      transactionData.baseGas,
+      transactionData.gasPrice,
+      transactionData.gasToken,
+      transactionData.refundReceiver,
+      transactionData.nonce
+    );
+  }
+
+  async signTransactionHash(hash: string): Promise<SafeSignature> {
+    const owners = await this.getOwners();
+    const signer = await this.provider.getSigner(0);
+    const signerAddress = await signer.getAddress();
+    const addressIsOwner = owners.find(
+      (owner: string) => signerAddress && sameString(owner, signerAddress)
+    );
+    if (!addressIsOwner) {
+      throw new Error("Transactions can only be signed by Safe owners");
+    }
+    return generateSignature(this.provider, hash);
+  }
+
+  async signTransaction(transaction: SafeTransaction) {
+    const hash = await this.getTransactionHash(transaction);
+    const sig = await this.signTransactionHash(hash);
+    transaction.addSignature(sig);
+  }
+
+  async getOwnersWhoApprovedTx(txHash: string): Promise<string[]> {
+    const owners = await this.getOwners();
+    let ownersWhoApproved: string[] = [];
+    for (const owner of owners) {
+      const approved = await this.contract.approvedHashes(owner, txHash);
+      if (approved.gt(0)) {
+        ownersWhoApproved.push(owner);
+      }
+    }
+    return ownersWhoApproved;
+  }
+
+  async postTransaction(transaction: SafeTransaction, hash: string) {
+    const signer = this.provider.getSigner(0);
+    const signerAddress = await signer.getAddress();
+    const safeAddress = toChecksumAddress(this.safeAddress);
+    await this.request.postTransactions(this.safeAddress, {
+      safe: safeAddress,
+      to: toChecksumAddress(transaction.data.to),
+      value: Number(transaction.data.value),
+      data: transaction.data.data,
+      operation: transaction.data.operation,
+      gasToken: transaction.data.gasToken,
+      safeTxGas: transaction.data.safeTxGas,
+      baseGas: transaction.data.baseGas,
+      gasPrice: transaction.data.gasPrice,
+      refundReceiver: transaction.data.refundReceiver,
+      nonce: transaction.data.nonce,
+      contractTransactionHash: hash,
+      sender: toChecksumAddress(signerAddress),
+      signature: transaction.encodedSignatures(),
+    });
+  }
+
+  async confirmTransaction(safeTransaction: SafeTransaction) {
+    const hash = await this.getTransactionHash(safeTransaction);
+    const signature = await this.signTransactionHash(hash);
+    safeTransaction.addSignature(signature);
+    const signer = await this.provider.getSigner(0);
+    const signerAddress = await signer.getAddress();
+    const sig = safeTransaction.signatures.get(signerAddress?.toLowerCase());
+    if (sig) {
+      await this.request.confirmTransaction(hash, { signature: sig.data });
+    }
+  }
+
+  async getBalance(): Promise<BigNumber> {
+    return this.provider.getBalance(this.safeAddress);
+  }
+
+  async executeTransaction(
+    safeTransaction: SafeTransaction,
+    options?: TransactionOptions
+  ): Promise<TransactionResult> {
+    const txHash = await this.getTransactionHash(safeTransaction);
+    const ownersWhoApprovedTx = await this.getOwnersWhoApprovedTx(txHash);
+    for (const owner of ownersWhoApprovedTx) {
+      safeTransaction.addSignature(generatePreValidatedSignature(owner));
+    }
+    const owners = await this.getOwners();
+    const signer = await this.provider.getSigner(0);
+    const contract = this.contract.connect(signer);
+    const signerAddress = await signer.getAddress();
+    if (owners.includes(signerAddress)) {
+      safeTransaction.addSignature(
+        generatePreValidatedSignature(signerAddress)
+      );
+    }
+
+    const threshold = await this.getThreshold();
+    if (threshold > safeTransaction.signatures.size) {
+      const signaturesMissing = threshold - safeTransaction.signatures.size;
+      throw new Error(
+        `There ${
+          signaturesMissing > 1 ? "are" : "is"
+        } ${signaturesMissing} signature${
+          signaturesMissing > 1 ? "s" : ""
+        } missing`
+      );
+    }
+
+    const value = BigNumber.from(safeTransaction.data.value);
+    if (!value.isZero()) {
+      const balance = await this.getBalance();
+      if (value.gt(BigNumber.from(balance))) {
+        throw new Error("Not enough Ether funds");
+      }
+    }
+
+    const gasLimit = await estimateGasForTransactionExecution(
+      contract,
+      signerAddress,
+      safeTransaction
+    );
+    const executionOptions: TransactionOptions = {
+      gasLimit,
+      gasPrice: options?.gasPrice,
+      from: signerAddress,
+    };
+
+    const txResponse = await contract.execTransaction(
+      safeTransaction.data.to,
+      safeTransaction.data.value,
+      safeTransaction.data.data,
+      safeTransaction.data.operation,
+      safeTransaction.data.safeTxGas,
+      safeTransaction.data.baseGas,
+      safeTransaction.data.gasPrice,
+      safeTransaction.data.gasToken,
+      safeTransaction.data.refundReceiver,
+      safeTransaction.encodedSignatures(),
+      executionOptions
+    )
+
+    return toTxResult(txResponse, executionOptions);
+  }
+}
+
+export default Safe;

package/src/type.ts

@@ -0,0 +1,36 @@
+import { BigNumber } from "@ethersproject/bignumber";
+import {
+  SafeTransaction,
+  SafeTransactionData,
+} from "@gnosis.pm/safe-core-sdk-types";
+import {
+  TransactionOptions,
+  TransactionResult,
+} from "@gnosis.pm/safe-core-sdk/dist/src/utils/transactions/types";
+
+export interface GnosisSafeContract {
+  getVersion(): Promise<string>;
+  getAddress(): string;
+  getNonce(): Promise<number>;
+  getThreshold(): Promise<number>;
+  getOwners(): Promise<string[]>;
+  isOwner(address: string): Promise<boolean>;
+  getTransactionHash(safeTransactionData: SafeTransactionData): Promise<string>;
+  approvedHashes(ownerAddress: string, hash: string): Promise<BigNumber>;
+  approveHash(
+    hash: string,
+    options?: TransactionOptions
+  ): Promise<TransactionResult>;
+  getModules(): Promise<string[]>;
+  isModuleEnabled(moduleAddress: string): Promise<boolean>;
+  execTransaction(
+    safeTransaction: SafeTransaction,
+    options?: TransactionOptions
+  ): Promise<TransactionResult>;
+  encode(methodName: any, params: any): string;
+  estimateGas(
+    methodName: string,
+    params: any[],
+    options: TransactionOptions
+  ): Promise<number>;
+}

package/src/utils.ts

@@ -0,0 +1,251 @@
+import { BigNumber } from "@ethersproject/bignumber";
+import { Contract, providers } from "ethers";
+import {
+  MetaTransactionData,
+  OperationType,
+  SafeTransactionData,
+  SafeTransactionDataPartial,
+  SafeSignature,
+  SafeTransaction,
+} from "@gnosis.pm/safe-core-sdk-types";
+import {
+  TransactionOptions,
+  Web3TransactionResult,
+} from "@gnosis.pm/safe-core-sdk/dist/src/utils/transactions/types";
+import { PromiEvent, TransactionReceipt } from "web3-core/types";
+import { bufferToHex, ecrecover, pubToAddress } from "ethereumjs-util";
+import { ZERO_ADDRESS, SENTINEL_ADDRESS } from "./constants";
+import EthSignSignature from "@gnosis.pm/safe-core-sdk/dist/src/utils/signatures/SafeSignature";
+
+function estimateDataGasCosts(data: string): number {
+  const reducer = (accumulator: number, currentValue: string) => {
+    if (currentValue === "0x") {
+      return accumulator + 0;
+    }
+    if (currentValue === "00") {
+      return accumulator + 4;
+    }
+    return accumulator + 16;
+  };
+  return (data.match(/.{2}/g) as string[]).reduce(reducer, 0);
+}
+
+export function sameString(str1: string, str2: string): boolean {
+  return str1.toLowerCase() === str2.toLowerCase();
+}
+
+function isZeroAddress(address: string): boolean {
+  return address === ZERO_ADDRESS;
+}
+
+function isSentinelAddress(address: string): boolean {
+  return address === SENTINEL_ADDRESS;
+}
+
+export function isRestrictedAddress(address: string): boolean {
+  return isZeroAddress(address) || isSentinelAddress(address);
+}
+
+export async function estimateTxGas(
+  safeAddress: string,
+  safeContract: Contract,
+  provider: providers.Web3Provider,
+  to: string,
+  valueInWei: string,
+  data: string,
+  operation: OperationType
+): Promise<number> {
+  let txGasEstimation = 0;
+
+  const estimateData: string = safeContract.interface.encodeFunctionData(
+    "requiredTxGas",
+    [to, valueInWei, data, operation]
+  );
+  try {
+    const estimateResponse = (
+      await provider.estimateGas({
+        to: safeAddress,
+        from: safeAddress,
+        data: estimateData,
+      })
+    ).toString();
+    txGasEstimation =
+      BigNumber.from("0x" + estimateResponse.substring(138)).toNumber() + 10000;
+  } catch (error) {}
+
+  if (txGasEstimation > 0) {
+    const dataGasEstimation = estimateDataGasCosts(estimateData);
+    let additionalGas = 10000;
+    for (let i = 0; i < 10; i++) {
+      try {
+        const estimateResponse = await provider.call({
+          to: safeAddress,
+          from: safeAddress,
+          data: estimateData,
+          gasPrice: 0,
+          gasLimit: txGasEstimation + dataGasEstimation + additionalGas,
+        });
+        if (estimateResponse !== "0x") {
+          break;
+        }
+      } catch (error) {}
+      txGasEstimation += additionalGas;
+      additionalGas *= 2;
+    }
+    return txGasEstimation + additionalGas;
+  }
+
+  try {
+    const estimateGas = await provider.estimateGas({
+      to,
+      from: safeAddress,
+      value: valueInWei,
+      data,
+    });
+    return estimateGas.toNumber();
+  } catch (error) {
+    if (operation === OperationType.DelegateCall) {
+      return 0;
+    }
+    return Promise.reject(error);
+  }
+}
+
+export async function standardizeSafeTransactionData(
+  safeAddress: string,
+  safeContract: Contract,
+  provider: any,
+  tx: SafeTransactionDataPartial
+): Promise<SafeTransactionData> {
+  const standardizedTxs = {
+    to: tx.to,
+    value: tx.value,
+    data: tx.data,
+    operation: tx.operation ?? OperationType.Call,
+    baseGas: tx.baseGas ?? 0,
+    gasPrice: tx.gasPrice ?? 0,
+    gasToken: tx.gasToken || ZERO_ADDRESS,
+    refundReceiver: tx.refundReceiver || ZERO_ADDRESS,
+    nonce: tx.nonce ?? (await safeContract.nonce()).toNumber(),
+  };
+  const safeTxGas =
+    tx.safeTxGas ??
+    (await estimateTxGas(
+      safeAddress,
+      safeContract,
+      provider,
+      standardizedTxs.to,
+      standardizedTxs.value,
+      standardizedTxs.data,
+      standardizedTxs.operation
+    ));
+  return {
+    ...standardizedTxs,
+    safeTxGas,
+  };
+}
+
+export function generatePreValidatedSignature(
+  ownerAddress: string
+): SafeSignature {
+  const signature =
+    "0x000000000000000000000000" +
+    ownerAddress.slice(2) +
+    "0000000000000000000000000000000000000000000000000000000000000000" +
+    "01";
+
+  return new EthSignSignature(ownerAddress, signature);
+}
+
+export function isTxHashSignedWithPrefix(
+  txHash: string,
+  signature: string,
+  ownerAddress: string
+): boolean {
+  let hasPrefix;
+  try {
+    const rsvSig = {
+      r: Buffer.from(signature.slice(2, 66), "hex"),
+      s: Buffer.from(signature.slice(66, 130), "hex"),
+      v: parseInt(signature.slice(130, 132), 16),
+    };
+    const recoveredData = ecrecover(
+      Buffer.from(txHash.slice(2), "hex"),
+      rsvSig.v,
+      rsvSig.r,
+      rsvSig.s
+    );
+    const recoveredAddress = bufferToHex(pubToAddress(recoveredData));
+    hasPrefix = !sameString(recoveredAddress, ownerAddress);
+  } catch (e) {
+    hasPrefix = true;
+  }
+  return hasPrefix;
+}
+
+export function adjustVInSignature(signature: string, hasPrefix: boolean) {
+  const V_VALUES = [0, 1, 27, 28];
+  const MIN_VALID_V_VALUE = 27;
+  let signatureV = parseInt(signature.slice(-2), 16);
+  if (!V_VALUES.includes(signatureV)) {
+    throw new Error("Invalid signature");
+  }
+  if (signatureV < MIN_VALID_V_VALUE) {
+    signatureV += MIN_VALID_V_VALUE;
+  }
+  if (hasPrefix) {
+    signatureV += 4;
+  }
+  signature = signature.slice(0, -2) + signatureV.toString(16);
+  return signature;
+}
+
+export async function generateSignature(
+  provider: providers.Web3Provider,
+  hash: string
+): Promise<EthSignSignature> {
+  const signer = await provider.getSigner(0);
+  const signerAddress = await signer.getAddress();
+  let signature = await provider.send("personal_sign", [hash, signerAddress]);
+  const hasPrefix = isTxHashSignedWithPrefix(hash, signature, signerAddress);
+  signature = adjustVInSignature(signature, hasPrefix);
+  return new EthSignSignature(signerAddress, signature);
+}
+
+export async function estimateGasForTransactionExecution(
+  safeContract: Contract,
+  from: string,
+  tx: SafeTransaction
+): Promise<number> {
+  try {
+    const gas = await safeContract.estimateGas.execTransaction(
+      tx.data.to,
+      tx.data.value,
+      tx.data.data,
+      tx.data.operation,
+      tx.data.safeTxGas,
+      tx.data.baseGas,
+      tx.data.gasPrice,
+      tx.data.gasToken,
+      tx.data.refundReceiver,
+      tx.encodedSignatures(),
+      { from }
+    );
+    return gas.toNumber();
+  } catch (error) {
+    return Promise.reject(error);
+  }
+}
+
+export function toTxResult(
+  promiEvent: PromiEvent<TransactionReceipt>,
+  options?: TransactionOptions
+): Promise<Web3TransactionResult> {
+  return new Promise((resolve, reject) =>
+    promiEvent
+      .once("transactionHash", (hash: string) =>
+        resolve({ hash, promiEvent, options })
+      )
+      .catch(reject)
+  );
+}

package/tsconfig.json

@@ -0,0 +1,19 @@
+{
+  "compilerOptions": {
+    "baseUrl": "./",
+    "experimentalDecorators": true,
+    "emitDecoratorMetadata": true,
+    "module": "ESNext",
+    "target": "es2019",
+    "moduleResolution": "node",
+    "noImplicitAny": false,
+    "strict": true,
+    "esModuleInterop": true,
+    "allowSyntheticDefaultImports": true,
+    "allowJs": true,
+    "plugins": [{ "transform": "typescript-transform-paths", "afterDeclarations": true }],
+    "outDir": "./dist"
+  },
+  "exclude": ["./node_modules"],
+  "include": ["src", "__tests__"]
+}