@circle-fin/usdckit 0.21.1 → 0.23.0

package/dist/cjs/providers/circle-wallets/actions/getAccounts.d.ts

@@ -1,4 +1,5 @@
-import type { Address, ChainContract, ExtendedViemClient, NativeUnits } from '../../../types.js';
+import type { ExtendedViemClient } from '../../../client.js';
+import type { Address, ChainContract, NativeUnits } from '../../../types.js';
 import type { Chain } from '../index.js';
 export type GetAccountsInput = {
     address?: Address;
@@ -365,6 +366,185 @@ export declare function getAccounts(client: ExtendedViemClient, params: GetAccou
         readonly blockchainId: "ARB-SEPOLIA";
         readonly blockchainVm: "EVM";
         readonly formatters?: undefined | undefined;
+    } | {
+        blockExplorers: {
+            readonly default: {
+                readonly name: "ArcScan";
+                readonly url: "https://testnet.arcscan.app";
+                readonly apiUrl: "https://testnet.arcscan.app/api";
+            };
+        };
+        blockTime?: number | undefined | undefined;
+        contracts: {
+            readonly USDC: {
+                readonly address: "0x3600000000000000000000000000000000000000";
+                readonly abi: readonly [{
+                    readonly type: "event";
+                    readonly name: "Approval";
+                    readonly inputs: readonly [{
+                        readonly indexed: true;
+                        readonly name: "owner";
+                        readonly type: "address";
+                    }, {
+                        readonly indexed: true;
+                        readonly name: "spender";
+                        readonly type: "address";
+                    }, {
+                        readonly indexed: false;
+                        readonly name: "value";
+                        readonly type: "uint256";
+                    }];
+                }, {
+                    readonly type: "event";
+                    readonly name: "Transfer";
+                    readonly inputs: readonly [{
+                        readonly indexed: true;
+                        readonly name: "from";
+                        readonly type: "address";
+                    }, {
+                        readonly indexed: true;
+                        readonly name: "to";
+                        readonly type: "address";
+                    }, {
+                        readonly indexed: false;
+                        readonly name: "value";
+                        readonly type: "uint256";
+                    }];
+                }, {
+                    readonly type: "function";
+                    readonly name: "allowance";
+                    readonly stateMutability: "view";
+                    readonly inputs: readonly [{
+                        readonly name: "owner";
+                        readonly type: "address";
+                    }, {
+                        readonly name: "spender";
+                        readonly type: "address";
+                    }];
+                    readonly outputs: readonly [{
+                        readonly type: "uint256";
+                    }];
+                }, {
+                    readonly type: "function";
+                    readonly name: "approve";
+                    readonly stateMutability: "nonpayable";
+                    readonly inputs: readonly [{
+                        readonly name: "spender";
+                        readonly type: "address";
+                    }, {
+                        readonly name: "amount";
+                        readonly type: "uint256";
+                    }];
+                    readonly outputs: readonly [{
+                        readonly type: "bool";
+                    }];
+                }, {
+                    readonly type: "function";
+                    readonly name: "balanceOf";
+                    readonly stateMutability: "view";
+                    readonly inputs: readonly [{
+                        readonly name: "account";
+                        readonly type: "address";
+                    }];
+                    readonly outputs: readonly [{
+                        readonly type: "uint256";
+                    }];
+                }, {
+                    readonly type: "function";
+                    readonly name: "decimals";
+                    readonly stateMutability: "view";
+                    readonly inputs: readonly [];
+                    readonly outputs: readonly [{
+                        readonly type: "uint8";
+                    }];
+                }, {
+                    readonly type: "function";
+                    readonly name: "name";
+                    readonly stateMutability: "view";
+                    readonly inputs: readonly [];
+                    readonly outputs: readonly [{
+                        readonly type: "string";
+                    }];
+                }, {
+                    readonly type: "function";
+                    readonly name: "symbol";
+                    readonly stateMutability: "view";
+                    readonly inputs: readonly [];
+                    readonly outputs: readonly [{
+                        readonly type: "string";
+                    }];
+                }, {
+                    readonly type: "function";
+                    readonly name: "totalSupply";
+                    readonly stateMutability: "view";
+                    readonly inputs: readonly [];
+                    readonly outputs: readonly [{
+                        readonly type: "uint256";
+                    }];
+                }, {
+                    readonly type: "function";
+                    readonly name: "transfer";
+                    readonly stateMutability: "nonpayable";
+                    readonly inputs: readonly [{
+                        readonly name: "recipient";
+                        readonly type: "address";
+                    }, {
+                        readonly name: "amount";
+                        readonly type: "uint256";
+                    }];
+                    readonly outputs: readonly [{
+                        readonly type: "bool";
+                    }];
+                }, {
+                    readonly type: "function";
+                    readonly name: "transferFrom";
+                    readonly stateMutability: "nonpayable";
+                    readonly inputs: readonly [{
+                        readonly name: "sender";
+                        readonly type: "address";
+                    }, {
+                        readonly name: "recipient";
+                        readonly type: "address";
+                    }, {
+                        readonly name: "amount";
+                        readonly type: "uint256";
+                    }];
+                    readonly outputs: readonly [{
+                        readonly type: "bool";
+                    }];
+                }];
+                readonly read: {
+                    readonly decimals: () => 6;
+                };
+            };
+            readonly multicall3: {
+                readonly address: "0xcA11bde05977b3631167028862bE2a173976CA11";
+                readonly blockCreated: 0;
+            };
+        };
+        ensTlds?: readonly string[] | undefined;
+        id: 5042002;
+        name: "Arc Testnet";
+        nativeCurrency: {
+            readonly name: "USDC";
+            readonly symbol: "USDC";
+            readonly decimals: 18;
+        };
+        experimental_preconfirmationTime?: number | undefined | undefined;
+        rpcUrls: {
+            readonly default: {
+                readonly http: readonly ["https://rpc.testnet.arc.network", "https://rpc.quicknode.testnet.arc.network", "https://rpc.blockdaemon.testnet.arc.network"];
+                readonly webSocket: readonly ["wss://rpc.testnet.arc.network", "wss://rpc.quicknode.testnet.arc.network"];
+            };
+        };
+        sourceId?: number | undefined | undefined;
+        testnet: true;
+        custom?: Record<string, unknown> | undefined;
+        fees?: import("viem").ChainFees<undefined> | undefined;
+        serializers?: import("viem").ChainSerializers<undefined, import("viem").TransactionSerializable> | undefined;
+        readonly blockchainId: "ARC-TESTNET";
+        readonly blockchainVm: "EVM";
+        readonly formatters?: undefined;
     } | {
         blockExplorers: {
             readonly default: {

package/dist/cjs/providers/circle-wallets/actions/getNotificationSignature.d.ts

@@ -1,4 +1,4 @@
-import type { ExtendedViemClient } from '../../../types.js';
+import type { ExtendedViemClient } from '../../../client.js';
 import type { GetNotificationSignatureInput } from '../transports/index.js';
 /**
  * Get the public key and algorithm used to digitally sign webhook notifications. Verifying the digital signature ensures the notification came from Circle.

package/dist/cjs/providers/circle-wallets/actions/getTokenBalances.d.ts

@@ -1,4 +1,6 @@
-import type { Account, Address, BaseUnits, ChainContract, ExtendedViemClient, NativeUnits } from '../../../types.js';
+import type { GetTokenBalanceReturnType } from '../../../actions/getTokenBalance.js';
+import type { ExtendedViemClient } from '../../../client.js';
+import type { Account, Address, ChainContract } from '../../../types.js';
 import type { Chain } from '../index.js';
 import type { GetWalletTokenBalanceInput as _GetWalletTokenBalanceInput } from '../transports/index.js';
 export type GetTokenBalancesInput = _GetWalletTokenBalanceInput & {
@@ -6,17 +8,4 @@ export type GetTokenBalancesInput = _GetWalletTokenBalanceInput & {
     chain?: Chain;
     token?: Address | ChainContract | null;
 };
-export type TokenBalance = {
-    token: Address | undefined;
-    decimals: number | undefined;
-    symbol: string | undefined;
-    value: BaseUnits;
-    formatted: NativeUnits;
-};
-export declare function getTokenBalances(client: ExtendedViemClient, params: GetTokenBalancesInput): Promise<{
-    token: Address | undefined;
-    decimals: number;
-    symbol: string | undefined;
-    value: bigint;
-    formatted: NativeUnits;
-}[]>;
+export declare function getTokenBalances(client: ExtendedViemClient, params: GetTokenBalancesInput): Promise<GetTokenBalanceReturnType[]>;

package/dist/cjs/providers/circle-wallets/actions/getTransactionById.d.ts

@@ -1,4 +1,4 @@
-import type { ExtendedViemClient } from '../../../types.js';
+import type { ExtendedViemClient } from '../../../client.js';
 import type { GetTransactionInput } from '../transports/index.js';
 /**
  * Retrieves info for a single transaction using its unique identifier.

package/dist/cjs/providers/circle-wallets/actions/getWallet.d.ts

@@ -1,4 +1,4 @@
-import type { ExtendedViemClient } from '../../../types.js';
+import type { ExtendedViemClient } from '../../../client.js';
 import type { GetWalletInput } from '../transports/index.js';
 /**
  * Retrieve an existing {@link Wallet}

package/dist/cjs/providers/circle-wallets/actions/getWalletTokenBalance.d.ts

@@ -1,4 +1,4 @@
-import type { ExtendedViemClient } from '../../../types.js';
+import type { ExtendedViemClient } from '../../../client.js';
 import type { GetWalletTokenBalanceInput } from '../transports/index.js';
 /**
  * Fetches the digital asset balance for a single developer-controlled Wallet using its unique identifier.

package/dist/cjs/providers/circle-wallets/actions/getWalletsWithBalances.d.ts

@@ -1,3 +1,3 @@
-import type { ExtendedViemClient } from '../../../types.js';
+import type { ExtendedViemClient } from '../../../client.js';
 import type { GetWalletsWithBalancesInput } from '../transports/index.js';
 export declare function getWalletsWithBalances(client: ExtendedViemClient, params: GetWalletsWithBalancesInput): Promise<import("@circle-fin/developer-controlled-wallets/dist/types/clients/developer-controlled-wallets.js").Wallet[]>;

package/dist/cjs/providers/circle-wallets/actions/importContract.d.ts

@@ -1,3 +1,3 @@
-import type { ExtendedViemClient } from '../../../types.js';
+import type { ExtendedViemClient } from '../../../client.js';
 import type { ImportContractInput } from '../transports/index.js';
 export declare function importContract(client: ExtendedViemClient, params: ImportContractInput): Promise<import("@circle-fin/smart-contract-platform").Contract>;

package/dist/cjs/providers/circle-wallets/actions/index.d.ts

@@ -19,9 +19,7 @@ import { listTransactions } from './listTransactions.js';
 import { listWallets } from './listWallets.js';
 import { requestTestnetTokens } from './requestTestnetTokens.js';
 import { signTransaction } from './signTransaction.js';
-import { signTypedData } from './signTypedData.js';
 import { verifyNotification } from './verifyNotification.js';
-import { waitForTransactionHash } from './waitForTransactionHash.js';
 import { writeContract } from './writeContract.js';
 import type { Account } from '../../../types.js';
 import type { Chain } from '../index.js';
@@ -46,10 +44,8 @@ export * from './importContract.js';
 export * from './listTransactions.js';
 export * from './listWallets.js';
 export * from './requestTestnetTokens.js';
-export * from './signTypedData.js';
 export * from './signTransaction.js';
 export * from './verifyNotification.js';
-export * from './waitForTransactionHash.js';
 export * from './writeContract.js';
 export type Actions<transport extends Transport = Transport, chain extends ViemChain | undefined = Chain | undefined, account extends Account | undefined = Account | undefined> = {
     /** See {@link createWalletSet} action */
@@ -94,12 +90,8 @@ export type Actions<transport extends Transport = Transport, chain extends ViemC
     getTokenBalances: (params: Parameters<typeof getTokenBalances>[1]) => ReturnType<typeof getTokenBalances>;
     /** See {@link signTransaction} action */
     signTransaction: (params: Parameters<typeof signTransaction>[1]) => ReturnType<typeof signTransaction>;
-    /** See {@link signTypedData} action */
-    signTypedData: (params: Parameters<typeof signTypedData>[1]) => ReturnType<typeof signTypedData>;
     /** See {@link verifyNotification} action */
     verifyNotification: (params: Parameters<typeof verifyNotification>[1]) => ReturnType<typeof verifyNotification>;
-    /** See {@link waitForTransactionHash} action */
-    waitForTransactionHash: (params: Parameters<typeof waitForTransactionHash>[1]) => ReturnType<typeof waitForTransactionHash>;
     /** See {@link writeContract} action */
     writeContract: (params: any) => ReturnType<typeof writeContract>;
 };

package/dist/cjs/providers/circle-wallets/actions/index.js

@@ -46,9 +46,7 @@ const listTransactions_js_1 = require("./listTransactions.js");
 const listWallets_js_1 = require("./listWallets.js");
 const requestTestnetTokens_js_1 = require("./requestTestnetTokens.js");
 const signTransaction_js_1 = require("./signTransaction.js");
-const signTypedData_js_1 = require("./signTypedData.js");
 const verifyNotification_js_1 = require("./verifyNotification.js");
-const waitForTransactionHash_js_1 = require("./waitForTransactionHash.js");
 const writeContract_js_1 = require("./writeContract.js");
 __exportStar(require("./createAccount.js"), exports);
 __exportStar(require("./createContractExecutionTransaction.js"), exports);
@@ -70,10 +68,8 @@ __exportStar(require("./importContract.js"), exports);
 __exportStar(require("./listTransactions.js"), exports);
 __exportStar(require("./listWallets.js"), exports);
 __exportStar(require("./requestTestnetTokens.js"), exports);
-__exportStar(require("./signTypedData.js"), exports);
 __exportStar(require("./signTransaction.js"), exports);
 __exportStar(require("./verifyNotification.js"), exports);
-__exportStar(require("./waitForTransactionHash.js"), exports);
 __exportStar(require("./writeContract.js"), exports);
 function actions(client) {
     const _client = client;
@@ -104,8 +100,6 @@ function actions(client) {
         deriveWallet: (params) => (0, deriveWallet_js_1.deriveWallet)(_client, params),
         /** See {@link signTransaction} action */
         signTransaction: (params) => (0, signTransaction_js_1.signTransaction)(_client, params),
-        /** See {@link signTypedData} action */
-        signTypedData: (params) => (0, signTypedData_js_1.signTypedData)(_client, params),
         /** See {@link requestTestnetTokens} action */
         requestTestnetTokens: (params) => (0, requestTestnetTokens_js_1.requestTestnetTokens)(_client, params),
         /** See {@link importContract} action */
@@ -124,8 +118,6 @@ function actions(client) {
         getTokenBalances: (params) => (0, getTokenBalances_js_1.getTokenBalances)(_client, params),
         /** See {@link verifyNotification} action */
         verifyNotification: (params) => (0, verifyNotification_js_1.verifyNotification)(_client, params),
-        /** See {@link waitForTransactionHash} action */
-        waitForTransactionHash: (params) => (0, waitForTransactionHash_js_1.waitForTransactionHash)(_client, params),
         /** See {@link writeContract} action */
         writeContract: (params) => (0, writeContract_js_1.writeContract)(_client, params),
     };

package/dist/cjs/providers/circle-wallets/actions/index.test.js

@@ -66,12 +66,8 @@ vitest_1.describe.concurrent('actions', () => {
             // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
             signTransaction: vitest_1.expect.any(Function),
             // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
-            signTypedData: vitest_1.expect.any(Function),
-            // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
             verifyNotification: vitest_1.expect.any(Function),
             // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
-            waitForTransactionHash: vitest_1.expect.any(Function),
-            // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
             writeContract: vitest_1.expect.any(Function),
         });
     });

package/dist/cjs/providers/circle-wallets/actions/listTransactions.d.ts

@@ -1,4 +1,4 @@
-import type { ExtendedViemClient } from '../../../types.js';
+import type { ExtendedViemClient } from '../../../client.js';
 import type { ListTransactionsInput } from '../transports/index.js';
 /**
  * Retrieves a list of transactions that fit the specified parameters.

package/dist/cjs/providers/circle-wallets/actions/listWallets.d.ts

@@ -1,4 +1,4 @@
-import type { ExtendedViemClient } from '../../../types.js';
+import type { ExtendedViemClient } from '../../../client.js';
 import type { ListWalletsInput } from '../transports/index.js';
 /**
  * Retrieves a list of all wallets that fit the specified parameters.

package/dist/cjs/providers/circle-wallets/actions/requestTestnetTokens.d.ts

@@ -1,3 +1,3 @@
-import type { ExtendedViemClient } from '../../../types.js';
+import type { ExtendedViemClient } from '../../../client.js';
 import type { RequestTestnetTokensInput } from '../transports/index.js';
 export declare function requestTestnetTokens(client: ExtendedViemClient, params: RequestTestnetTokensInput): Promise<void>;

package/dist/cjs/providers/circle-wallets/actions/signTransaction.d.ts

@@ -1,4 +1,4 @@
-import type { ExtendedViemClient } from '../../../types.js';
+import type { ExtendedViemClient } from '../../../client.js';
 import type { SignTransactionInput } from '../transports/index.js';
 /**
  * Sign a transaction from a specific developer-controlled wallet.

package/dist/cjs/providers/circle-wallets/actions/verifyNotification.d.ts

@@ -1,4 +1,4 @@
-import type { ExtendedViemClient } from '../../../types.js';
+import type { ExtendedViemClient } from '../../../client.js';
 export type VerifyNotificationInput = {
     kid: string;
     message: Buffer;

package/dist/cjs/providers/circle-wallets/actions/writeContract.d.ts

@@ -1,4 +1,5 @@
-import type { ControlFlowOptions, ExtendedViemClient } from '../../../types.js';
+import type { ExtendedViemClient } from '../../../client.js';
+import type { ControlFlowOptions } from '../../../types.js';
 import type { Chain } from '../index.js';
 import type { WriteContractParameters as _WriteContractParameters } from 'viem';
 import type { writeContract as _writeContract } from 'viem/actions';

package/dist/cjs/providers/circle-wallets/actions/writeContract.js

@@ -21,11 +21,9 @@ const index_js_1 = require("../index.js");
 const index_js_2 = require("../transports/index.js");
 const createContractExecutionTransaction_js_1 = require("./createContractExecutionTransaction.js");
 const estimateContractExecutionFee_js_1 = require("./estimateContractExecutionFee.js");
-const waitForTransactionHash_js_1 = require("./waitForTransactionHash.js");
 async function writeContract(client, params) {
     const createContractExecutionTransaction = (0, utils_1.getAction)(client, createContractExecutionTransaction_js_1.createContractExecutionTransaction, 'createContractExecutionTransaction');
     const estimateContractExecutionFee = (0, utils_1.getAction)(client, estimateContractExecutionFee_js_1.estimateContractExecutionFee, 'estimateContractExecutionFee');
-    const waitForTransactionHash = (0, utils_1.getAction)(client, waitForTransactionHash_js_1.waitForTransactionHash, 'waitForTransactionHash');
     const { abi, account: _account, address, args, functionName, value, chain: _chain = client.chain } = params;
     let { gas, maxFeePerGas, maxPriorityFeePerGas } = params;
     const account = (0, parseAccount_js_1.parseAccount)(_account, { chain: _chain });
@@ -66,8 +64,7 @@ async function writeContract(client, params) {
                 priorityFee: (0, utils_1.formatGwei)(maxPriorityFeePerGas),
             },
         },
+        signal: params?.signal,
     });
-    // NOTE: `createContractExecutionTransaction` does not produce `txHash`
-    const { txHash } = await waitForTransactionHash({ ...transaction, signal: params?.signal });
-    return txHash;
+    return transaction.txHash;
 }

package/dist/cjs/providers/circle-wallets/actions/writeContract.test.js

@@ -21,7 +21,6 @@ const writeContract_js_1 = require("./writeContract.js");
         request: vitest_1.vi.fn(),
         createContractExecutionTransaction: vitest_1.vi.fn(),
         estimateContractExecutionFee: vitest_1.vi.fn(),
-        waitForTransactionHash: vitest_1.vi.fn(),
     };
     const USDC = {
         address: '0xa0b86991c6218b36c1d19d4a2e9eb0ce3606eb48',
@@ -64,9 +63,9 @@ const writeContract_js_1 = require("./writeContract.js");
                             config: { gasLimit: '21000', maxFee: '0.01', priorityFee: '0.001' },
                         },
                     },
-                    { id: 'tx-id', state: 'PENDING' },
+                    { id: 'tx-id', state: 'PENDING', txHash: 'tx-hash' },
                 ],
-                [{ id: 'tx-id' }, { id: 'tx-id', state: 'COMPLETE', txHash: 'tx-hash' }],
+                undefined,
             ],
             'tx-hash',
         ],
@@ -96,27 +95,23 @@ const writeContract_js_1 = require("./writeContract.js");
                             config: { gasLimit: '1', maxFee: '0.000000002', priorityFee: '0.000000003' },
                         },
                     },
-                    { id: 'tx-id', state: 'PENDING' },
+                    { id: 'tx-id', state: 'PENDING', txHash: 'tx-hash' },
                 ],
-                [{ id: 'tx-id' }, { id: 'tx-id', state: 'COMPLETE', txHash: 'tx-hash' }],
+                undefined,
             ],
             'tx-hash',
         ],
-    ])('should return txHash using %s', async (_, params, [estimateContractExecutionFee, createContractExecutionTransaction, waitForTransactionHash], expectedResult) => {
+    ])('should return txHash using %s', async (_, params, [estimateContractExecutionFee, createContractExecutionTransaction], expectedResult) => {
         if (estimateContractExecutionFee !== undefined)
             client.estimateContractExecutionFee.mockResolvedValue(estimateContractExecutionFee[1]);
         if (createContractExecutionTransaction !== undefined)
             client.createContractExecutionTransaction.mockResolvedValue(createContractExecutionTransaction[1]);
-        if (waitForTransactionHash !== undefined)
-            client.waitForTransactionHash.mockResolvedValue(waitForTransactionHash[1]);
         const result = await (0, writeContract_js_1.writeContract)(client, params);
         (0, vitest_1.expect)(result).toEqual(expectedResult);
         if (estimateContractExecutionFee !== undefined)
             (0, vitest_1.expect)(client.estimateContractExecutionFee).toHaveBeenCalledWith(vitest_1.expect.objectContaining(estimateContractExecutionFee[0]));
         if (createContractExecutionTransaction !== undefined)
             (0, vitest_1.expect)(client.createContractExecutionTransaction).toHaveBeenCalledWith(vitest_1.expect.objectContaining(createContractExecutionTransaction[0]));
-        if (waitForTransactionHash !== undefined)
-            (0, vitest_1.expect)(client.waitForTransactionHash).toHaveBeenCalledWith(vitest_1.expect.objectContaining(waitForTransactionHash[0]));
     });
     (0, vitest_1.it)('should throw UnsupportedChainError for unsupported chain', async () => {
         await (0, vitest_1.expect)((0, writeContract_js_1.writeContract)(client, {
@@ -143,8 +138,7 @@ const writeContract_js_1 = require("./writeContract.js");
                 preVerificationGas: '33333',
             };
             client.estimateContractExecutionFee.mockResolvedValue(scaFeeResponse);
-            client.createContractExecutionTransaction.mockResolvedValue({ id: 'tx-id', state: 'PENDING' });
-            client.waitForTransactionHash.mockResolvedValue({ id: 'tx-id', state: 'COMPLETE', txHash: 'tx-hash' });
+            client.createContractExecutionTransaction.mockResolvedValue({ id: 'tx-id', state: 'PENDING', txHash: 'tx-hash' });
             const params = {
                 abi: USDC.abi,
                 address: USDC.address,
@@ -177,8 +171,7 @@ const writeContract_js_1 = require("./writeContract.js");
                 low: { gasLimit: '19000', maxFee: '0.006', priorityFee: '0.0006' },
             };
             client.estimateContractExecutionFee.mockResolvedValue(regularFeeResponse);
-            client.createContractExecutionTransaction.mockResolvedValue({ id: 'tx-id', state: 'PENDING' });
-            client.waitForTransactionHash.mockResolvedValue({ id: 'tx-id', state: 'COMPLETE', txHash: 'tx-hash' });
+            client.createContractExecutionTransaction.mockResolvedValue({ id: 'tx-id', state: 'PENDING', txHash: 'tx-hash' });
             const params = {
                 abi: USDC.abi,
                 address: USDC.address,
@@ -204,8 +197,7 @@ const writeContract_js_1 = require("./writeContract.js");
             });
         });
         (0, vitest_1.it)('should not call estimateContractExecutionFee when all fees are provided', async () => {
-            client.createContractExecutionTransaction.mockResolvedValue({ id: 'tx-id', state: 'PENDING' });
-            client.waitForTransactionHash.mockResolvedValue({ id: 'tx-id', state: 'COMPLETE', txHash: 'tx-hash' });
+            client.createContractExecutionTransaction.mockResolvedValue({ id: 'tx-id', state: 'PENDING', txHash: 'tx-hash' });
             const params = {
                 abi: USDC.abi,
                 address: USDC.address,
@@ -243,8 +235,7 @@ const writeContract_js_1 = require("./writeContract.js");
                 preVerificationGas: '33333',
             };
             client.estimateContractExecutionFee.mockResolvedValue(scaFeeResponse);
-            client.createContractExecutionTransaction.mockResolvedValue({ id: 'tx-id', state: 'PENDING' });
-            client.waitForTransactionHash.mockResolvedValue({ id: 'tx-id', state: 'COMPLETE', txHash: 'tx-hash' });
+            client.createContractExecutionTransaction.mockResolvedValue({ id: 'tx-id', state: 'PENDING', txHash: 'tx-hash' });
             const params = {
                 abi: USDC.abi,
                 address: USDC.address,