@rabby-wallet/gnosis-sdk 1.0.0 → 1.0.1

package/dist/api.d.ts

@@ -0,0 +1,54 @@
+import { Axios } from "axios";
+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;
+}
+export 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;
+}
+export default class RequestProvider {
+    host: string;
+    request: Axios;
+    constructor(networkId: string);
+    getPendingTransactions(safeAddress: string, nonce: number): Promise<{
+        results: SafeTransactionItem[];
+    }>;
+    postTransactions(safeAddres: string, data: any): Promise<void>;
+    getSafeInfo(safeAddress: string): Promise<SafeInfo>;
+    confirmTransaction(hash: string, data: any): Promise<void>;
+}
+export {};

package/dist/api.js

@@ -0,0 +1,39 @@
+import axios from "axios";
+import { toChecksumAddress } from "web3-utils";
+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 {
+    constructor(networkId) {
+        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, nonce) {
+        return this.request.get(`/safes/${safeAddress}/multisig-transactions/`, {
+            params: {
+                executed: false,
+                nonce__gte: nonce,
+            },
+        });
+    }
+    postTransactions(safeAddres, data) {
+        return this.request.post(`/safes/${toChecksumAddress(safeAddres)}/multisig-transactions/`, data);
+    }
+    getSafeInfo(safeAddress) {
+        return this.request.get(`/safes/${safeAddress}/`);
+    }
+    confirmTransaction(hash, data) {
+        return this.request.post(`/multisig-transactions/${hash}/confirmations/`, data);
+    }
+}

package/dist/constants.d.ts

@@ -0,0 +1,3 @@
+export declare const ZERO_ADDRESS: string;
+export declare const EMPTY_DATA = "0x";
+export declare const SENTINEL_ADDRESS = "0x0000000000000000000000000000000000000001";

package/dist/constants.js

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

package/dist/index.d.ts

@@ -0,0 +1,36 @@
+import { Contract } from "ethers";
+import { BigNumber } from "@ethersproject/bignumber";
+import { providers } from "ethers";
+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";
+declare class Safe {
+    contract: Contract;
+    safeAddress: string;
+    owners: string[];
+    version: string;
+    provider: providers.Web3Provider;
+    safeInfo: SafeInfo | null;
+    request: RequestProvider;
+    network: string;
+    constructor(safeAddress: string, version: string, provider: providers.Web3Provider, network?: string);
+    static getSafeInfo(safeAddress: string, network: string): Promise<SafeInfo>;
+    init(): Promise<void>;
+    getOwners(): Promise<string[]>;
+    getThreshold(): Promise<any>;
+    getNonce(): Promise<number>;
+    getPendingTransactions(): Promise<{
+        results: import("./api").SafeTransactionItem[];
+    }>;
+    buildTransaction(data: SafeTransactionDataPartial): Promise<SafeTransaction>;
+    getTransactionHash(transaction: SafeTransaction): Promise<any>;
+    signTransactionHash(hash: string): Promise<SafeSignature>;
+    signTransaction(transaction: SafeTransaction): Promise<void>;
+    getOwnersWhoApprovedTx(txHash: string): Promise<string[]>;
+    postTransaction(transaction: SafeTransaction, hash: string): Promise<void>;
+    confirmTransaction(safeTransaction: SafeTransaction): Promise<void>;
+    getBalance(): Promise<BigNumber>;
+    executeTransaction(safeTransaction: SafeTransaction, options?: TransactionOptions): Promise<TransactionResult>;
+}
+export default Safe;

package/dist/index.js

@@ -0,0 +1,161 @@
+import { Contract } from "ethers";
+import { BigNumber } from "@ethersproject/bignumber";
+import { getSafeSingletonDeployment } from "@gnosis.pm/safe-deployments";
+import { toChecksumAddress } from "web3-utils";
+import SafeTransaction from "@gnosis.pm/safe-core-sdk/dist/src/utils/transactions/SafeTransaction";
+import RequestProvider from "./api";
+import { standardizeSafeTransactionData, sameString, generateSignature, generatePreValidatedSignature, estimateGasForTransactionExecution, toTxResult, } from "./utils";
+class Safe {
+    constructor(safeAddress, version, provider, network = "1") {
+        this.owners = [];
+        this.safeInfo = null;
+        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, network) {
+        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() {
+        const owners = await this.contract.getOwners();
+        return owners;
+    }
+    async getThreshold() {
+        const threshold = await this.contract.getThreshold();
+        return threshold.toNumber();
+    }
+    async getNonce() {
+        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) {
+        const transaction = await standardizeSafeTransactionData(this.safeAddress, this.contract, this.provider, data);
+        return new SafeTransaction(transaction);
+    }
+    async getTransactionHash(transaction) {
+        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) {
+        const owners = await this.getOwners();
+        const signer = await this.provider.getSigner(0);
+        const signerAddress = await signer.getAddress();
+        const addressIsOwner = owners.find((owner) => 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) {
+        const hash = await this.getTransactionHash(transaction);
+        const sig = await this.signTransactionHash(hash);
+        transaction.addSignature(sig);
+    }
+    async getOwnersWhoApprovedTx(txHash) {
+        const owners = await this.getOwners();
+        let ownersWhoApproved = [];
+        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, hash) {
+        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) {
+        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 === null || signerAddress === void 0 ? void 0 : signerAddress.toLowerCase());
+        if (sig) {
+            await this.request.confirmTransaction(hash, { signature: sig.data });
+        }
+    }
+    async getBalance() {
+        return this.provider.getBalance(this.safeAddress);
+    }
+    async executeTransaction(safeTransaction, options) {
+        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 = {
+            gasLimit,
+            gasPrice: options === null || options === void 0 ? void 0 : 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/dist/type.d.ts

@@ -0,0 +1,19 @@
+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/dist/type.js

@@ -0,0 +1 @@
+export {};

package/dist/utils.d.ts

@@ -0,0 +1,15 @@
+import { Contract, providers } from "ethers";
+import { 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 EthSignSignature from "@gnosis.pm/safe-core-sdk/dist/src/utils/signatures/SafeSignature";
+export declare function sameString(str1: string, str2: string): boolean;
+export declare function isRestrictedAddress(address: string): boolean;
+export declare function estimateTxGas(safeAddress: string, safeContract: Contract, provider: providers.Web3Provider, to: string, valueInWei: string, data: string, operation: OperationType): Promise<number>;
+export declare function standardizeSafeTransactionData(safeAddress: string, safeContract: Contract, provider: any, tx: SafeTransactionDataPartial): Promise<SafeTransactionData>;
+export declare function generatePreValidatedSignature(ownerAddress: string): SafeSignature;
+export declare function isTxHashSignedWithPrefix(txHash: string, signature: string, ownerAddress: string): boolean;
+export declare function adjustVInSignature(signature: string, hasPrefix: boolean): string;
+export declare function generateSignature(provider: providers.Web3Provider, hash: string): Promise<EthSignSignature>;
+export declare function estimateGasForTransactionExecution(safeContract: Contract, from: string, tx: SafeTransaction): Promise<number>;
+export declare function toTxResult(promiEvent: PromiEvent<TransactionReceipt>, options?: TransactionOptions): Promise<Web3TransactionResult>;

package/dist/utils.js

@@ -0,0 +1,161 @@
+import { BigNumber } from "@ethersproject/bignumber";
+import { OperationType, } from "@gnosis.pm/safe-core-sdk-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) {
+    const reducer = (accumulator, currentValue) => {
+        if (currentValue === "0x") {
+            return accumulator + 0;
+        }
+        if (currentValue === "00") {
+            return accumulator + 4;
+        }
+        return accumulator + 16;
+    };
+    return data.match(/.{2}/g).reduce(reducer, 0);
+}
+export function sameString(str1, str2) {
+    return str1.toLowerCase() === str2.toLowerCase();
+}
+function isZeroAddress(address) {
+    return address === ZERO_ADDRESS;
+}
+function isSentinelAddress(address) {
+    return address === SENTINEL_ADDRESS;
+}
+export function isRestrictedAddress(address) {
+    return isZeroAddress(address) || isSentinelAddress(address);
+}
+export async function estimateTxGas(safeAddress, safeContract, provider, to, valueInWei, data, operation) {
+    let txGasEstimation = 0;
+    const estimateData = 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, safeContract, provider, tx) {
+    var _a, _b, _c, _d, _e;
+    const standardizedTxs = {
+        to: tx.to,
+        value: tx.value,
+        data: tx.data,
+        operation: (_a = tx.operation) !== null && _a !== void 0 ? _a : OperationType.Call,
+        baseGas: (_b = tx.baseGas) !== null && _b !== void 0 ? _b : 0,
+        gasPrice: (_c = tx.gasPrice) !== null && _c !== void 0 ? _c : 0,
+        gasToken: tx.gasToken || ZERO_ADDRESS,
+        refundReceiver: tx.refundReceiver || ZERO_ADDRESS,
+        nonce: (_d = tx.nonce) !== null && _d !== void 0 ? _d : (await safeContract.nonce()).toNumber(),
+    };
+    const safeTxGas = (_e = tx.safeTxGas) !== null && _e !== void 0 ? _e : (await estimateTxGas(safeAddress, safeContract, provider, standardizedTxs.to, standardizedTxs.value, standardizedTxs.data, standardizedTxs.operation));
+    return {
+        ...standardizedTxs,
+        safeTxGas,
+    };
+}
+export function generatePreValidatedSignature(ownerAddress) {
+    const signature = "0x000000000000000000000000" +
+        ownerAddress.slice(2) +
+        "0000000000000000000000000000000000000000000000000000000000000000" +
+        "01";
+    return new EthSignSignature(ownerAddress, signature);
+}
+export function isTxHashSignedWithPrefix(txHash, signature, ownerAddress) {
+    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, hasPrefix) {
+    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, hash) {
+    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, from, tx) {
+    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, options) {
+    return new Promise((resolve, reject) => promiEvent
+        .once("transactionHash", (hash) => resolve({ hash, promiEvent, options }))
+        .catch(reject));
+}

package/package.json

@@ -1,8 +1,8 @@
 {
   "name": "@rabby-wallet/gnosis-sdk",
-  "version": "1.0.0",
+  "version": "1.0.1",
   "description": "",
-  "main": "index.js",
+  "main": "dist/index.js",
   "scripts": {
     "build": "tsc"
   },

package/src/api.ts

@@ -21,7 +21,7 @@ interface ConfirmationItem {
   signatureType: string;
 }
 
-interface SafeTransactionItem {
+export interface SafeTransactionItem {
   safe: string;
   to: string;
   value: string;

package/tsconfig.json

@@ -12,7 +12,8 @@
     "allowSyntheticDefaultImports": true,
     "allowJs": true,
     "plugins": [{ "transform": "typescript-transform-paths", "afterDeclarations": true }],
-    "outDir": "./dist"
+    "outDir": "./dist",
+    "declaration": true
   },
   "exclude": ["./node_modules"],
   "include": ["src", "__tests__"]