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

package/dist/api.d.ts

@@ -41,27 +41,58 @@ export interface SafeTransactionItem {
     confirmations: ConfirmationItem[];
     signatures: string | null;
 }
-export declare const GNOSIS_SUPPORT_CHAINS: string[];
-export declare const HOST_MAP: {
-    /**
-     * blast
-     */
-    "81457": string;
+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 getTxServiceUrl: (chainId: string) => any;
+export declare const GNOSIS_SUPPORT_CHAINS: string[];
+export declare const HOST_MAP: Record<string, string>;
+export declare const getTxServiceUrl: (chainId: string) => string;
 export default class RequestProvider {
-    host: string;
+    prefix: string;
     request: Axios;
-    constructor({ networkId, adapter, }: {
+    openapiService?: SafeOpenApiService;
+    shouldUseOpenapiService: boolean;
+    constructor({ networkId, adapter, openapiService, }: {
         networkId: string;
         adapter?: AxiosAdapter;
+        openapiService?: SafeOpenApiService;
     });
     getPendingTransactions(safeAddress: string, nonce: number): Promise<{
         results: SafeTransactionItem[];
     }>;
-    postTransactions(safeAddres: string, data: any): Promise<void>;
+    postTransactions(safeAddres: string, data: Record<string, any>): Promise<void>;
     getSafeInfo(safeAddress: string): Promise<SafeInfo>;
-    confirmTransaction(safeTransactionHash: string, data: any): Promise<void>;
+    confirmTransaction(safeTransactionHash: string, data: Record<string, any>): Promise<void>;
     getSafeTxGas(safeAddress: string, safeVersion: string, safeTxData: SafeTransactionDataPartial): Promise<string | undefined>;
 }
 export {};

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,19 +207,21 @@ 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, }) {
+    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,
         });
         this.request.interceptors.response.use((response) => {
@@ -228,7 +229,16 @@ export default class RequestProvider {
         });
     }
     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,
@@ -236,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
@@ -251,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,6 +16,7 @@ declare class Safe {
     network: string;
     apiKit: SafeApiKit;
     static adapter: AxiosAdapter;
+    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,6 +56,7 @@ class Safe {
         this.request = new RequestProvider({
             networkId: network,
             adapter: Safe.adapter,
+            openapiService: Safe.openapiService,
         });
         this.apiKit = Safe.createSafeApiKit(network);
         // this.init();
@@ -70,6 +71,7 @@ class Safe {
         const request = new RequestProvider({
             networkId: network,
             adapter: Safe.adapter,
+            openapiService: Safe.openapiService,
         });
         return request.getSafeInfo(ethers.utils.getAddress(safeAddress));
     }
@@ -77,6 +79,7 @@ class Safe {
         const request = new RequestProvider({
             networkId: network,
             adapter: Safe.adapter,
+            openapiService: Safe.openapiService,
         });
         const transactions = await request.getPendingTransactions(safeAddress, nonce);
         return transactions;

package/dist/utils.js

@@ -100,12 +100,13 @@ export async function standardizeSafeTransactionData(safeAddress, safeContract,
     const request = new RequestProvider({
         networkId: network,
         adapter: Safe.adapter,
+        openapiService: Safe.openapiService,
     });
     const safeTxGas = tx.safeTxGas ??
         (await request.getSafeTxGas(safeAddress, version, standardizedTxs));
     return {
         ...standardizedTxs,
-        safeTxGas: safeTxGas || "0",
+        safeTxGas: `${safeTxGas || "0"}`,
     };
 }
 export function generatePreValidatedSignature(ownerAddress) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rabby-wallet/gnosis-sdk",
-  "version": "1.4.7",
+  "version": "1.4.8-alpha-2",
   "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;
@@ -257,7 +287,7 @@ const networkMap = networks.reduce<Record<string, string>>(
   {}
 );
 
-export const HOST_MAP = {
+export const HOST_MAP: Record<string, string> = {
   /**
    * blast
    */
@@ -267,31 +297,37 @@ 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,
+    openapiService,
   }: {
     networkId: string;
     adapter?: AxiosAdapter;
+    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,
     });
 
@@ -304,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,
@@ -317,20 +363,54 @@ export default class RequestProvider {
     );
   }
 
-  postTransactions(safeAddres: string, data): Promise<void> {
+  postTransactions(safeAddres: string, data: Record<string, any>): 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> {
+  confirmTransaction(
+    safeTransactionHash: string,
+    data: Record<string, any>
+  ): 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
@@ -350,6 +430,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,6 +41,7 @@ class Safe {
   apiKit: SafeApiKit;
 
   static adapter: AxiosAdapter;
+  static openapiService?: SafeOpenApiService;
 
   constructor(
     safeAddress: string,
@@ -59,6 +64,7 @@ class Safe {
     this.request = new RequestProvider({
       networkId: network,
       adapter: Safe.adapter,
+      openapiService: Safe.openapiService,
     });
     this.apiKit = Safe.createSafeApiKit(network);
 
@@ -75,6 +81,7 @@ class Safe {
     const request = new RequestProvider({
       networkId: network,
       adapter: Safe.adapter,
+      openapiService: Safe.openapiService,
     });
     return request.getSafeInfo(ethers.utils.getAddress(safeAddress));
   }
@@ -87,6 +94,7 @@ class Safe {
     const request = new RequestProvider({
       networkId: network,
       adapter: Safe.adapter,
+      openapiService: Safe.openapiService,
     });
     const transactions = await request.getPendingTransactions(
       safeAddress,

package/src/utils.ts

@@ -135,13 +135,14 @@ export async function standardizeSafeTransactionData(
   const request = new RequestProvider({
     networkId: network,
     adapter: Safe.adapter,
+    openapiService: Safe.openapiService,
   });
   const safeTxGas =
     tx.safeTxGas ??
     (await request.getSafeTxGas(safeAddress, version, standardizedTxs));
   return {
     ...standardizedTxs,
-    safeTxGas: safeTxGas || "0",
+    safeTxGas: `${safeTxGas || "0"}`,
   };
 }