@rabby-wallet/gnosis-sdk 1.4.7-alpha-1 → 1.4.8-alpha-1

package/dist/api.d.ts

@@ -41,6 +41,39 @@ export interface SafeTransactionItem {
     confirmations: ConfirmationItem[];
     signatures: string | null;
 }
+export type SafeOpenApiService = {
+    getSafePendingTransactions?: (params: {
+        txServiceUrl: string;
+        safeAddress: string;
+        nonce: number;
+    }) => Promise<{
+        results: SafeTransactionItem[];
+    }>;
+    postSafeTransactions?: (params: {
+        txServiceUrl: string;
+        safeAddress: string;
+        data: Record<string, any>;
+    }) => Promise<void>;
+    getSafeInfo?: (params: {
+        txServiceUrl: string;
+        safeAddress: string;
+    }) => Promise<SafeInfo>;
+    confirmSafeTransaction?: (params: {
+        txServiceUrl: string;
+        safeTransactionHash: string;
+        data: Record<string, any>;
+    }) => Promise<void>;
+    getSafeTxGas?: (params: {
+        txServiceUrl: string;
+        safeAddress: string;
+        safeTxData: {
+            to: string;
+            value?: string;
+            data?: string | null;
+            operation?: number;
+        };
+    }) => Promise<string | undefined>;
+};
 export declare const GNOSIS_SUPPORT_CHAINS: string[];
 export declare const HOST_MAP: {
     /**
@@ -50,12 +83,14 @@ export declare const HOST_MAP: {
 };
 export declare const getTxServiceUrl: (chainId: string) => any;
 export default class RequestProvider {
-    host: string;
+    prefix: string;
     request: Axios;
-    constructor({ networkId, adapter, apiKey, }: {
+    openapiService?: SafeOpenApiService;
+    shouldUseOpenapiService: boolean;
+    constructor({ networkId, adapter, openapiService, }: {
         networkId: string;
         adapter?: AxiosAdapter;
-        apiKey: string;
+        openapiService?: SafeOpenApiService;
     });
     getPendingTransactions(safeAddress: string, nonce: number): Promise<{
         results: SafeTransactionItem[];

package/dist/api.js

@@ -1,7 +1,6 @@
 import { ethers } from "ethers";
 import { isLegacyVersion } from "./utils";
 import axios from "axios";
-const TRANSACTION_SERVICE_URL = "https://api.rabby.io/v1/safe-tx-service";
 // https://github.com/safe-global/safe-core-sdk/blob/main/packages/api-kit/src/utils/config.ts
 const networks = [
     {
@@ -208,32 +207,38 @@ export const HOST_MAP = {
 export const getTxServiceUrl = (chainId) => {
     const shortName = networkMap[chainId];
     if (shortName) {
-        return `${TRANSACTION_SERVICE_URL}/${shortName}/api`;
+        return `/v1/safe-tx-service/${shortName}/api`;
     }
     return HOST_MAP[chainId];
 };
 export default class RequestProvider {
-    constructor({ networkId, adapter, apiKey, }) {
+    constructor({ networkId, adapter, openapiService, }) {
         const txServiceUrl = getTxServiceUrl(networkId);
         if (!txServiceUrl) {
             throw new Error("Wrong networkId");
         }
-        this.host = txServiceUrl;
+        this.prefix = txServiceUrl;
+        this.openapiService = openapiService;
+        this.shouldUseOpenapiService = !/^https?:\/\//i.test(this.prefix);
         this.request = axios.create({
-            baseURL: this.host,
+            baseURL: this.prefix,
             adapter,
-            headers: apiKey
-                ? {
-                    Authorization: `Bearer ${apiKey}`,
-                }
-                : undefined,
         });
         this.request.interceptors.response.use((response) => {
             return response.data;
         });
     }
     getPendingTransactions(safeAddress, nonce) {
-        return this.request.get(`/v1/safes/${ethers.utils.getAddress(safeAddress)}/multisig-transactions/`, {
+        const checksumAddress = ethers.utils.getAddress(safeAddress);
+        if (this.shouldUseOpenapiService &&
+            this.openapiService?.getSafePendingTransactions) {
+            return this.openapiService.getSafePendingTransactions({
+                txServiceUrl: this.prefix,
+                safeAddress: checksumAddress,
+                nonce,
+            });
+        }
+        return this.request.get(`/v1/safes/${checksumAddress}/multisig-transactions/`, {
             params: {
                 executed: false,
                 nonce__gte: nonce,
@@ -241,12 +246,36 @@ export default class RequestProvider {
         });
     }
     postTransactions(safeAddres, data) {
-        return this.request.post(`/v1/safes/${ethers.utils.getAddress(safeAddres)}/multisig-transactions/`, data);
+        const checksumAddress = ethers.utils.getAddress(safeAddres);
+        if (this.shouldUseOpenapiService &&
+            this.openapiService?.postSafeTransactions) {
+            return this.openapiService.postSafeTransactions({
+                txServiceUrl: this.prefix,
+                safeAddress: checksumAddress,
+                data,
+            });
+        }
+        return this.request.post(`/v1/safes/${checksumAddress}/multisig-transactions/`, data);
     }
     getSafeInfo(safeAddress) {
-        return this.request.get(`/v1/safes/${ethers.utils.getAddress(safeAddress)}/`);
+        const checksumAddress = ethers.utils.getAddress(safeAddress);
+        if (this.shouldUseOpenapiService && this.openapiService?.getSafeInfo) {
+            return this.openapiService.getSafeInfo({
+                txServiceUrl: this.prefix,
+                safeAddress: checksumAddress,
+            });
+        }
+        return this.request.get(`/v1/safes/${checksumAddress}/`);
     }
     confirmTransaction(safeTransactionHash, data) {
+        if (this.shouldUseOpenapiService &&
+            this.openapiService?.confirmSafeTransaction) {
+            return this.openapiService.confirmSafeTransaction({
+                txServiceUrl: this.prefix,
+                safeTransactionHash,
+                data,
+            });
+        }
         return this.request.post(`/v1/multisig-transactions/${safeTransactionHash}/confirmations/`, data);
     }
     // https://github.com/safe-global/safe-wallet-web/blob/dev/src/services/tx/tx-sender/recommendedNonce.ts#L24
@@ -256,6 +285,18 @@ export default class RequestProvider {
         if (!isSafeTxGasRequired)
             return "0";
         const address = ethers.utils.getAddress(safeAddress);
+        if (this.shouldUseOpenapiService && this.openapiService?.getSafeTxGas) {
+            return this.openapiService.getSafeTxGas({
+                txServiceUrl: this.prefix,
+                safeAddress: address,
+                safeTxData: {
+                    to: ethers.utils.getAddress(safeTxData.to),
+                    value: safeTxData.value || "0",
+                    data: safeTxData.data,
+                    operation: safeTxData.operation,
+                },
+            });
+        }
         try {
             const estimation = await this.request.post(`/v1/safes/${address}/multisig-transactions/estimations/`, {
                 to: ethers.utils.getAddress(safeTxData.to),

package/dist/index.d.ts

@@ -4,7 +4,7 @@ import { Contract, providers } from "ethers";
 import { TransactionOptions, TransactionResult, SafeSignature, SafeTransaction, SafeTransactionDataPartial } from "@safe-global/types-kit";
 import { EthSafeMessage, EthSafeTransaction } from "@safe-global/protocol-kit";
 import SafeApiKit, { SafeMessage as ApiKitSafeMessage } from "@safe-global/api-kit";
-import RequestProvider, { SafeInfo } from "./api";
+import RequestProvider, { SafeInfo, SafeOpenApiService } from "./api";
 declare class Safe {
     contract: Contract;
     safeAddress: string;
@@ -16,7 +16,7 @@ declare class Safe {
     network: string;
     apiKit: SafeApiKit;
     static adapter: AxiosAdapter;
-    static apiKey: string;
+    static openapiService?: SafeOpenApiService;
     constructor(safeAddress: string, version: string, provider: providers.Web3Provider, network?: string);
     /**
      * @deprecated

package/dist/index.js

@@ -5,7 +5,7 @@ import { calculateSafeMessageHash } from "@safe-global/protocol-kit/dist/src/uti
 import SafeApiKit from "@safe-global/api-kit";
 // import { getTransactionServiceUrl } from "@safe-global/api-kit/dist/src/utils/config";
 import { getSafeSingletonDeployment } from "@safe-global/safe-deployments";
-import RequestProvider, { getTxServiceUrl } from "./api";
+import RequestProvider, { getTxServiceUrl, } from "./api";
 import { generatePreValidatedSignature, generateSignature, sameString, standardizeSafeTransactionData, } from "./utils";
 class Safe {
     constructor(safeAddress, version, provider, network = "1") {
@@ -56,7 +56,7 @@ class Safe {
         this.request = new RequestProvider({
             networkId: network,
             adapter: Safe.adapter,
-            apiKey: Safe.apiKey,
+            openapiService: Safe.openapiService,
         });
         this.apiKit = Safe.createSafeApiKit(network);
         // this.init();
@@ -71,7 +71,7 @@ class Safe {
         const request = new RequestProvider({
             networkId: network,
             adapter: Safe.adapter,
-            apiKey: Safe.apiKey,
+            openapiService: Safe.openapiService,
         });
         return request.getSafeInfo(ethers.utils.getAddress(safeAddress));
     }
@@ -79,7 +79,7 @@ class Safe {
         const request = new RequestProvider({
             networkId: network,
             adapter: Safe.adapter,
-            apiKey: Safe.apiKey,
+            openapiService: Safe.openapiService,
         });
         const transactions = await request.getPendingTransactions(safeAddress, nonce);
         return transactions;
@@ -263,7 +263,6 @@ Safe.createSafeApiKit = (network) => {
     return new SafeApiKit({
         chainId: BigInt(network),
         txServiceUrl: getTxServiceUrl(network) || undefined,
-        apiKey: Safe.apiKey,
     });
 };
 export default Safe;

package/dist/utils.js

@@ -100,7 +100,7 @@ export async function standardizeSafeTransactionData(safeAddress, safeContract,
     const request = new RequestProvider({
         networkId: network,
         adapter: Safe.adapter,
-        apiKey: Safe.apiKey,
+        openapiService: Safe.openapiService,
     });
     const safeTxGas = tx.safeTxGas ??
         (await request.getSafeTxGas(safeAddress, version, standardizedTxs));

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rabby-wallet/gnosis-sdk",
-  "version": "1.4.7-alpha-1",
+  "version": "1.4.8-alpha-1",
   "description": "",
   "main": "dist/index.js",
   "scripts": {

package/src/api.ts

@@ -47,7 +47,37 @@ export interface SafeTransactionItem {
   signatures: string | null;
 }
 
-const TRANSACTION_SERVICE_URL = "https://api.rabby.io/v1/safe-tx-service";
+export type SafeOpenApiService = {
+  getSafePendingTransactions?: (params: {
+    txServiceUrl: string;
+    safeAddress: string;
+    nonce: number;
+  }) => Promise<{ results: SafeTransactionItem[] }>;
+  postSafeTransactions?: (params: {
+    txServiceUrl: string;
+    safeAddress: string;
+    data: Record<string, any>;
+  }) => Promise<void>;
+  getSafeInfo?: (params: {
+    txServiceUrl: string;
+    safeAddress: string;
+  }) => Promise<SafeInfo>;
+  confirmSafeTransaction?: (params: {
+    txServiceUrl: string;
+    safeTransactionHash: string;
+    data: Record<string, any>;
+  }) => Promise<void>;
+  getSafeTxGas?: (params: {
+    txServiceUrl: string;
+    safeAddress: string;
+    safeTxData: {
+      to: string;
+      value?: string;
+      data?: string | null;
+      operation?: number;
+    };
+  }) => Promise<string | undefined>;
+};
 
 type NetworkShortName = {
   shortName: string;
@@ -267,40 +297,38 @@ export const HOST_MAP = {
 export const getTxServiceUrl = (chainId: string) => {
   const shortName = networkMap[chainId];
   if (shortName) {
-    return `${TRANSACTION_SERVICE_URL}/${shortName}/api`;
+    return `/v1/safe-tx-service/${shortName}/api`;
   }
   return HOST_MAP[chainId];
 };
 
 export default class RequestProvider {
-  host: string;
+  prefix: string;
   request: Axios;
+  openapiService?: SafeOpenApiService;
+  shouldUseOpenapiService: boolean;
 
   constructor({
     networkId,
     adapter,
-    apiKey,
+    openapiService,
   }: {
     networkId: string;
     adapter?: AxiosAdapter;
-    apiKey: string;
+    openapiService?: SafeOpenApiService;
   }) {
     const txServiceUrl = getTxServiceUrl(networkId);
     if (!txServiceUrl) {
       throw new Error("Wrong networkId");
     }
 
-    this.host = txServiceUrl;
+    this.prefix = txServiceUrl;
+    this.openapiService = openapiService;
+    this.shouldUseOpenapiService = !/^https?:\/\//i.test(this.prefix);
 
     this.request = axios.create({
-      baseURL: this.host,
+      baseURL: this.prefix,
       adapter,
-
-      headers: apiKey
-        ? {
-            Authorization: `Bearer ${apiKey}`,
-          }
-        : undefined,
     });
 
     this.request.interceptors.response.use((response) => {
@@ -312,10 +340,20 @@ export default class RequestProvider {
     safeAddress: string,
     nonce: number
   ): Promise<{ results: SafeTransactionItem[] }> {
+    const checksumAddress = ethers.utils.getAddress(safeAddress);
+    if (
+      this.shouldUseOpenapiService &&
+      this.openapiService?.getSafePendingTransactions
+    ) {
+      return this.openapiService.getSafePendingTransactions({
+        txServiceUrl: this.prefix,
+        safeAddress: checksumAddress,
+        nonce,
+      });
+    }
+
     return this.request.get(
-      `/v1/safes/${ethers.utils.getAddress(
-        safeAddress
-      )}/multisig-transactions/`,
+      `/v1/safes/${checksumAddress}/multisig-transactions/`,
       {
         params: {
           executed: false,
@@ -326,19 +364,50 @@ export default class RequestProvider {
   }
 
   postTransactions(safeAddres: string, data): Promise<void> {
+    const checksumAddress = ethers.utils.getAddress(safeAddres);
+    if (
+      this.shouldUseOpenapiService &&
+      this.openapiService?.postSafeTransactions
+    ) {
+      return this.openapiService.postSafeTransactions({
+        txServiceUrl: this.prefix,
+        safeAddress: checksumAddress,
+        data,
+      });
+    }
+
     return this.request.post(
-      `/v1/safes/${ethers.utils.getAddress(safeAddres)}/multisig-transactions/`,
+      `/v1/safes/${checksumAddress}/multisig-transactions/`,
       data
     );
   }
 
   getSafeInfo(safeAddress: string): Promise<SafeInfo> {
+    const checksumAddress = ethers.utils.getAddress(safeAddress);
+    if (this.shouldUseOpenapiService && this.openapiService?.getSafeInfo) {
+      return this.openapiService.getSafeInfo({
+        txServiceUrl: this.prefix,
+        safeAddress: checksumAddress,
+      });
+    }
+
     return this.request.get(
-      `/v1/safes/${ethers.utils.getAddress(safeAddress)}/`
+      `/v1/safes/${checksumAddress}/`
     );
   }
 
   confirmTransaction(safeTransactionHash: string, data): Promise<void> {
+    if (
+      this.shouldUseOpenapiService &&
+      this.openapiService?.confirmSafeTransaction
+    ) {
+      return this.openapiService.confirmSafeTransaction({
+        txServiceUrl: this.prefix,
+        safeTransactionHash,
+        data,
+      });
+    }
+
     return this.request.post(
       `/v1/multisig-transactions/${safeTransactionHash}/confirmations/`,
       data
@@ -358,6 +427,19 @@ export default class RequestProvider {
 
     const address = ethers.utils.getAddress(safeAddress);
 
+    if (this.shouldUseOpenapiService && this.openapiService?.getSafeTxGas) {
+      return this.openapiService.getSafeTxGas({
+        txServiceUrl: this.prefix,
+        safeAddress: address,
+        safeTxData: {
+          to: ethers.utils.getAddress(safeTxData.to),
+          value: safeTxData.value || "0",
+          data: safeTxData.data,
+          operation: safeTxData.operation,
+        },
+      });
+    }
+
     try {
       const estimation: { safeTxGas: string } = await this.request.post(
         `/v1/safes/${address}/multisig-transactions/estimations/`,

package/src/index.ts

@@ -16,7 +16,11 @@ import SafeApiKit, {
 } from "@safe-global/api-kit";
 // import { getTransactionServiceUrl } from "@safe-global/api-kit/dist/src/utils/config";
 import { getSafeSingletonDeployment } from "@safe-global/safe-deployments";
-import RequestProvider, { getTxServiceUrl, SafeInfo } from "./api";
+import RequestProvider, {
+  getTxServiceUrl,
+  SafeInfo,
+  SafeOpenApiService,
+} from "./api";
 import {
   estimateGasForTransactionExecution,
   generatePreValidatedSignature,
@@ -37,13 +41,13 @@ class Safe {
   apiKit: SafeApiKit;
 
   static adapter: AxiosAdapter;
-  static apiKey: string;
+  static openapiService?: SafeOpenApiService;
 
   constructor(
     safeAddress: string,
     version: string,
     provider: providers.Web3Provider,
-    network = "1"
+    network = "1",
   ) {
     const contract = getSafeSingletonDeployment({
       version,
@@ -60,7 +64,7 @@ class Safe {
     this.request = new RequestProvider({
       networkId: network,
       adapter: Safe.adapter,
-      apiKey: Safe.apiKey,
+      openapiService: Safe.openapiService,
     });
     this.apiKit = Safe.createSafeApiKit(network);
 
@@ -77,7 +81,7 @@ class Safe {
     const request = new RequestProvider({
       networkId: network,
       adapter: Safe.adapter,
-      apiKey: Safe.apiKey,
+      openapiService: Safe.openapiService,
     });
     return request.getSafeInfo(ethers.utils.getAddress(safeAddress));
   }
@@ -85,16 +89,16 @@ class Safe {
   static async getPendingTransactions(
     safeAddress: string,
     network: string,
-    nonce: number
+    nonce: number,
   ) {
     const request = new RequestProvider({
       networkId: network,
       adapter: Safe.adapter,
-      apiKey: Safe.apiKey,
+      openapiService: Safe.openapiService,
     });
     const transactions = await request.getPendingTransactions(
       safeAddress,
-      nonce
+      nonce,
     );
 
     return transactions;
@@ -104,7 +108,6 @@ class Safe {
     return new SafeApiKit({
       chainId: BigInt(network),
       txServiceUrl: getTxServiceUrl(network) || undefined,
-      apiKey: Safe.apiKey,
     });
   };
 
@@ -112,7 +115,7 @@ class Safe {
     const nonce = await this.getNonce();
     const transactions = await this.request.getPendingTransactions(
       this.safeAddress,
-      nonce
+      nonce,
     );
 
     return transactions;
@@ -144,7 +147,7 @@ class Safe {
           type: "function",
         },
       ],
-      provider
+      provider,
     );
 
     const version = await contract.VERSION();
@@ -157,7 +160,7 @@ class Safe {
     this.safeInfo = safeInfo;
     if (this.version !== safeInfo.version) {
       throw new Error(
-        `Current version ${this.version} not matched address version ${safeInfo.version}`
+        `Current version ${this.version} not matched address version ${safeInfo.version}`,
       );
     }
     this.version = safeInfo.version;
@@ -202,7 +205,7 @@ class Safe {
       this.provider,
       data,
       this.network,
-      this.version
+      this.version,
     );
     return new EthSafeTransaction(transaction);
   }
@@ -219,7 +222,7 @@ class Safe {
       transactionData.gasPrice,
       transactionData.gasToken,
       transactionData.refundReceiver,
-      transactionData.nonce
+      transactionData.nonce,
     );
   }
 
@@ -228,7 +231,7 @@ class Safe {
     const signer = await this.provider.getSigner(0);
     const signerAddress = await signer.getAddress();
     const addressIsOwner = owners.find(
-      (owner: string) => signerAddress && sameString(owner, signerAddress)
+      (owner: string) => signerAddress && sameString(owner, signerAddress),
     );
     if (!addressIsOwner) {
       throw new Error("Transactions can only be signed by Safe owners");
@@ -294,7 +297,7 @@ class Safe {
 
   async executeTransaction(
     safeTransaction: SafeTransaction,
-    options?: TransactionOptions
+    options?: TransactionOptions,
   ): Promise<TransactionResult> {
     const txHash = await this.getTransactionHash(safeTransaction);
     const ownersWhoApprovedTx = await this.getOwnersWhoApprovedTx(txHash);
@@ -307,7 +310,7 @@ class Safe {
     const signerAddress = await signer.getAddress();
     if (owners.includes(signerAddress)) {
       safeTransaction.addSignature(
-        generatePreValidatedSignature(signerAddress)
+        generatePreValidatedSignature(signerAddress),
       );
     }
 
@@ -319,7 +322,7 @@ class Safe {
           signaturesMissing > 1 ? "are" : "is"
         } ${signaturesMissing} signature${
           signaturesMissing > 1 ? "s" : ""
-        } missing`
+        } missing`,
       );
     }
 
@@ -353,7 +356,7 @@ class Safe {
       safeTransaction.data.gasToken,
       safeTransaction.data.refundReceiver,
       safeTransaction.encodedSignatures(),
-      executionOptions
+      executionOptions,
     );
 
     return txResponse;
@@ -379,7 +382,7 @@ class Safe {
       ethers.utils.getAddress(safeAddress),
       messageHash,
       safeVersion,
-      chainId
+      chainId,
     );
   };
 
@@ -405,7 +408,7 @@ class Safe {
       });
     } catch (error) {
       throw new Error(
-        "Could not add a new off-chain message to the Safe account"
+        "Could not add a new off-chain message to the Safe account",
       );
     }
   }

package/src/utils.ts

@@ -135,7 +135,7 @@ export async function standardizeSafeTransactionData(
   const request = new RequestProvider({
     networkId: network,
     adapter: Safe.adapter,
-    apiKey: Safe.apiKey,
+    openapiService: Safe.openapiService,
   });
   const safeTxGas =
     tx.safeTxGas ??