near-safe 0.6.2 → 0.7.0

package/dist/cjs/lib/bundler.d.ts

@@ -1,9 +1,12 @@
 import { Address, Hash, PublicClient, Transport } from "viem";
 import { GasPrices, PaymasterData, UnsignedUserOperation, UserOperation, UserOperationReceipt } from "../types";
+type SponsorshipPolicy = {
+    sponsorshipPolicyId: string;
+};
 type BundlerRpcSchema = [
     {
         Method: "pm_sponsorUserOperation";
-        Parameters: [UnsignedUserOperation, Address];
+        Parameters: [UnsignedUserOperation, Address, SponsorshipPolicy];
         ReturnType: PaymasterData;
     },
     {
@@ -28,7 +31,7 @@ export declare class Erc4337Bundler {
     apiKey: string;
     chainId: number;
     constructor(entryPointAddress: Address, apiKey: string, chainId: number);
-    getPaymasterData(rawUserOp: UnsignedUserOperation, usePaymaster: boolean, safeNotDeployed: boolean): Promise<PaymasterData>;
+    getPaymasterData(rawUserOp: UnsignedUserOperation, safeNotDeployed: boolean, sponsorshipPolicy?: string): Promise<PaymasterData>;
     sendUserOperation(userOp: UserOperation): Promise<Hash>;
     getGasPrice(): Promise<GasPrices>;
     getUserOpReceipt(userOpHash: Hash): Promise<UserOperationReceipt>;

package/dist/cjs/lib/bundler.js

@@ -17,15 +17,16 @@ class Erc4337Bundler {
             rpcSchema: (0, viem_1.rpcSchema)(),
         });
     }
-    async getPaymasterData(rawUserOp, usePaymaster, safeNotDeployed) {
+    async getPaymasterData(rawUserOp, safeNotDeployed, sponsorshipPolicy) {
         // TODO: Keep this option out of the bundler
-        if (usePaymaster) {
+        if (sponsorshipPolicy) {
             console.log("Requesting paymaster data...");
             return handleRequest(() => this.client.request({
                 method: "pm_sponsorUserOperation",
                 params: [
                     { ...rawUserOp, signature: util_1.PLACEHOLDER_SIG },
                     this.entryPointAddress,
+                    { sponsorshipPolicyId: sponsorshipPolicy },
                 ],
             }));
         }

package/dist/cjs/near-safe.d.ts

@@ -70,7 +70,7 @@ export declare class NearSafe {
     buildTransaction(args: {
         chainId: number;
         transactions: MetaTransaction[];
-        usePaymaster: boolean;
+        sponsorshipPolicy?: string;
     }): Promise<UserOperation>;
     /**
      * Signs a transaction with the NEAR adapter using the provided operation hash.
@@ -93,7 +93,7 @@ export declare class NearSafe {
      * @param {boolean} usePaymaster - Flag indicating whether to use a paymaster for gas fees. If true, the transaction will be sponsored by the paymaster.
      * @returns {Promise<EncodedTxData>} - A promise that resolves to the encoded transaction data for the NEAR and EVM networks.
      */
-    encodeSignRequest(signRequest: SignRequestData, usePaymaster: boolean): Promise<EncodedTxData>;
+    encodeSignRequest(signRequest: SignRequestData, sponsorshipPolicy?: string): Promise<EncodedTxData>;
     /**
      * Broadcasts a user operation to the EVM network with a provided signature.
      * Warning: Uses a private ethRPC with sensitive Pimlico API key (should be run server side).
@@ -173,7 +173,7 @@ export declare class NearSafe {
      * - Returns a promise that resolves to an object containing the Ethereum Virtual Machine (EVM) message,
      *   the payload (hashed data), and recovery data needed for reconstructing the signature request.
      */
-    requestRouter({ method, chainId, params }: SignRequestData, usePaymaster: boolean): Promise<{
+    requestRouter({ method, chainId, params }: SignRequestData, sponsorshipPolicy?: string): Promise<{
         evmMessage: string;
         payload: number[];
         hash: Hash;

package/dist/cjs/near-safe.js

@@ -87,7 +87,7 @@ class NearSafe {
      * @throws {Error} - Throws an error if the transaction set is empty or if any operation fails during the building process.
      */
     async buildTransaction(args) {
-        const { transactions, usePaymaster, chainId } = args;
+        const { transactions, sponsorshipPolicy, chainId } = args;
         if (transactions.length === 0) {
             throw new Error("Empty transaction set!");
         }
@@ -101,7 +101,7 @@ class NearSafe {
         // Build Singular MetaTransaction for Multisend from transaction list.
         const tx = transactions.length > 1 ? (0, multisend_1.encodeMulti)(transactions) : transactions[0];
         const rawUserOp = await this.safePack.buildUserOp(nonce, tx, this.address, gasFees.fast, this.setup, !safeDeployed, this.safeSaltNonce);
-        const paymasterData = await bundler.getPaymasterData(rawUserOp, usePaymaster, !safeDeployed);
+        const paymasterData = await bundler.getPaymasterData(rawUserOp, !safeDeployed, sponsorshipPolicy);
         const unsignedUserOp = { ...rawUserOp, ...paymasterData };
         return unsignedUserOp;
     }
@@ -131,8 +131,8 @@ class NearSafe {
      * @param {boolean} usePaymaster - Flag indicating whether to use a paymaster for gas fees. If true, the transaction will be sponsored by the paymaster.
      * @returns {Promise<EncodedTxData>} - A promise that resolves to the encoded transaction data for the NEAR and EVM networks.
      */
-    async encodeSignRequest(signRequest, usePaymaster) {
-        const { payload, evmMessage, hash } = await this.requestRouter(signRequest, usePaymaster);
+    async encodeSignRequest(signRequest, sponsorshipPolicy) {
+        const { payload, evmMessage, hash } = await this.requestRouter(signRequest, sponsorshipPolicy);
         return {
             nearPayload: await this.nearAdapter.mpcContract.encodeSignatureRequestTx({
                 path: this.nearAdapter.derivationPath,
@@ -283,7 +283,7 @@ class NearSafe {
      * - Returns a promise that resolves to an object containing the Ethereum Virtual Machine (EVM) message,
      *   the payload (hashed data), and recovery data needed for reconstructing the signature request.
      */
-    async requestRouter({ method, chainId, params }, usePaymaster) {
+    async requestRouter({ method, chainId, params }, sponsorshipPolicy) {
         const safeInfo = {
             address: { value: this.address },
             chainId: chainId.toString(),
@@ -318,7 +318,7 @@ class NearSafe {
                 const userOp = await this.buildTransaction({
                     chainId,
                     transactions,
-                    usePaymaster,
+                    ...(sponsorshipPolicy ? { sponsorshipPolicy } : {}),
                 });
                 const opHash = await this.opHash(chainId, userOp);
                 return {

package/dist/cjs/types.d.ts

@@ -80,7 +80,7 @@ export interface PaymasterData {
  */
 export interface UserOptions {
     /** Whether to use a paymaster for gas fee coverage. */
-    usePaymaster: boolean;
+    sponsorshipPolicy?: string;
     /** The unique nonce used to differentiate multiple Safe setups. */
     safeSaltNonce: string;
     /** The NEAR contract ID for the MPC contract. */

package/dist/cjs/util.d.ts

@@ -11,4 +11,30 @@ export declare function isContract(address: Address, chainId: number): Promise<b
 export declare function getClient(chainId: number): PublicClient;
 export declare function metaTransactionsFromRequest(params: SessionRequestParams): MetaTransaction[];
 export declare function saltNonceFromMessage(input: string): string;
+/**
+ * Fetches the signature for a NEAR transaction hash. If an `accountId` is provided,
+ * it fetches the signature from the appropriate network. Otherwise, it races across
+ * both `testnet` and `mainnet`.
+ *
+ * @param {string} txHash - The NEAR transaction hash for which to fetch the signature.
+ * @param {string} [accountId] - (Optional) The account ID associated with the transaction.
+ * Providing this will reduce dangling promises as the network is determined by the account.
+ *
+ * @returns {Promise<Hex>} A promise that resolves to the hex-encoded signature.
+ *
+ * @throws Will throw an error if no signature is found for the given transaction hash.
+ */
+export declare function signatureFromTxHash(txHash: string, accountId?: string): Promise<Hex>;
+/**
+ * Races an array of promises and resolves with the first promise that fulfills.
+ * If all promises reject, the function will reject with an error.
+ *
+ * @template T
+ * @param {Promise<T>[]} promises - An array of promises to race. Each promise should resolve to type `T`.
+ *
+ * @returns {Promise<T>} A promise that resolves to the value of the first successfully resolved promise.
+ *
+ * @throws Will throw an error if all promises reject with the message "All promises rejected".
+ */
+export declare function raceToFirstResolve<T>(promises: Promise<T>[]): Promise<T>;
 export {};

package/dist/cjs/util.js

@@ -8,9 +8,10 @@ exports.isContract = isContract;
 exports.getClient = getClient;
 exports.metaTransactionsFromRequest = metaTransactionsFromRequest;
 exports.saltNonceFromMessage = saltNonceFromMessage;
+exports.signatureFromTxHash = signatureFromTxHash;
+exports.raceToFirstResolve = raceToFirstResolve;
 const near_ca_1 = require("near-ca");
 const viem_1 = require("viem");
-//
 exports.PLACEHOLDER_SIG = (0, viem_1.encodePacked)(["uint48", "uint48"], [0, 0]);
 const packGas = (hi, lo) => (0, viem_1.encodePacked)(["uint128", "uint128"], [BigInt(hi), BigInt(lo)]);
 exports.packGas = packGas;
@@ -66,3 +67,66 @@ function saltNonceFromMessage(input) {
     // Return string for readability and transport.
     return BigInt((0, viem_1.keccak256)((0, viem_1.toBytes)(input))).toString();
 }
+/**
+ * Fetches the signature for a NEAR transaction hash. If an `accountId` is provided,
+ * it fetches the signature from the appropriate network. Otherwise, it races across
+ * both `testnet` and `mainnet`.
+ *
+ * @param {string} txHash - The NEAR transaction hash for which to fetch the signature.
+ * @param {string} [accountId] - (Optional) The account ID associated with the transaction.
+ * Providing this will reduce dangling promises as the network is determined by the account.
+ *
+ * @returns {Promise<Hex>} A promise that resolves to the hex-encoded signature.
+ *
+ * @throws Will throw an error if no signature is found for the given transaction hash.
+ */
+async function signatureFromTxHash(txHash, accountId) {
+    if (accountId) {
+        const signature = await (0, near_ca_1.signatureFromTxHash)(`https://archival-rpc.${(0, near_ca_1.getNetworkId)(accountId)}.near.org`, txHash, accountId);
+        return packSignature((0, viem_1.serializeSignature)(signature));
+    }
+    try {
+        const signature = await raceToFirstResolve(["testnet", "mainnet"].map((network) => (0, near_ca_1.signatureFromTxHash)(archiveNode(network), txHash)));
+        return packSignature((0, viem_1.serializeSignature)(signature));
+    }
+    catch {
+        throw new Error(`No signature found for txHash ${txHash}`);
+    }
+}
+/**
+ * Utility function to construct an archive node URL for a given NEAR network.
+ *
+ * @param {string} networkId - The ID of the NEAR network (e.g., 'testnet', 'mainnet').
+ *
+ * @returns {string} The full URL of the archival RPC node for the specified network.
+ */
+const archiveNode = (networkId) => `https://archival-rpc.${networkId}.near.org`;
+/**
+ * Races an array of promises and resolves with the first promise that fulfills.
+ * If all promises reject, the function will reject with an error.
+ *
+ * @template T
+ * @param {Promise<T>[]} promises - An array of promises to race. Each promise should resolve to type `T`.
+ *
+ * @returns {Promise<T>} A promise that resolves to the value of the first successfully resolved promise.
+ *
+ * @throws Will throw an error if all promises reject with the message "All promises rejected".
+ */
+async function raceToFirstResolve(promises) {
+    return new Promise((resolve, reject) => {
+        let rejectionCount = 0;
+        const totalPromises = promises.length;
+        promises.forEach((promise) => {
+            // Wrap each promise so it only resolves when fulfilled
+            Promise.resolve(promise)
+                .then(resolve) // Resolve when any promise resolves
+                .catch(() => {
+                rejectionCount++;
+                // If all promises reject, reject the race with an error
+                if (rejectionCount === totalPromises) {
+                    reject(new Error("All promises rejected"));
+                }
+            });
+        });
+    });
+}

package/dist/esm/lib/bundler.d.ts

@@ -1,9 +1,12 @@
 import { Address, Hash, PublicClient, Transport } from "viem";
 import { GasPrices, PaymasterData, UnsignedUserOperation, UserOperation, UserOperationReceipt } from "../types";
+type SponsorshipPolicy = {
+    sponsorshipPolicyId: string;
+};
 type BundlerRpcSchema = [
     {
         Method: "pm_sponsorUserOperation";
-        Parameters: [UnsignedUserOperation, Address];
+        Parameters: [UnsignedUserOperation, Address, SponsorshipPolicy];
         ReturnType: PaymasterData;
     },
     {
@@ -28,7 +31,7 @@ export declare class Erc4337Bundler {
     apiKey: string;
     chainId: number;
     constructor(entryPointAddress: Address, apiKey: string, chainId: number);
-    getPaymasterData(rawUserOp: UnsignedUserOperation, usePaymaster: boolean, safeNotDeployed: boolean): Promise<PaymasterData>;
+    getPaymasterData(rawUserOp: UnsignedUserOperation, safeNotDeployed: boolean, sponsorshipPolicy?: string): Promise<PaymasterData>;
     sendUserOperation(userOp: UserOperation): Promise<Hash>;
     getGasPrice(): Promise<GasPrices>;
     getUserOpReceipt(userOpHash: Hash): Promise<UserOperationReceipt>;

package/dist/esm/lib/bundler.js

@@ -17,15 +17,16 @@ export class Erc4337Bundler {
             rpcSchema: rpcSchema(),
         });
     }
-    async getPaymasterData(rawUserOp, usePaymaster, safeNotDeployed) {
+    async getPaymasterData(rawUserOp, safeNotDeployed, sponsorshipPolicy) {
         // TODO: Keep this option out of the bundler
-        if (usePaymaster) {
+        if (sponsorshipPolicy) {
             console.log("Requesting paymaster data...");
             return handleRequest(() => this.client.request({
                 method: "pm_sponsorUserOperation",
                 params: [
                     { ...rawUserOp, signature: PLACEHOLDER_SIG },
                     this.entryPointAddress,
+                    { sponsorshipPolicyId: sponsorshipPolicy },
                 ],
             }));
         }

package/dist/esm/near-safe.d.ts

@@ -70,7 +70,7 @@ export declare class NearSafe {
     buildTransaction(args: {
         chainId: number;
         transactions: MetaTransaction[];
-        usePaymaster: boolean;
+        sponsorshipPolicy?: string;
     }): Promise<UserOperation>;
     /**
      * Signs a transaction with the NEAR adapter using the provided operation hash.
@@ -93,7 +93,7 @@ export declare class NearSafe {
      * @param {boolean} usePaymaster - Flag indicating whether to use a paymaster for gas fees. If true, the transaction will be sponsored by the paymaster.
      * @returns {Promise<EncodedTxData>} - A promise that resolves to the encoded transaction data for the NEAR and EVM networks.
      */
-    encodeSignRequest(signRequest: SignRequestData, usePaymaster: boolean): Promise<EncodedTxData>;
+    encodeSignRequest(signRequest: SignRequestData, sponsorshipPolicy?: string): Promise<EncodedTxData>;
     /**
      * Broadcasts a user operation to the EVM network with a provided signature.
      * Warning: Uses a private ethRPC with sensitive Pimlico API key (should be run server side).
@@ -173,7 +173,7 @@ export declare class NearSafe {
      * - Returns a promise that resolves to an object containing the Ethereum Virtual Machine (EVM) message,
      *   the payload (hashed data), and recovery data needed for reconstructing the signature request.
      */
-    requestRouter({ method, chainId, params }: SignRequestData, usePaymaster: boolean): Promise<{
+    requestRouter({ method, chainId, params }: SignRequestData, sponsorshipPolicy?: string): Promise<{
         evmMessage: string;
         payload: number[];
         hash: Hash;

package/dist/esm/near-safe.js

@@ -90,7 +90,7 @@ export class NearSafe {
      * @throws {Error} - Throws an error if the transaction set is empty or if any operation fails during the building process.
      */
     async buildTransaction(args) {
-        const { transactions, usePaymaster, chainId } = args;
+        const { transactions, sponsorshipPolicy, chainId } = args;
         if (transactions.length === 0) {
             throw new Error("Empty transaction set!");
         }
@@ -104,7 +104,7 @@ export class NearSafe {
         // Build Singular MetaTransaction for Multisend from transaction list.
         const tx = transactions.length > 1 ? encodeMulti(transactions) : transactions[0];
         const rawUserOp = await this.safePack.buildUserOp(nonce, tx, this.address, gasFees.fast, this.setup, !safeDeployed, this.safeSaltNonce);
-        const paymasterData = await bundler.getPaymasterData(rawUserOp, usePaymaster, !safeDeployed);
+        const paymasterData = await bundler.getPaymasterData(rawUserOp, !safeDeployed, sponsorshipPolicy);
         const unsignedUserOp = { ...rawUserOp, ...paymasterData };
         return unsignedUserOp;
     }
@@ -134,8 +134,8 @@ export class NearSafe {
      * @param {boolean} usePaymaster - Flag indicating whether to use a paymaster for gas fees. If true, the transaction will be sponsored by the paymaster.
      * @returns {Promise<EncodedTxData>} - A promise that resolves to the encoded transaction data for the NEAR and EVM networks.
      */
-    async encodeSignRequest(signRequest, usePaymaster) {
-        const { payload, evmMessage, hash } = await this.requestRouter(signRequest, usePaymaster);
+    async encodeSignRequest(signRequest, sponsorshipPolicy) {
+        const { payload, evmMessage, hash } = await this.requestRouter(signRequest, sponsorshipPolicy);
         return {
             nearPayload: await this.nearAdapter.mpcContract.encodeSignatureRequestTx({
                 path: this.nearAdapter.derivationPath,
@@ -286,7 +286,7 @@ export class NearSafe {
      * - Returns a promise that resolves to an object containing the Ethereum Virtual Machine (EVM) message,
      *   the payload (hashed data), and recovery data needed for reconstructing the signature request.
      */
-    async requestRouter({ method, chainId, params }, usePaymaster) {
+    async requestRouter({ method, chainId, params }, sponsorshipPolicy) {
         const safeInfo = {
             address: { value: this.address },
             chainId: chainId.toString(),
@@ -321,7 +321,7 @@ export class NearSafe {
                 const userOp = await this.buildTransaction({
                     chainId,
                     transactions,
-                    usePaymaster,
+                    ...(sponsorshipPolicy ? { sponsorshipPolicy } : {}),
                 });
                 const opHash = await this.opHash(chainId, userOp);
                 return {

package/dist/esm/types.d.ts

@@ -80,7 +80,7 @@ export interface PaymasterData {
  */
 export interface UserOptions {
     /** Whether to use a paymaster for gas fee coverage. */
-    usePaymaster: boolean;
+    sponsorshipPolicy?: string;
     /** The unique nonce used to differentiate multiple Safe setups. */
     safeSaltNonce: string;
     /** The NEAR contract ID for the MPC contract. */

package/dist/esm/util.d.ts

@@ -11,4 +11,30 @@ export declare function isContract(address: Address, chainId: number): Promise<b
 export declare function getClient(chainId: number): PublicClient;
 export declare function metaTransactionsFromRequest(params: SessionRequestParams): MetaTransaction[];
 export declare function saltNonceFromMessage(input: string): string;
+/**
+ * Fetches the signature for a NEAR transaction hash. If an `accountId` is provided,
+ * it fetches the signature from the appropriate network. Otherwise, it races across
+ * both `testnet` and `mainnet`.
+ *
+ * @param {string} txHash - The NEAR transaction hash for which to fetch the signature.
+ * @param {string} [accountId] - (Optional) The account ID associated with the transaction.
+ * Providing this will reduce dangling promises as the network is determined by the account.
+ *
+ * @returns {Promise<Hex>} A promise that resolves to the hex-encoded signature.
+ *
+ * @throws Will throw an error if no signature is found for the given transaction hash.
+ */
+export declare function signatureFromTxHash(txHash: string, accountId?: string): Promise<Hex>;
+/**
+ * Races an array of promises and resolves with the first promise that fulfills.
+ * If all promises reject, the function will reject with an error.
+ *
+ * @template T
+ * @param {Promise<T>[]} promises - An array of promises to race. Each promise should resolve to type `T`.
+ *
+ * @returns {Promise<T>} A promise that resolves to the value of the first successfully resolved promise.
+ *
+ * @throws Will throw an error if all promises reject with the message "All promises rejected".
+ */
+export declare function raceToFirstResolve<T>(promises: Promise<T>[]): Promise<T>;
 export {};

package/dist/esm/util.js

@@ -1,6 +1,5 @@
-import { Network } from "near-ca";
-import { concatHex, encodePacked, toHex, isHex, parseTransaction, zeroAddress, toBytes, keccak256, } from "viem";
-//
+import { getNetworkId, Network, signatureFromTxHash as sigFromHash, } from "near-ca";
+import { concatHex, encodePacked, toHex, isHex, parseTransaction, zeroAddress, toBytes, keccak256, serializeSignature, } from "viem";
 export const PLACEHOLDER_SIG = encodePacked(["uint48", "uint48"], [0, 0]);
 export const packGas = (hi, lo) => encodePacked(["uint128", "uint128"], [BigInt(hi), BigInt(lo)]);
 export function packSignature(signature, validFrom = 0, validTo = 0) {
@@ -55,3 +54,66 @@ export function saltNonceFromMessage(input) {
     // Return string for readability and transport.
     return BigInt(keccak256(toBytes(input))).toString();
 }
+/**
+ * Fetches the signature for a NEAR transaction hash. If an `accountId` is provided,
+ * it fetches the signature from the appropriate network. Otherwise, it races across
+ * both `testnet` and `mainnet`.
+ *
+ * @param {string} txHash - The NEAR transaction hash for which to fetch the signature.
+ * @param {string} [accountId] - (Optional) The account ID associated with the transaction.
+ * Providing this will reduce dangling promises as the network is determined by the account.
+ *
+ * @returns {Promise<Hex>} A promise that resolves to the hex-encoded signature.
+ *
+ * @throws Will throw an error if no signature is found for the given transaction hash.
+ */
+export async function signatureFromTxHash(txHash, accountId) {
+    if (accountId) {
+        const signature = await sigFromHash(`https://archival-rpc.${getNetworkId(accountId)}.near.org`, txHash, accountId);
+        return packSignature(serializeSignature(signature));
+    }
+    try {
+        const signature = await raceToFirstResolve(["testnet", "mainnet"].map((network) => sigFromHash(archiveNode(network), txHash)));
+        return packSignature(serializeSignature(signature));
+    }
+    catch {
+        throw new Error(`No signature found for txHash ${txHash}`);
+    }
+}
+/**
+ * Utility function to construct an archive node URL for a given NEAR network.
+ *
+ * @param {string} networkId - The ID of the NEAR network (e.g., 'testnet', 'mainnet').
+ *
+ * @returns {string} The full URL of the archival RPC node for the specified network.
+ */
+const archiveNode = (networkId) => `https://archival-rpc.${networkId}.near.org`;
+/**
+ * Races an array of promises and resolves with the first promise that fulfills.
+ * If all promises reject, the function will reject with an error.
+ *
+ * @template T
+ * @param {Promise<T>[]} promises - An array of promises to race. Each promise should resolve to type `T`.
+ *
+ * @returns {Promise<T>} A promise that resolves to the value of the first successfully resolved promise.
+ *
+ * @throws Will throw an error if all promises reject with the message "All promises rejected".
+ */
+export async function raceToFirstResolve(promises) {
+    return new Promise((resolve, reject) => {
+        let rejectionCount = 0;
+        const totalPromises = promises.length;
+        promises.forEach((promise) => {
+            // Wrap each promise so it only resolves when fulfilled
+            Promise.resolve(promise)
+                .then(resolve) // Resolve when any promise resolves
+                .catch(() => {
+                rejectionCount++;
+                // If all promises reject, reject the race with an error
+                if (rejectionCount === totalPromises) {
+                    reject(new Error("All promises rejected"));
+                }
+            });
+        });
+    });
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "near-safe",
-  "version": "0.6.2",
+  "version": "0.7.0",
   "license": "MIT",
   "description": "An SDK for controlling Ethereum Smart Accounts via ERC4337 from a Near Account.",
   "author": "bh2smith",
@@ -36,15 +36,15 @@
     "start": "yarn example",
     "example": "tsx examples/send-tx.ts",
     "lint": "eslint . --ignore-pattern dist/",
-    "test": "jest",
     "fmt": "prettier --write '{src,examples,tests}/**/*.{js,jsx,ts,tsx}' && yarn lint --fix",
+    "test": "jest",
     "all": "yarn fmt && yarn lint && yarn build"
   },
   "dependencies": {
     "@safe-global/safe-gateway-typescript-sdk": "^3.22.2",
     "ethers-multisend": "^3.1.0",
     "near-api-js": "^5.0.0",
-    "near-ca": "^0.5.9",
+    "near-ca": "^0.5.10",
     "semver": "^7.6.3",
     "viem": "^2.16.5"
   },