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

package/dist/api.d.ts

@@ -73,6 +73,31 @@ export type SafeOpenApiService = {
             operation?: number;
         };
     }) => Promise<string | undefined>;
+    getSafeMessages?: (params: {
+        txServiceUrl: string;
+        safeAddress: string;
+        options?: Record<string, any>;
+    }) => Promise<{
+        results: any[];
+    }>;
+    addSafeMessage?: (params: {
+        txServiceUrl: string;
+        safeAddress: string;
+        data: {
+            message: string | Record<string, any>;
+            signature: string;
+            safeAppId?: number;
+        };
+    }) => Promise<void>;
+    getSafeMessage?: (params: {
+        txServiceUrl: string;
+        messageHash: string;
+    }) => Promise<any>;
+    addSafeMessageSignature?: (params: {
+        txServiceUrl: string;
+        messageHash: string;
+        signature: string;
+    }) => Promise<void>;
 };
 export declare const GNOSIS_SUPPORT_CHAINS: string[];
 export declare const HOST_MAP: Record<string, string>;
@@ -94,5 +119,15 @@ export default class RequestProvider {
     getSafeInfo(safeAddress: string): Promise<SafeInfo>;
     confirmTransaction(safeTransactionHash: string, data: Record<string, any>): Promise<void>;
     getSafeTxGas(safeAddress: string, safeVersion: string, safeTxData: SafeTransactionDataPartial): Promise<string | undefined>;
+    getMessages(safeAddress: string, options?: Record<string, any>): Promise<{
+        results: any[];
+    }>;
+    addMessage(safeAddress: string, data: {
+        message: string | Record<string, any>;
+        signature: string;
+        safeAppId?: number;
+    }): Promise<void>;
+    getMessage(messageHash: string): Promise<any>;
+    addMessageSignature(messageHash: string, signature: string): Promise<void>;
 }
 export {};

package/dist/api.js

@@ -310,4 +310,50 @@ export default class RequestProvider {
             console.error(e);
         }
     }
+    getMessages(safeAddress, options) {
+        const checksumAddress = ethers.utils.getAddress(safeAddress);
+        if (this.shouldUseOpenapiService && this.openapiService?.getSafeMessages) {
+            return this.openapiService.getSafeMessages({
+                txServiceUrl: this.prefix,
+                safeAddress: checksumAddress,
+                options,
+            });
+        }
+        return this.request.get(`/v1/safes/${checksumAddress}/messages/`, {
+            params: options,
+        });
+    }
+    addMessage(safeAddress, data) {
+        const checksumAddress = ethers.utils.getAddress(safeAddress);
+        if (this.shouldUseOpenapiService && this.openapiService?.addSafeMessage) {
+            return this.openapiService.addSafeMessage({
+                txServiceUrl: this.prefix,
+                safeAddress: checksumAddress,
+                data,
+            });
+        }
+        return this.request.post(`/v1/safes/${checksumAddress}/messages/`, data);
+    }
+    getMessage(messageHash) {
+        if (this.shouldUseOpenapiService && this.openapiService?.getSafeMessage) {
+            return this.openapiService.getSafeMessage({
+                txServiceUrl: this.prefix,
+                messageHash,
+            });
+        }
+        return this.request.get(`/v1/messages/${messageHash}/`);
+    }
+    addMessageSignature(messageHash, signature) {
+        if (this.shouldUseOpenapiService &&
+            this.openapiService?.addSafeMessageSignature) {
+            return this.openapiService.addSafeMessageSignature({
+                txServiceUrl: this.prefix,
+                messageHash,
+                signature,
+            });
+        }
+        return this.request.post(`/v1/messages/${messageHash}/signatures/`, {
+            signature,
+        });
+    }
 }

package/dist/index.d.ts

@@ -3,7 +3,7 @@ import { AxiosAdapter } from "axios";
 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 SafeApiKit, { GetSafeMessageListOptions, SafeMessage as ApiKitSafeMessage } from "@safe-global/api-kit";
 import RequestProvider, { SafeInfo, SafeOpenApiService } from "./api";
 declare class Safe {
     contract: Contract;
@@ -28,6 +28,7 @@ declare class Safe {
     static getPendingTransactions(safeAddress: string, network: string, nonce: number): Promise<{
         results: import("./api").SafeTransactionItem[];
     }>;
+    static getMessage(messageHash: string, network: string): Promise<any>;
     static createSafeApiKit: (network: string) => SafeApiKit;
     getPendingTransactions(): Promise<{
         results: import("./api").SafeTransactionItem[];
@@ -75,6 +76,11 @@ declare class Safe {
     addMessage({ safeMessage, }: {
         safeMessage: EthSafeMessage;
     }): Promise<void>;
+    getMessages(options?: GetSafeMessageListOptions): Promise<{
+        results: any[];
+    }>;
+    getMessage(messageHash: string): Promise<any>;
+    addMessageSignature(messageHash: string, signature: string): Promise<void>;
 }
 export default Safe;
 export type BasicSafeInfo = Awaited<ReturnType<Safe["getBasicSafeInfo"]>>;

package/dist/index.js

@@ -84,6 +84,14 @@ class Safe {
         const transactions = await request.getPendingTransactions(safeAddress, nonce);
         return transactions;
     }
+    static async getMessage(messageHash, network) {
+        const request = new RequestProvider({
+            networkId: network,
+            adapter: Safe.adapter,
+            openapiService: Safe.openapiService,
+        });
+        return request.getMessage(messageHash);
+    }
     async getPendingTransactions() {
         const nonce = await this.getNonce();
         const transactions = await this.request.getPendingTransactions(this.safeAddress, nonce);
@@ -249,7 +257,7 @@ class Safe {
     async addMessage({ safeMessage, }) {
         const safeAddress = this.safeAddress;
         try {
-            return this.apiKit.addMessage(safeAddress, {
+            return this.request.addMessage(safeAddress, {
                 message: safeMessage.data,
                 signature: safeMessage.encodedSignatures(),
             });
@@ -258,6 +266,31 @@ class Safe {
             throw new Error("Could not add a new off-chain message to the Safe account");
         }
     }
+    async getMessages(options) {
+        const safeAddress = this.safeAddress;
+        try {
+            return this.request.getMessages(safeAddress, options);
+        }
+        catch (error) {
+            throw new Error("Could not get off-chain messages of the Safe account");
+        }
+    }
+    async getMessage(messageHash) {
+        try {
+            return this.request.getMessage(messageHash);
+        }
+        catch (error) {
+            throw new Error("Could not get off-chain message of the Safe account");
+        }
+    }
+    async addMessageSignature(messageHash, signature) {
+        try {
+            return this.request.addMessageSignature(messageHash, signature);
+        }
+        catch (error) {
+            throw new Error("Could not add an off-chain message signature to the Safe account");
+        }
+    }
 }
 Safe.createSafeApiKit = (network) => {
     return new SafeApiKit({

package/package.json

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

package/src/api.ts

@@ -77,6 +77,29 @@ export type SafeOpenApiService = {
       operation?: number;
     };
   }) => Promise<string | undefined>;
+  getSafeMessages?: (params: {
+    txServiceUrl: string;
+    safeAddress: string;
+    options?: Record<string, any>;
+  }) => Promise<{ results: any[] }>;
+  addSafeMessage?: (params: {
+    txServiceUrl: string;
+    safeAddress: string;
+    data: {
+      message: string | Record<string, any>;
+      signature: string;
+      safeAppId?: number;
+    };
+  }) => Promise<void>;
+  getSafeMessage?: (params: {
+    txServiceUrl: string;
+    messageHash: string;
+  }) => Promise<any>;
+  addSafeMessageSignature?: (params: {
+    txServiceUrl: string;
+    messageHash: string;
+    signature: string;
+  }) => Promise<void>;
 };
 
 type NetworkShortName = {
@@ -458,4 +481,70 @@ export default class RequestProvider {
       console.error(e);
     }
   }
+
+  getMessages(
+    safeAddress: string,
+    options?: Record<string, any>
+  ): Promise<{ results: any[] }> {
+    const checksumAddress = ethers.utils.getAddress(safeAddress);
+    if (this.shouldUseOpenapiService && this.openapiService?.getSafeMessages) {
+      return this.openapiService.getSafeMessages({
+        txServiceUrl: this.prefix,
+        safeAddress: checksumAddress,
+        options,
+      });
+    }
+
+    return this.request.get(`/v1/safes/${checksumAddress}/messages/`, {
+      params: options,
+    });
+  }
+
+  addMessage(
+    safeAddress: string,
+    data: {
+      message: string | Record<string, any>;
+      signature: string;
+      safeAppId?: number;
+    }
+  ): Promise<void> {
+    const checksumAddress = ethers.utils.getAddress(safeAddress);
+    if (this.shouldUseOpenapiService && this.openapiService?.addSafeMessage) {
+      return this.openapiService.addSafeMessage({
+        txServiceUrl: this.prefix,
+        safeAddress: checksumAddress,
+        data,
+      });
+    }
+
+    return this.request.post(`/v1/safes/${checksumAddress}/messages/`, data);
+  }
+
+  getMessage(messageHash: string): Promise<any> {
+    if (this.shouldUseOpenapiService && this.openapiService?.getSafeMessage) {
+      return this.openapiService.getSafeMessage({
+        txServiceUrl: this.prefix,
+        messageHash,
+      });
+    }
+
+    return this.request.get(`/v1/messages/${messageHash}/`);
+  }
+
+  addMessageSignature(messageHash: string, signature: string): Promise<void> {
+    if (
+      this.shouldUseOpenapiService &&
+      this.openapiService?.addSafeMessageSignature
+    ) {
+      return this.openapiService.addSafeMessageSignature({
+        txServiceUrl: this.prefix,
+        messageHash,
+        signature,
+      });
+    }
+
+    return this.request.post(`/v1/messages/${messageHash}/signatures/`, {
+      signature,
+    });
+  }
 }

package/src/index.ts

@@ -12,6 +12,7 @@ import {
 import { EthSafeMessage, EthSafeTransaction } from "@safe-global/protocol-kit";
 import { calculateSafeMessageHash } from "@safe-global/protocol-kit/dist/src/utils";
 import SafeApiKit, {
+  GetSafeMessageListOptions,
   SafeMessage as ApiKitSafeMessage,
 } from "@safe-global/api-kit";
 // import { getTransactionServiceUrl } from "@safe-global/api-kit/dist/src/utils/config";
@@ -104,6 +105,15 @@ class Safe {
     return transactions;
   }
 
+  static async getMessage(messageHash: string, network: string) {
+    const request = new RequestProvider({
+      networkId: network,
+      adapter: Safe.adapter,
+      openapiService: Safe.openapiService,
+    });
+    return request.getMessage(messageHash);
+  }
+
   static createSafeApiKit = (network: string) => {
     return new SafeApiKit({
       chainId: BigInt(network),
@@ -402,7 +412,7 @@ class Safe {
     const safeAddress = this.safeAddress;
 
     try {
-      return this.apiKit.addMessage(safeAddress, {
+      return this.request.addMessage(safeAddress, {
         message: safeMessage.data as string | ApiKitEIP712TypedData,
         signature: safeMessage.encodedSignatures(),
       });
@@ -412,6 +422,34 @@ class Safe {
       );
     }
   }
+
+  async getMessages(options?: GetSafeMessageListOptions) {
+    const safeAddress = this.safeAddress;
+
+    try {
+      return this.request.getMessages(safeAddress, options);
+    } catch (error) {
+      throw new Error("Could not get off-chain messages of the Safe account");
+    }
+  }
+
+  async getMessage(messageHash: string) {
+    try {
+      return this.request.getMessage(messageHash);
+    } catch (error) {
+      throw new Error("Could not get off-chain message of the Safe account");
+    }
+  }
+
+  async addMessageSignature(messageHash: string, signature: string) {
+    try {
+      return this.request.addMessageSignature(messageHash, signature);
+    } catch (error) {
+      throw new Error(
+        "Could not add an off-chain message signature to the Safe account",
+      );
+    }
+  }
 }
 
 export default Safe;