@circle-fin/usdckit 0.21.1 → 0.23.0

package/dist/esm/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/esm/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/esm/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/esm/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/esm/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/esm/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/esm/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/esm/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/esm/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/esm/providers/circle-wallets/actions/index.js

@@ -29,9 +29,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';
 export * from './createAccount.js';
 export * from './createContractExecutionTransaction.js';
@@ -53,10 +51,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 function actions(client) {
     const _client = client;
@@ -87,8 +83,6 @@ export function actions(client) {
         deriveWallet: (params) => deriveWallet(_client, params),
         /** See {@link signTransaction} action */
         signTransaction: (params) => signTransaction(_client, params),
-        /** See {@link signTypedData} action */
-        signTypedData: (params) => signTypedData(_client, params),
         /** See {@link requestTestnetTokens} action */
         requestTestnetTokens: (params) => requestTestnetTokens(_client, params),
         /** See {@link importContract} action */
@@ -107,8 +101,6 @@ export function actions(client) {
         getTokenBalances: (params) => getTokenBalances(_client, params),
         /** See {@link verifyNotification} action */
         verifyNotification: (params) => verifyNotification(_client, params),
-        /** See {@link waitForTransactionHash} action */
-        waitForTransactionHash: (params) => waitForTransactionHash(_client, params),
         /** See {@link writeContract} action */
         writeContract: (params) => writeContract(_client, params),
     };

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

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

package/dist/esm/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/esm/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/esm/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/esm/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/esm/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/esm/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/esm/providers/circle-wallets/actions/writeContract.js

@@ -18,11 +18,9 @@ import { extractChain } from '../index.js';
 import { SENTINEL_FEES } from '../transports/index.js';
 import { createContractExecutionTransaction as _createContractExecutionTransaction } from './createContractExecutionTransaction.js';
 import { estimateContractExecutionFee as _estimateContractExecutionFee } from './estimateContractExecutionFee.js';
-import { waitForTransactionHash as _waitForTransactionHash } from './waitForTransactionHash.js';
 export async function writeContract(client, params) {
     const createContractExecutionTransaction = getAction(client, _createContractExecutionTransaction, 'createContractExecutionTransaction');
     const estimateContractExecutionFee = getAction(client, _estimateContractExecutionFee, 'estimateContractExecutionFee');
-    const waitForTransactionHash = getAction(client, _waitForTransactionHash, 'waitForTransactionHash');
     const { abi, account: _account, address, args, functionName, value, chain: _chain = client.chain } = params;
     let { gas, maxFeePerGas, maxPriorityFeePerGas } = params;
     const account = parseAccount(_account, { chain: _chain });
@@ -63,8 +61,7 @@ export async function writeContract(client, params) {
                 priorityFee: 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/esm/providers/circle-wallets/actions/writeContract.test.js

@@ -19,7 +19,6 @@ describe(`${action.name}`, () => {
         request: vi.fn(),
         createContractExecutionTransaction: vi.fn(),
         estimateContractExecutionFee: vi.fn(),
-        waitForTransactionHash: vi.fn(),
     };
     const USDC = {
         address: '0xa0b86991c6218b36c1d19d4a2e9eb0ce3606eb48',
@@ -62,9 +61,9 @@ describe(`${action.name}`, () => {
                             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',
         ],
@@ -94,27 +93,23 @@ describe(`${action.name}`, () => {
                             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 action(client, params);
         expect(result).toEqual(expectedResult);
         if (estimateContractExecutionFee !== undefined)
             expect(client.estimateContractExecutionFee).toHaveBeenCalledWith(expect.objectContaining(estimateContractExecutionFee[0]));
         if (createContractExecutionTransaction !== undefined)
             expect(client.createContractExecutionTransaction).toHaveBeenCalledWith(expect.objectContaining(createContractExecutionTransaction[0]));
-        if (waitForTransactionHash !== undefined)
-            expect(client.waitForTransactionHash).toHaveBeenCalledWith(expect.objectContaining(waitForTransactionHash[0]));
     });
     it('should throw UnsupportedChainError for unsupported chain', async () => {
         await expect(action(client, {
@@ -141,8 +136,7 @@ describe(`${action.name}`, () => {
                 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,
@@ -175,8 +169,7 @@ describe(`${action.name}`, () => {
                 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,
@@ -202,8 +195,7 @@ describe(`${action.name}`, () => {
             });
         });
         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,
@@ -241,8 +233,7 @@ describe(`${action.name}`, () => {
                 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,