@coinbase/agentkit 0.5.0 → 0.6.0

package/dist/action-providers/onramp/onrampActionProvider.js

@@ -0,0 +1,109 @@
+"use strict";
+/**
+ * Onramp Action Provider
+ *
+ * This file contains the implementation of the OnrampActionProvider,
+ * which provides actions for onramp operations.
+ *
+ * @module onramp
+ */
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.onrampActionProvider = exports.OnrampActionProvider = void 0;
+const zod_1 = require("zod");
+const actionProvider_1 = require("../actionProvider");
+const actionDecorator_1 = require("../actionDecorator");
+const wallet_providers_1 = require("../../wallet-providers");
+const schemas_1 = require("./schemas");
+const utils_1 = require("./utils");
+/**
+ * OnrampActionProvider provides actions for onramp operations.
+ *
+ * @description
+ * This provider is designed to work with EvmWalletProvider for blockchain interactions.
+ * It supports all evm networks.
+ */
+class OnrampActionProvider extends actionProvider_1.ActionProvider {
+    /**
+     * Constructor for the OnrampActionProvider.
+     *
+     * @param props - The props for the OnrampActionProvider
+     * @param props.projectId - The project ID for the OnrampActionProvider
+     */
+    constructor(props) {
+        super("onramp", []);
+        this.projectId = props.projectId;
+    }
+    /**
+     * This action provides a link to buy more cryptocurrency (ETH, USDC, or BTC) using fiat currency (regular money like USD).
+     *
+     * @param walletProvider - The wallet provider instance for blockchain interactions
+     * @param _ - The arguments for the action (not used)
+     * @returns A promise that resolves to a string describing the action result
+     */
+    async getOnrampBuyUrl(walletProvider, _ = {}) {
+        const networkId = walletProvider.getNetwork().networkId;
+        if (!networkId) {
+            throw new Error("Network ID is not set");
+        }
+        const network = (0, utils_1.convertNetworkIdToOnrampNetworkId)(networkId);
+        if (!network) {
+            throw new Error("Network ID is not supported. Make sure you are using a supported mainnet network.");
+        }
+        return (0, utils_1.getOnrampBuyUrl)({
+            projectId: this.projectId,
+            addresses: {
+                [walletProvider.getAddress()]: [network],
+            },
+            defaultNetwork: network,
+        });
+    }
+    /**
+     * Checks if this provider supports the given network.
+     *
+     * @param network - The network to check support for
+     * @returns True if the network is supported
+     */
+    supportsNetwork(network) {
+        return Boolean(network.networkId &&
+            (0, utils_1.convertNetworkIdToOnrampNetworkId)(network.networkId) !== null &&
+            network.protocolFamily === "evm");
+    }
+}
+exports.OnrampActionProvider = OnrampActionProvider;
+__decorate([
+    (0, actionDecorator_1.CreateAction)({
+        name: "get_onramp_buy_url",
+        description: `
+      Get a URL to purchase more cryptocurrency when funds are low. This action provides a link to buy more 
+      cryptocurrency, defaulting to ETH, using fiat currency (regular money like USD). 
+      
+      Use this when:
+      - You detect that the wallet has insufficient funds for a transaction
+      - You need to guide the user to purchase more cryptocurrency
+      - The user asks how to buy more crypto
+      
+      The URL will direct to a secure Coinbase-powered purchase interface.
+    `,
+        schema: schemas_1.GetOnrampBuyUrlActionSchema,
+    }),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [wallet_providers_1.EvmWalletProvider, void 0]),
+    __metadata("design:returntype", Promise)
+], OnrampActionProvider.prototype, "getOnrampBuyUrl", null);
+/**
+ * Factory function to create a new OnrampActionProvider instance.
+ *
+ * @param props - The props for the OnrampActionProvider
+ * @returns A new OnrampActionProvider instance
+ */
+const onrampActionProvider = (props) => new OnrampActionProvider(props);
+exports.onrampActionProvider = onrampActionProvider;

package/dist/action-providers/onramp/onrampActionProvider.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/action-providers/onramp/onrampActionProvider.test.js

@@ -0,0 +1,97 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const onrampActionProvider_1 = require("./onrampActionProvider");
+const schemas_1 = require("./schemas");
+describe("OnrampActionProvider", () => {
+    const provider = new onrampActionProvider_1.OnrampActionProvider({
+        projectId: "test-project-id",
+    });
+    let mockWalletProvider;
+    beforeEach(() => {
+        mockWalletProvider = {
+            getAddress: jest.fn().mockReturnValue("0x123"),
+            getBalance: jest.fn(),
+            getName: jest.fn(),
+            getNetwork: jest.fn().mockReturnValue({
+                protocolFamily: "evm",
+                networkId: "base-mainnet",
+            }),
+            nativeTransfer: jest.fn(),
+        };
+    });
+    describe("network support", () => {
+        it("should support valid EVM networks", () => {
+            expect(provider.supportsNetwork({
+                networkId: "base-mainnet",
+                protocolFamily: "evm",
+            })).toBe(true);
+        });
+        it("should not support invalid EVM networks, such as testnets", () => {
+            expect(provider.supportsNetwork({
+                networkId: "base-sepolia",
+                protocolFamily: "evm",
+            })).toBe(false);
+        });
+        it("should not support other protocol families", () => {
+            expect(provider.supportsNetwork({
+                protocolFamily: "other-protocol-family",
+            })).toBe(false);
+        });
+        it("should handle invalid network objects", () => {
+            expect(provider.supportsNetwork({})).toBe(false);
+        });
+    });
+    describe("action validation", () => {
+        it("should validate getOnrampBuyUrl schema", () => {
+            const validInput = {};
+            const parseResult = schemas_1.GetOnrampBuyUrlActionSchema.safeParse(validInput);
+            expect(parseResult.success).toBe(true);
+        });
+    });
+    describe("getOnrampBuyUrl", () => {
+        beforeEach(() => {
+            mockWalletProvider.getAddress.mockReturnValue("0x123");
+        });
+        /**
+         * Parses URL search parameters from a URL string.
+         *
+         * @param url - The URL string to parse parameters from
+         * @returns The parsed URL search parameters
+         */
+        function parseUrlParams(url) {
+            const urlObj = new URL(url);
+            return urlObj.searchParams;
+        }
+        it("should execute getOnrampBuyUrl with wallet provider", async () => {
+            const result = await provider.getOnrampBuyUrl(mockWalletProvider, {});
+            const url = new URL(result);
+            const params = parseUrlParams(result);
+            // Verify base URL
+            expect(url.origin + url.pathname).toBe("https://pay.coinbase.com/buy");
+            // Verify all expected parameters are present with correct values
+            expect(params.get("appId")).toBe("test-project-id");
+            expect(params.get("defaultNetwork")).toBe("base");
+            // Verify address configuration
+            const addressConfig = JSON.parse(params.get("addresses") || "{}");
+            expect(addressConfig).toEqual({
+                "0x123": ["base"],
+            });
+            expect(mockWalletProvider.getNetwork).toHaveBeenCalled();
+            expect(mockWalletProvider.getAddress).toHaveBeenCalled();
+        });
+        it("should throw error for unsupported network", async () => {
+            mockWalletProvider.getNetwork.mockReturnValue({
+                protocolFamily: "evm",
+                networkId: "unsupported-network",
+            });
+            await expect(provider.getOnrampBuyUrl(mockWalletProvider, {})).rejects.toThrow("Network ID is not supported. Make sure you are using a supported mainnet network.");
+        });
+        it("should throw error when network ID is not set", async () => {
+            mockWalletProvider.getNetwork.mockReturnValue({
+                protocolFamily: "evm",
+                networkId: undefined,
+            });
+            await expect(provider.getOnrampBuyUrl(mockWalletProvider, {})).rejects.toThrow("Network ID is not set");
+        });
+    });
+});

package/dist/action-providers/onramp/schemas.d.ts

@@ -0,0 +1,12 @@
+import { z } from "zod";
+/**
+ * Action schemas for the onramp action provider.
+ *
+ * This file contains the Zod schemas that define the shape and validation
+ * rules for action parameters in the onramp action provider.
+ */
+/**
+ * Example action schema demonstrating various field types and validations.
+ * Replace or modify this with your actual action schemas.
+ */
+export declare const GetOnrampBuyUrlActionSchema: z.ZodObject<{}, "strip", z.ZodTypeAny, {}, {}>;

package/dist/action-providers/onramp/schemas.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GetOnrampBuyUrlActionSchema = void 0;
+const zod_1 = require("zod");
+/**
+ * Action schemas for the onramp action provider.
+ *
+ * This file contains the Zod schemas that define the shape and validation
+ * rules for action parameters in the onramp action provider.
+ */
+/**
+ * Example action schema demonstrating various field types and validations.
+ * Replace or modify this with your actual action schemas.
+ */
+exports.GetOnrampBuyUrlActionSchema = zod_1.z.object({});

package/dist/action-providers/onramp/types.d.ts

@@ -0,0 +1,107 @@
+/**
+ * Props used to get an Onramp buy URL by directly providing a CDP project ID.
+ * See https://docs.cdp.coinbase.com/onramp/docs/api-initializing#generating-the-coinbase-onramp-buysell-url
+ *
+ * Note: exported as public Type
+ */
+export type GetOnrampUrlWithProjectIdParams = {
+    /**
+     * The Project ID of your CDP project created at https://portal.cdp.coinbase.com/
+     * This must be provided if you don't provide a sessionToken.
+     */
+    projectId: string;
+    sessionToken?: never;
+    /**
+     * The addresses that the customer's funds should be delivered to.
+     *
+     * Each entry in the record represents a wallet address and the networks it is valid for. There should only be a
+     * single address for each network your app supports. Users will be able to buy/send any asset supported by any of
+     * the networks you specify. See the assets param if you want to restrict the available assets.
+     *
+     * Some common examples:
+     *
+     * Support all assets that are available for sending on the base network, only on the base network:
+     *
+     * `{ "0x1": ["base"] }`
+     */
+    addresses: Record<string, string[]>;
+    /**
+     * This optional parameter will restrict the assets available for the user to buy/send. It acts as a filter on the
+     * networks specified in the {addresses} param.
+     *
+     * Some common examples:
+     *
+     * Support only USDC on either the base network or the ethereum network:
+     *
+     * `addresses: { "0x1": ["base", "ethereum"] }, assets: ["USDC"]`
+     *
+     * The values in this list can either be asset symbols like BTC, ETH, or asset UUIDs that you can get from the Buy
+     * Options API {@link https://docs.cdp.coinbase.com/onramp/docs/api-configurations/#buy-options}.
+     */
+    assets?: string[];
+} & GetOnrampBuyUrlOptionalProps;
+/**
+ * Props used to get an Onramp buy URL using a session token created using the Onramp session token API.
+ * See https://docs.cdp.coinbase.com/onramp/docs/api-initializing#getting-an-coinbase-onramp-buysell-session-token
+ *
+ * Note: exported as public Type
+ */
+export type GetOnrampUrlWithSessionTokenParams = {
+    /**
+     * A session token create using the Onramp session token API. The token will be linked to the project ID, addresses,
+     * and assets params provided in the create session token API request.
+     */
+    sessionToken: string;
+    projectId?: never;
+    addresses?: never;
+    assets?: never;
+} & GetOnrampBuyUrlOptionalProps;
+/**
+ * The optional properties that can be used to create an Onramp buy URL.
+ */
+type GetOnrampBuyUrlOptionalProps = {
+    /**
+     * If specified, this asset will be automatically selected for the user in the Onramp UI. Should be a valid asset
+     * symbol e.g. BTC, ETH, USDC.
+     */
+    defaultAsset?: string;
+    /**
+     * If specified, this network will be automatically selected for the user in the Onramp UI. Should be a valid network
+     * name in lower case e.g. ethereum, base.
+     */
+    defaultNetwork?: string;
+    /**
+     * A unique identifier that will be associated with any transactions created by the user during their Onramp session.
+     * You can use this with the Transaction Status API to check the status of the user's transaction.
+     * See https://docs.cdp.coinbase.com/onramp/docs/api-reporting#buy-transaction-status
+     */
+    partnerUserId?: string;
+    /**
+     * This amount will be used to pre-fill the amount of crypto the user is buying or sending. The user can choose to
+     * change this amount in the UI. Only one of presetCryptoAmount or presetFiatAmount should be provided.
+     */
+    presetCryptoAmount?: number;
+    /**
+     * This amount will be used to pre-fill the fiat value of the crypto the user is buying or sending. The user can
+     * choose to change this amount in the UI. Only one of presetCryptoAmount or presetFiatAmount should be provided.
+     */
+    presetFiatAmount?: number;
+    /**
+     * The default payment method that will be selected for the user in the Onramp UI. Should be one of the payment methods
+     */
+    defaultPaymentMethod?: string;
+    /**
+     * The currency code of the fiat amount provided in the presetFiatAmount param e.g. USD, CAD, EUR.
+     */
+    fiatCurrency?: string;
+    /**
+     * A URL that the user will be automatically redirected to after a successful buy/send. The domain must match a domain
+     * on the domain allowlist in Coinbase Developer Platform (https://portal.cdp.coinbase.com/products/onramp).
+     */
+    redirectUrl?: string;
+    /**
+     * The name of the component that is calling the Onramp buy URL. This will be used for analytics.
+     */
+    originComponentName?: string;
+};
+export {};

package/dist/action-providers/onramp/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/action-providers/onramp/utils.d.ts

@@ -0,0 +1,16 @@
+import type { GetOnrampUrlWithProjectIdParams, GetOnrampUrlWithSessionTokenParams } from "./types";
+/**
+ * Builds a Coinbase Onramp buy URL using the provided parameters.
+ *
+ * @param props - Configuration options for the Onramp buy URL
+ * @param props.projectId - A projectId generated in the Coinbase Developer Portal
+ * @returns The generated Onramp buy URL
+ */
+export declare function getOnrampBuyUrl({ projectId, ...props }: GetOnrampUrlWithProjectIdParams | GetOnrampUrlWithSessionTokenParams): string;
+/**
+ * Converts a network ID to an Onramp network ID.
+ *
+ * @param networkId - The network ID to convert
+ * @returns The Onramp network ID or null if the network ID is not supported
+ */
+export declare const convertNetworkIdToOnrampNetworkId: (networkId: string) => string | null;

package/dist/action-providers/onramp/utils.js

@@ -0,0 +1,56 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.convertNetworkIdToOnrampNetworkId = void 0;
+exports.getOnrampBuyUrl = getOnrampBuyUrl;
+const version_1 = require("./version");
+/**
+ * Builds a Coinbase Onramp buy URL using the provided parameters.
+ *
+ * @param props - Configuration options for the Onramp buy URL
+ * @param props.projectId - A projectId generated in the Coinbase Developer Portal
+ * @returns The generated Onramp buy URL
+ */
+function getOnrampBuyUrl({ projectId, ...props }) {
+    const url = new URL(version_1.ONRAMP_BUY_URL);
+    if (projectId !== undefined) {
+        // Coinbase Onramp requires projectId to be passed as appId
+        url.searchParams.append("appId", projectId);
+    }
+    for (const key of Object.keys(props)) {
+        const value = props[key];
+        if (value !== undefined) {
+            if (["string", "number", "boolean"].includes(typeof value)) {
+                url.searchParams.append(key, value.toString());
+            }
+            else {
+                url.searchParams.append(key, JSON.stringify(value));
+            }
+        }
+    }
+    url.searchParams.append("sdkVersion", `onchainkit@${version_1.VERSION}`);
+    url.searchParams.sort();
+    return url.toString();
+}
+/**
+ * Converts a network ID to an Onramp network ID.
+ *
+ * @param networkId - The network ID to convert
+ * @returns The Onramp network ID or null if the network ID is not supported
+ */
+const convertNetworkIdToOnrampNetworkId = (networkId) => {
+    switch (networkId) {
+        case "base-mainnet":
+            return "base";
+        case "ethereum-mainnet":
+            return "ethereum";
+        case "polygon-mainnet":
+            return "polygon";
+        case "optimism-mainnet":
+            return "optimism";
+        case "arbitrum-mainnet":
+            return "arbitrum";
+        default:
+            return null;
+    }
+};
+exports.convertNetworkIdToOnrampNetworkId = convertNetworkIdToOnrampNetworkId;

package/dist/action-providers/onramp/version.d.ts

@@ -0,0 +1,2 @@
+export declare const VERSION = "0.38.2";
+export declare const ONRAMP_BUY_URL = "https://pay.coinbase.com/buy";

package/dist/action-providers/onramp/version.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ONRAMP_BUY_URL = exports.VERSION = void 0;
+exports.VERSION = "0.38.2";
+exports.ONRAMP_BUY_URL = "https://pay.coinbase.com/buy";

package/dist/wallet-providers/cdpWalletProvider.js

@@ -10,7 +10,7 @@ var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (
     if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
     return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
 };
-var _CdpWalletProvider_cdpWallet, _CdpWalletProvider_address, _CdpWalletProvider_network, _CdpWalletProvider_publicClient, _CdpWalletProvider_gasLimitMultiplier, _CdpWalletProvider_feePerGasMultiplier;
+var _CdpWalletProvider_cdpWallet, _CdpWalletProvider_address, _CdpWalletProvider_network, _CdpWalletProvider_publicClient, _CdpWalletProvider_gasLimitMultiplier, _CdpWalletProvider_feePerGasMultiplier, _CdpWalletProvider_transactionQueue;
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.CdpWalletProvider = void 0;
 const package_json_1 = require("../../package.json");
@@ -37,6 +37,7 @@ class CdpWalletProvider extends evmWalletProvider_1.EvmWalletProvider {
         _CdpWalletProvider_publicClient.set(this, void 0);
         _CdpWalletProvider_gasLimitMultiplier.set(this, void 0);
         _CdpWalletProvider_feePerGasMultiplier.set(this, void 0);
+        _CdpWalletProvider_transactionQueue.set(this, void 0);
         __classPrivateFieldSet(this, _CdpWalletProvider_cdpWallet, config.wallet, "f");
         __classPrivateFieldSet(this, _CdpWalletProvider_address, config.address, "f");
         __classPrivateFieldSet(this, _CdpWalletProvider_network, config.network, "f");
@@ -165,14 +166,22 @@ class CdpWalletProvider extends evmWalletProvider_1.EvmWalletProvider {
         if (!__classPrivateFieldGet(this, _CdpWalletProvider_cdpWallet, "f")) {
             throw new Error("Wallet not initialized");
         }
-        const preparedTransaction = await this.prepareTransaction(transaction.to, transaction.value, transaction.data);
-        const signature = await this.signTransaction({
-            ...preparedTransaction,
-        });
-        const signedPayload = await this.addSignatureAndSerialize(preparedTransaction, signature);
-        const externalAddress = new coinbase_sdk_1.ExternalAddress(__classPrivateFieldGet(this, _CdpWalletProvider_cdpWallet, "f").getNetworkId(), __classPrivateFieldGet(this, _CdpWalletProvider_address, "f"));
-        const tx = await externalAddress.broadcastExternalTransaction(signedPayload.slice(2));
-        return tx.transactionHash;
+        const sendPromise = (async () => {
+            if (__classPrivateFieldGet(this, _CdpWalletProvider_transactionQueue, "f"))
+                await __classPrivateFieldGet(this, _CdpWalletProvider_transactionQueue, "f");
+            const preparedTransaction = await this.prepareTransaction(transaction.to, transaction.value, transaction.data);
+            const signature = await this.signTransaction({
+                ...preparedTransaction,
+            });
+            const signedPayload = await this.addSignatureAndSerialize(preparedTransaction, signature);
+            const externalAddress = new coinbase_sdk_1.ExternalAddress(__classPrivateFieldGet(this, _CdpWalletProvider_cdpWallet, "f").getNetworkId(), __classPrivateFieldGet(this, _CdpWalletProvider_address, "f"));
+            const tx = await externalAddress.broadcastExternalTransaction(signedPayload.slice(2));
+            return tx.transactionHash;
+        })();
+        __classPrivateFieldSet(this, _CdpWalletProvider_transactionQueue, sendPromise
+            .then(txHash => this.waitForTransactionReceipt(txHash))
+            .catch(() => { }), "f");
+        return await sendPromise;
     }
     /**
      * Prepares a transaction.
@@ -188,6 +197,7 @@ class CdpWalletProvider extends evmWalletProvider_1.EvmWalletProvider {
         }
         const nonce = await __classPrivateFieldGet(this, _CdpWalletProvider_publicClient, "f").getTransactionCount({
             address: __classPrivateFieldGet(this, _CdpWalletProvider_address, "f"),
+            blockTag: "pending",
         });
         const feeData = await __classPrivateFieldGet(this, _CdpWalletProvider_publicClient, "f").estimateFeesPerGas();
         const maxFeePerGas = (0, utils_1.applyGasMultiplier)(feeData.maxFeePerGas, __classPrivateFieldGet(this, _CdpWalletProvider_feePerGasMultiplier, "f"));
@@ -418,4 +428,4 @@ class CdpWalletProvider extends evmWalletProvider_1.EvmWalletProvider {
     }
 }
 exports.CdpWalletProvider = CdpWalletProvider;
-_CdpWalletProvider_cdpWallet = new WeakMap(), _CdpWalletProvider_address = new WeakMap(), _CdpWalletProvider_network = new WeakMap(), _CdpWalletProvider_publicClient = new WeakMap(), _CdpWalletProvider_gasLimitMultiplier = new WeakMap(), _CdpWalletProvider_feePerGasMultiplier = new WeakMap();
+_CdpWalletProvider_cdpWallet = new WeakMap(), _CdpWalletProvider_address = new WeakMap(), _CdpWalletProvider_network = new WeakMap(), _CdpWalletProvider_publicClient = new WeakMap(), _CdpWalletProvider_gasLimitMultiplier = new WeakMap(), _CdpWalletProvider_feePerGasMultiplier = new WeakMap(), _CdpWalletProvider_transactionQueue = new WeakMap();

package/dist/wallet-providers/cdpWalletProvider.test.js

@@ -122,6 +122,9 @@ const MOCK_NETWORK = {
     protocolFamily: "evm",
     networkId: MOCK_NETWORK_ID,
 };
+const MOCK_TRANSACTION_RECEIPT = {
+    transactionHash: MOCK_TRANSACTION_HASH,
+};
 describe("CdpWalletProvider", () => {
     let provider;
     beforeEach(async () => {
@@ -154,9 +157,7 @@ describe("CdpWalletProvider", () => {
         });
         jest.spyOn(coinbase_sdk_1.Wallet, "import").mockResolvedValue(mockWalletObj);
         jest.spyOn(coinbase_sdk_1.Wallet, "create").mockResolvedValue(mockWalletObj);
-        mockPublicClient.waitForTransactionReceipt.mockResolvedValue({
-            transactionHash: MOCK_TRANSACTION_HASH,
-        });
+        mockPublicClient.waitForTransactionReceipt.mockResolvedValue(MOCK_TRANSACTION_RECEIPT);
         mockPublicClient.readContract.mockResolvedValue("mock_result");
         mockPublicClient.getTransactionCount.mockResolvedValue(1);
         mockPublicClient.estimateFeesPerGas.mockResolvedValue({
@@ -323,6 +324,39 @@ describe("CdpWalletProvider", () => {
             expect(mockWalletObj.createPayloadSignature).toHaveBeenCalled();
             expect(txHash).toBe(MOCK_TRANSACTION_HASH);
         });
+        it("should wait for the first transfer before sending another one", async () => {
+            const validSignature = "0x" + "1".repeat(64) + "2".repeat(64) + "01"; // r, s, v format (130 chars + 0x prefix)
+            const mockSignature = {
+                model: {},
+                getId: jest.fn().mockReturnValue("signature-id"),
+                getWalletId: jest.fn().mockReturnValue("mock-wallet-id"),
+                getAddressId: jest.fn().mockReturnValue(MOCK_ADDRESS),
+                getNetworkId: jest.fn().mockReturnValue(MOCK_NETWORK_ID),
+                getSignature: jest.fn().mockReturnValue(validSignature),
+                getPayload: jest.fn().mockReturnValue("0xpayload"),
+                getEncodedPayload: jest.fn().mockReturnValue("0xencodedpayload"),
+                getStatus: jest.fn().mockReturnValue("completed"),
+            };
+            mockWalletObj.createPayloadSignature.mockResolvedValue(mockSignature);
+            const transaction = {
+                to: "0x1234567890123456789012345678901234567890",
+                value: BigInt(1000000000000000000),
+            };
+            mockPublicClient.waitForTransactionReceipt.mockImplementationOnce(async () => {
+                await new Promise(resolve => setTimeout(resolve, 20));
+                return MOCK_TRANSACTION_RECEIPT;
+            });
+            const txHash1 = await provider.sendTransaction(transaction);
+            expect(mockWalletObj.createPayloadSignature).toHaveBeenCalledTimes(1);
+            expect(txHash1).toBe(MOCK_TRANSACTION_HASH);
+            expect(mockPublicClient.waitForTransactionReceipt).toHaveBeenCalledTimes(1);
+            const awaitReceiptPromise = mockPublicClient.waitForTransactionReceipt.mock.results[0]
+                .value;
+            const secondTxHashPromise = provider.sendTransaction(transaction);
+            const race = Promise.race([awaitReceiptPromise, secondTxHashPromise]);
+            expect(await race).toStrictEqual(MOCK_TRANSACTION_RECEIPT);
+            expect(await secondTxHashPromise).toBe(MOCK_TRANSACTION_HASH);
+        });
         it("should execute a native transfer", async () => {
             const to = "0x1234567890123456789012345678901234567890";
             const value = "1.0";

package/package.json

@@ -2,7 +2,7 @@
   "name": "@coinbase/agentkit",
   "description": "Coinbase AgentKit core primitives",
   "repository": "https://github.com/coinbase/agentkit",
-  "version": "0.5.0",
+  "version": "0.6.0",
   "author": "Coinbase Inc.",
   "license": "Apache-2.0",
   "main": "dist/index.js",
@@ -57,7 +57,8 @@
     "ts-jest": "^29.2.5",
     "tsd": "^0.31.2",
     "tsx": "^4.7.1",
-    "typescript": "^5.7.2"
+    "typescript": "^5.7.2",
+    "yargs": "^17.7.2"
   },
   "exports": {
     ".": {