@circle-fin/usdckit 0.21.1 → 0.23.0

package/dist/esm/extractChain.test.js

@@ -10,7 +10,7 @@
 // prohibited without the express written permission of Circle Internet Group, Inc.
 import { arbitrumSepolia, avalancheFuji, sepolia, polygonAmoy, unichainSepolia, mainnet, arbitrum, avalanche, polygon, unichain, base, baseSepolia, nearTestnet, near, optimismSepolia, optimism, } from 'viem/chains';
 import { describe, test, expect } from 'vitest';
-import { ARB, ARB_SEPOLIA, AVAX, AVAX_FUJI, BASE_SEPOLIA, BASE, ETH, ETH_SEPOLIA, MATIC, MATIC_AMOY, NEAR_TESTNET, NEAR, OP_SEPOLIA, OP, UNI, UNI_SEPOLIA, } from './chains/index.js';
+import { ARB, ARB_SEPOLIA, ARC_TESTNET, AVAX, AVAX_FUJI, BASE_SEPOLIA, BASE, ETH, ETH_SEPOLIA, MATIC, MATIC_AMOY, NEAR_TESTNET, NEAR, OP_SEPOLIA, OP, UNI, UNI_SEPOLIA, } from './chains/index.js';
 import { extractChain } from './extractChain.js';
 describe.concurrent('extractChain', () => {
     test.each([
@@ -18,6 +18,7 @@ describe.concurrent('extractChain', () => {
         [arbitrumSepolia, ARB_SEPOLIA],
         [ARB, ARB],
         [arbitrum, ARB],
+        [ARC_TESTNET, ARC_TESTNET],
         [AVAX_FUJI, AVAX_FUJI],
         [avalancheFuji, AVAX_FUJI],
         [AVAX, AVAX],

package/dist/esm/index.d.ts

@@ -1,5 +1,8 @@
-import type { Chain, CircleClient } from './types.js';
+import type { Chain } from './chains.js';
+import type { CircleClient } from './client.js';
 export * from './types.js';
+export * from './chains.js';
+export * from './client.js';
 export { VERSION } from './metadata.js';
 export * from './errors/index.js';
 export * from './extractChain.js';

package/dist/esm/index.js

@@ -9,14 +9,18 @@
 // of this source code or any related proprietary information is strictly
 // prohibited without the express written permission of Circle Internet Group, Inc.
 import { pino, destination } from 'pino';
-import { createClient as createViemClient, fallback, http, publicActions, walletActions } from 'viem';
+import { createClient as createViemClient, fallback, publicActions, walletActions } from 'viem';
 import { actions as coreActions } from './actions/index.js';
-import { ETH_SEPOLIA } from './chains/index.js';
+import * as chains from './chains/index.js';
 import { createTransportOnResponse } from './onResponse.js';
 import { actions as circleWalletsActions, http as circleWalletsTransport } from './providers/circle-wallets/index.js';
 import { actions as crossChainTransferProtocolActions, http as crossChainTransferProtocolTransport, } from './providers/cross-chain-transfer-protocol/index.js';
+import { actions as solanaActions, http as solanaTransport } from './providers/solana/index.js';
 import { actions as uniswapActions } from './providers/uniswap/index.js';
+import { createConfig } from './utils/createConfig.js';
 export * from './types.js';
+export * from './chains.js';
+export * from './client.js';
 export { VERSION } from './metadata.js';
 export * from './errors/index.js';
 export * from './extractChain.js';
@@ -61,20 +65,40 @@ export * from './extractChain.js';
  * ```
  */
 export function createCircleClient(params) {
-    const { apiKey, entitySecret, chain = ETH_SEPOLIA, baseUrl, logLevel, logFile } = params;
+    const { apiKey, entitySecret, chain = chains.ETH_SEPOLIA, baseUrl, logLevel, logFile } = params;
     const transport = fallback([
-        ...[circleWalletsTransport, crossChainTransferProtocolTransport].map((transport) => transport({ apiKey, entitySecret, baseUrl })),
-        http(),
+        ...[crossChainTransferProtocolTransport, solanaTransport, circleWalletsTransport].map((transport) => transport({ apiKey, entitySecret, baseUrl, chainId: chain.id })),
     ]);
-    const client = createViemClient({ chain, transport })
+    const _client = createViemClient({ chain, transport });
+    // Create a config and bind it onto the client.
+    // Note: By default, we build config with all supported chains.
+    // Note: this step must occur before extending actions, otherwise the config won't be closured into each action calls.
+    _client.config = createConfig({
+        chains: Object.values(chains),
+        transportFactory: ({ chainId }) => circleWalletsTransport({ apiKey, entitySecret, baseUrl, chainId }),
+    });
+    const client = _client
         .extend(publicActions)
         .extend(walletActions)
+        .extend(solanaActions)
         .extend(circleWalletsActions)
         .extend(circleWalletsActions) // HACK: Re-extend to ensure method override
         .extend(crossChainTransferProtocolActions)
         .extend(uniswapActions)
         .extend(coreActions);
-    client.logger = pino({ level: logLevel ?? 'silent' }, destination(logFile));
+    client.logger = pino({
+        level: logLevel ?? 'silent',
+        redact: {
+            paths: [
+                'Authorization',
+                '*.Authorization',
+                'entitySecret',
+                '*.entitySecret',
+                'entitySecretCiphertext',
+                '*.entitySecretCiphertext',
+            ],
+        },
+    }, destination(logFile));
     // eslint-disable-next-line @typescript-eslint/no-unsafe-call
     client.transport.onResponse(createTransportOnResponse(client));
     return client;

package/dist/esm/index.test.js

@@ -17,5 +17,6 @@ describe('createClient', () => {
             entitySecret: 'secret',
         });
         expect(client).toBeDefined();
+        expect(client.config).toBeDefined();
     });
 });

package/dist/esm/metadata.js

@@ -11,4 +11,4 @@
 /**
  * The current semantic version of the SDK
  */
-export const VERSION = `${'0.21.1' || '0.0.0'}`;
+export const VERSION = `${'0.23.0' || '0.0.0'}`;

package/dist/esm/onResponse.d.ts

@@ -1,4 +1,4 @@
-import type { CircleClient } from './types.js';
+import type { CircleClient } from './client.js';
 import type { Transport } from 'viem';
 export declare function createTransportOnResponse(client: CircleClient): ({ method, params, response, error, transport, }: {
     method: string;

package/dist/esm/onResponse.js

@@ -21,6 +21,9 @@ export function createTransportOnResponse(client) {
             // Re-throw on `circle_` methods
             if (method.startsWith('circle_') && code !== undefined)
                 throw error;
+            // Re-throw on `sol_` methods
+            if (method.startsWith('sol_') && code !== undefined)
+                throw error;
         }
         client.logger.debug({ transport: transport.config.key, method, params, response });
     };

package/dist/esm/providers/circle-wallets/actions/createAccount.d.ts

@@ -1,5 +1,6 @@
 import { createWallets as _createWallets } from './createWallets.js';
-import type { Account, Address, Merge, ExtendedViemClient } from '../../../types.js';
+import type { ExtendedViemClient } from '../../../client.js';
+import type { Account, Address, Merge } from '../../../types.js';
 import type { Chain } from '../index.js';
 /**
  * The input for the {@link createAccount} action.
@@ -426,6 +427,185 @@ export declare function createAccount(client: ExtendedViemClient, params?: Creat
         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/createAccount.js

@@ -60,6 +60,9 @@ export async function createAccount(client, params = {}) {
     let wallet;
     if (account !== undefined) {
         const accountChain = extractChain(account.chain) ?? raise(new UnsupportedChainError());
+        if (chain.blockchainId === 'ARC-TESTNET') {
+            raise(new UnsupportedChainError());
+        }
         const [sourceWallet] = await listWallets({
             address: account.address,
             blockchain: accountChain.blockchainId,

package/dist/esm/providers/circle-wallets/actions/createContractExecutionTransaction.d.ts

@@ -1,3 +1,11 @@
-import type { ExtendedViemClient } from '../../../types.js';
+import type { ExtendedViemClient } from '../../../client.js';
 import type { CreateContractExecutionTransactionInput } from '../transports/index.js';
+/**
+ * Initiates a contract execution transaction from a specified developer-controlled wallet.
+ *
+ * By default, creation waits for the transaction to be processed and returns the transaction along with its txHash.
+ * To disable this behavior, set `waitForTransactionHash` to `false`.
+ *
+ * @returns The created Transaction
+ */
 export declare function createContractExecutionTransaction(client: ExtendedViemClient, params: CreateContractExecutionTransactionInput): Promise<import("@circle-fin/developer-controlled-wallets/dist/types/clients/developer-controlled-wallets.js").Transaction>;

package/dist/esm/providers/circle-wallets/actions/createContractExecutionTransaction.js

@@ -8,6 +8,14 @@
 // evidence any actual or intended publication of such source code. Disclosure
 // of this source code or any related proprietary information is strictly
 // prohibited without the express written permission of Circle Internet Group, Inc.
+/**
+ * Initiates a contract execution transaction from a specified developer-controlled wallet.
+ *
+ * By default, creation waits for the transaction to be processed and returns the transaction along with its txHash.
+ * To disable this behavior, set `waitForTransactionHash` to `false`.
+ *
+ * @returns The created Transaction
+ */
 export async function createContractExecutionTransaction(client, params) {
     return await client.request({ method: 'circle_createContractExecutionTransaction', params: [params] });
 }

package/dist/esm/providers/circle-wallets/actions/createTransaction.d.ts

@@ -1,8 +1,11 @@
-import type { ExtendedViemClient } from '../../../types.js';
+import type { ExtendedViemClient } from '../../../client.js';
 import type { CreateTransactionInput } from '../transports/index.js';
 /**
  * Initiates an on-chain digital asset transfer from a specified developer-controlled wallet.
  *
+ * By default, creation waits for the transaction to be processed and returns the transaction along with its txHash.
+ * To disable this behavior, set `waitForTransactionHash` to `false`.
+ *
  * @returns The created Transaction
  *
  * @example

package/dist/esm/providers/circle-wallets/actions/createTransaction.js

@@ -11,6 +11,9 @@
 /**
  * Initiates an on-chain digital asset transfer from a specified developer-controlled wallet.
  *
+ * By default, creation waits for the transaction to be processed and returns the transaction along with its txHash.
+ * To disable this behavior, set `waitForTransactionHash` to `false`.
+ *
  * @returns The created Transaction
  *
  * @example

package/dist/esm/providers/circle-wallets/actions/createWalletSet.d.ts

@@ -1,4 +1,4 @@
-import type { ExtendedViemClient } from '../../../types.js';
+import type { ExtendedViemClient } from '../../../client.js';
 import type { CreateWalletSetInput } from '../transports/index.js';
 /**
  * Create a wallet set

package/dist/esm/providers/circle-wallets/actions/createWallets.d.ts

@@ -1,4 +1,4 @@
-import type { ExtendedViemClient } from '../../../types.js';
+import type { ExtendedViemClient } from '../../../client.js';
 import type { CreateWalletsInput } from '../transports/index.js';
 /**
  * Generates a new developer-controlled wallet or batch of wallets within a wallet set, specifying blockchain and wallet name.

package/dist/esm/providers/circle-wallets/actions/deriveWallet.d.ts

@@ -1,4 +1,4 @@
-import type { ExtendedViemClient } from '../../../types.js';
+import type { ExtendedViemClient } from '../../../client.js';
 import type { DeriveWalletInput } from '../transports/index.js';
 /**
  * Derives an EOA (Externally Owned Account) or SCA (Smart Contract Account) wallet using the address of the specified wallet and blockchain

package/dist/esm/providers/circle-wallets/actions/drip.d.ts

@@ -1,4 +1,5 @@
-import type { Account, Address, ExtendedViemClient } from '../../../types.js';
+import type { ExtendedViemClient } from '../../../client.js';
+import type { Account, Address } from '../../../types.js';
 import type { ChainFaucet as Chain } from '../index.js';
 export type DripParams = {
     account: Address | Account;

package/dist/esm/providers/circle-wallets/actions/estimateContractExecutionFee.d.ts

@@ -1,4 +1,4 @@
-import type { ExtendedViemClient } from '../../../types.js';
+import type { ExtendedViemClient } from '../../../client.js';
 import type { EstimateContractExecutionFeeInput } from '../transports/index.js';
 export declare function estimateContractExecutionFee(client: ExtendedViemClient, params: EstimateContractExecutionFeeInput): Promise<{
     high: {
@@ -8,6 +8,8 @@ export declare function estimateContractExecutionFee(client: ExtendedViemClient,
         gasPrice?: string;
         baseFee?: string;
         networkFee?: string;
+        networkFeeRaw?: string;
+        l1Fee?: string;
     } | undefined;
     medium: {
         gasLimit: `${number}` | "" | undefined;
@@ -16,6 +18,8 @@ export declare function estimateContractExecutionFee(client: ExtendedViemClient,
         gasPrice?: string;
         baseFee?: string;
         networkFee?: string;
+        networkFeeRaw?: string;
+        l1Fee?: string;
     } | undefined;
     low: {
         gasLimit: `${number}` | "" | undefined;
@@ -24,6 +28,8 @@ export declare function estimateContractExecutionFee(client: ExtendedViemClient,
         gasPrice?: string;
         baseFee?: string;
         networkFee?: string;
+        networkFeeRaw?: string;
+        l1Fee?: string;
     } | undefined;
     callGasLimit?: string;
     verificationGasLimit?: string;

package/dist/esm/providers/circle-wallets/actions/estimateTransferFee.d.ts

@@ -1,5 +1,6 @@
 import type { EstimateFeesPerGasParams } from '../../../actions/transfer.js';
-import type { Account, BaseUnits, ControlFlowOptions, ExtendedViemClient, FeeValuesEIP1559, Merge } from '../../../types.js';
+import type { ExtendedViemClient } from '../../../client.js';
+import type { Account, BaseUnits, ControlFlowOptions, FeeValuesEIP1559, Merge } from '../../../types.js';
 import type { EstimateTransferFeeInput } from '../transports/index.js';
 /**
  * Estimates the transfer fee for a given transaction.
@@ -31,6 +32,8 @@ export declare function estimateTransferFee(client: ExtendedViemClient, params:
         gasPrice?: string;
         baseFee?: string;
         networkFee?: string;
+        networkFeeRaw?: string;
+        l1Fee?: string;
     } | undefined;
     medium: {
         gasLimit: `${number}` | "" | undefined;
@@ -39,6 +42,8 @@ export declare function estimateTransferFee(client: ExtendedViemClient, params:
         gasPrice?: string;
         baseFee?: string;
         networkFee?: string;
+        networkFeeRaw?: string;
+        l1Fee?: string;
     } | undefined;
     low: {
         gasLimit: `${number}` | "" | undefined;
@@ -47,6 +52,8 @@ export declare function estimateTransferFee(client: ExtendedViemClient, params:
         gasPrice?: string;
         baseFee?: string;
         networkFee?: string;
+        networkFeeRaw?: string;
+        l1Fee?: string;
     } | undefined;
     callGasLimit?: string;
     verificationGasLimit?: string;

package/dist/esm/providers/circle-wallets/actions/estimateTransferFee.js

@@ -19,7 +19,6 @@ import { extractChain } from '../index.js';
 import { SENTINEL_FEES } from '../transports/index.js';
 import { createTransaction } from './createTransaction.js';
 import { getTokenBalances } from './getTokenBalances.js';
-import { waitForTransactionHash } from './waitForTransactionHash.js';
 /**
  * Estimates the transfer fee for a given transaction.
  *
@@ -116,7 +115,7 @@ export function FEE_LEVEL_WITH_PREPARE({ account, level, confirmations = 3, sign
         ]);
         const amountToTransfer = fees.gas * fees.maxFeePerGas - (nativeBalance?.value ?? 0n);
         if (amountToTransfer > 0) {
-            const { id } = await createTransaction(client, {
+            const { txHash } = await createTransaction(client, {
                 sourceAddress: account.address,
                 destinationAddress: from.address,
                 blockchain: chain.blockchainId,
@@ -128,8 +127,8 @@ export function FEE_LEVEL_WITH_PREPARE({ account, level, confirmations = 3, sign
                         feeLevel: 'HIGH',
                     },
                 },
+                signal,
             });
-            const { txHash } = await waitForTransactionHash(client, { id, signal });
             await waitForTransactionReceipt({ hash: txHash, confirmations });
         }
         return fees;

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

@@ -14,7 +14,6 @@ import { formatUnits } from '../../../utils/formatUnits.js';
 import { createTransaction } from './createTransaction.js';
 import { estimateTransferFee as action, estimateTransferFeeForFeeLevel, FEE_LEVEL_WITH_PREPARE, } from './estimateTransferFee.js';
 import { getTokenBalances } from './getTokenBalances.js';
-import { waitForTransactionHash } from './waitForTransactionHash.js';
 describe.concurrent(`${action.name}`, () => {
     const client = {
         request: vi.fn(),
@@ -60,9 +59,6 @@ vi.mock('./getTokenBalances.js', () => ({
 vi.mock('./createTransaction.js', () => ({
     createTransaction: vi.fn(),
 }));
-vi.mock('./waitForTransactionHash.js', () => ({
-    waitForTransactionHash: vi.fn(),
-}));
 vi.mock('viem/actions', async (importOriginal) => ({
     ...(await importOriginal()),
     waitForTransactionReceipt: vi.fn(),
@@ -169,14 +165,6 @@ describe('FEE_LEVEL_WITH_PREPARE', () => {
         };
         vi.mocked(getTokenBalances).mockResolvedValue([]);
         vi.mocked(createTransaction).mockResolvedValue({
-            id: 'transaction-id',
-            state: 'QUEUED',
-            blockchain: ETH_SEPOLIA.blockchainId,
-            createDate: '2025-01-01T00:00:00.000Z',
-            transactionType: 'OUTBOUND',
-            updateDate: '2025-01-01T00:00:00.000Z',
-        });
-        vi.mocked(waitForTransactionHash).mockResolvedValue({
             id: 'transaction-id',
             state: 'COMPLETE',
             txHash: '0x123',
@@ -201,6 +189,7 @@ describe('FEE_LEVEL_WITH_PREPARE', () => {
                     feeLevel: 'HIGH',
                 },
             },
+            signal: undefined,
         });
     });
     it('should return gas fee estimations for FEE_LEVEL_WITH_PREPARATION without preparation transfer', async () => {
@@ -388,14 +377,6 @@ describe('SCA Gas Fee Workarounds', () => {
             };
             vi.mocked(getTokenBalances).mockResolvedValue([]);
             vi.mocked(createTransaction).mockResolvedValue({
-                id: 'transaction-id',
-                state: 'QUEUED',
-                blockchain: ETH_SEPOLIA.blockchainId,
-                createDate: '2025-01-01T00:00:00.000Z',
-                transactionType: 'OUTBOUND',
-                updateDate: '2025-01-01T00:00:00.000Z',
-            });
-            vi.mocked(waitForTransactionHash).mockResolvedValue({
                 id: 'transaction-id',
                 state: 'COMPLETE',
                 txHash: '0x123',