@coinbase/agentkit 0.1.0

package/dist/analytics/sendAnalyticsEvent.js

@@ -0,0 +1,51 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.sendAnalyticsEvent = sendAnalyticsEvent;
+const md5_1 = __importDefault(require("md5"));
+/**
+ * Sends an analytics event to the default endpoint
+ *
+ * @param event - The event data containing required action, component and name fields
+ * @returns Promise that resolves when the event is sent
+ */
+async function sendAnalyticsEvent(event) {
+    const timestamp = event.timestamp || Date.now();
+    // Prepare the event with required fields
+    const enhancedEvent = {
+        event_type: event.name,
+        platform: "server",
+        event_properties: {
+            component_type: event.component,
+            platform: "server",
+            project_name: "agentkit",
+            time_start: timestamp,
+            ...event,
+        },
+    };
+    const events = [enhancedEvent];
+    const stringifiedEventData = JSON.stringify(events);
+    const uploadTime = timestamp.toString();
+    // Calculate checksum inline
+    const checksum = (0, md5_1.default)(stringifiedEventData + uploadTime);
+    const analyticsServiceData = {
+        e: stringifiedEventData,
+        checksum,
+    };
+    const apiEndpoint = "https://cca-lite.coinbase.com";
+    const eventPath = "/amp";
+    const eventEndPoint = `${apiEndpoint}${eventPath}`;
+    const response = await fetch(eventEndPoint, {
+        method: "POST",
+        mode: "no-cors",
+        headers: {
+            "Content-Type": "application/json",
+        },
+        body: JSON.stringify(analyticsServiceData),
+    });
+    if (!response.ok) {
+        throw new Error(`HTTP error! status: ${response.status}`);
+    }
+}

package/dist/index.d.ts

@@ -0,0 +1,3 @@
+export { AgentKit } from "./agentkit";
+export * from "./wallet-providers";
+export * from "./action-providers";

package/dist/index.js

@@ -0,0 +1,22 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AgentKit = void 0;
+// Export CDP AgentKit
+var agentkit_1 = require("./agentkit");
+Object.defineProperty(exports, "AgentKit", { enumerable: true, get: function () { return agentkit_1.AgentKit; } });
+__exportStar(require("./wallet-providers"), exports);
+__exportStar(require("./action-providers"), exports);

package/dist/network/index.d.ts

@@ -0,0 +1 @@
+export * from "./types";

package/dist/network/index.js

@@ -0,0 +1,17 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./types"), exports);

package/dist/network/network.d.ts

@@ -0,0 +1,13 @@
+import { Chain } from "viem/chains";
+/**
+ * Maps EVM chain IDs to Coinbase network IDs
+ */
+export declare const CHAIN_ID_TO_NETWORK_ID: Record<number, string>;
+/**
+ * Maps Coinbase network IDs to EVM chain IDs
+ */
+export declare const NETWORK_ID_TO_CHAIN_ID: Record<string, string>;
+/**
+ * Maps Coinbase network IDs to Viem chain objects
+ */
+export declare const NETWORK_ID_TO_VIEM_CHAIN: Record<string, Chain>;

package/dist/network/network.js

@@ -0,0 +1,41 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NETWORK_ID_TO_VIEM_CHAIN = exports.NETWORK_ID_TO_CHAIN_ID = exports.CHAIN_ID_TO_NETWORK_ID = void 0;
+const chains_1 = require("viem/chains");
+/**
+ * Maps EVM chain IDs to Coinbase network IDs
+ */
+exports.CHAIN_ID_TO_NETWORK_ID = {
+    1: "ethereum-mainnet",
+    11155111: "ethereum-sepolia",
+    137: "polygon-mainnet",
+    80001: "polygon-mumbai",
+    8453: "base-mainnet",
+    84532: "base-sepolia",
+    42161: "arbitrum-mainnet",
+    421614: "arbitrum-sepolia",
+    10: "optimism-mainnet",
+    11155420: "optimism-sepolia",
+};
+/**
+ * Maps Coinbase network IDs to EVM chain IDs
+ */
+exports.NETWORK_ID_TO_CHAIN_ID = Object.entries(exports.CHAIN_ID_TO_NETWORK_ID).reduce((acc, [chainId, networkId]) => {
+    acc[networkId] = String(chainId);
+    return acc;
+}, {});
+/**
+ * Maps Coinbase network IDs to Viem chain objects
+ */
+exports.NETWORK_ID_TO_VIEM_CHAIN = {
+    "ethereum-mainnet": chains_1.mainnet,
+    "ethereum-sepolia": chains_1.sepolia,
+    "polygon-mainnet": chains_1.polygon,
+    "polygon-mumbai": chains_1.polygonMumbai,
+    "base-mainnet": chains_1.base,
+    "base-sepolia": chains_1.baseSepolia,
+    "arbitrum-mainnet": chains_1.arbitrum,
+    "arbitrum-sepolia": chains_1.arbitrumSepolia,
+    "optimism-mainnet": chains_1.optimism,
+    "optimism-sepolia": chains_1.optimismSepolia,
+};

package/dist/network/types.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Network is the network that the wallet provider is connected to.
+ */
+export interface Network {
+    /**
+     * The protocol family of the network.
+     */
+    protocolFamily: string;
+    /**
+     * The network ID of the network.
+     */
+    networkId?: string;
+    /**
+     * The chain ID of the network.
+     */
+    chainId?: string;
+}

package/dist/network/types.js

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

package/dist/utils.d.ts

@@ -0,0 +1,11 @@
+import { EvmWalletProvider } from "./wallet-providers";
+/**
+ * Approves a spender to spend tokens on behalf of the owner
+ *
+ * @param wallet - The wallet provider
+ * @param tokenAddress - The address of the token contract
+ * @param spenderAddress - The address of the spender
+ * @param amount - The amount to approve in atomic units (wei)
+ * @returns A success message or error message
+ */
+export declare function approve(wallet: EvmWalletProvider, tokenAddress: string, spenderAddress: string, amount: bigint): Promise<string>;

package/dist/utils.js

@@ -0,0 +1,43 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.approve = approve;
+const viem_1 = require("viem");
+const ERC20_ABI = [
+    {
+        inputs: [
+            { name: "spender", type: "address" },
+            { name: "amount", type: "uint256" },
+        ],
+        name: "approve",
+        outputs: [{ name: "", type: "bool" }],
+        stateMutability: "nonpayable",
+        type: "function",
+    },
+];
+/**
+ * Approves a spender to spend tokens on behalf of the owner
+ *
+ * @param wallet - The wallet provider
+ * @param tokenAddress - The address of the token contract
+ * @param spenderAddress - The address of the spender
+ * @param amount - The amount to approve in atomic units (wei)
+ * @returns A success message or error message
+ */
+async function approve(wallet, tokenAddress, spenderAddress, amount) {
+    try {
+        const data = (0, viem_1.encodeFunctionData)({
+            abi: ERC20_ABI,
+            functionName: "approve",
+            args: [spenderAddress, amount],
+        });
+        const txHash = await wallet.sendTransaction({
+            to: tokenAddress,
+            data,
+        });
+        await wallet.waitForTransactionReceipt(txHash);
+        return `Successfully approved ${spenderAddress} to spend ${amount} tokens`;
+    }
+    catch (error) {
+        return `Error approving tokens: ${error}`;
+    }
+}

package/dist/utils.test.d.ts

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

package/dist/utils.test.js

@@ -0,0 +1,50 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const viem_1 = require("viem");
+const utils_1 = require("./utils");
+const MOCK_TOKEN_ADDRESS = "0x1234567890123456789012345678901234567890";
+const MOCK_SPENDER_ADDRESS = "0x9876543210987654321098765432109876543210";
+const MOCK_AMOUNT = BigInt("1000000000000000000");
+const MOCK_TX_HASH = "0xabcdef1234567890";
+const MOCK_RECEIPT = { status: 1, blockNumber: 1234567 };
+describe("utils", () => {
+    describe("approve", () => {
+        let mockWallet;
+        beforeEach(() => {
+            mockWallet = {
+                sendTransaction: jest.fn().mockResolvedValue(MOCK_TX_HASH),
+                waitForTransactionReceipt: jest.fn().mockResolvedValue(MOCK_RECEIPT),
+            };
+        });
+        it("should successfully approve tokens", async () => {
+            const response = await (0, utils_1.approve)(mockWallet, MOCK_TOKEN_ADDRESS, MOCK_SPENDER_ADDRESS, MOCK_AMOUNT);
+            expect(mockWallet.sendTransaction).toHaveBeenCalledWith({
+                to: MOCK_TOKEN_ADDRESS,
+                data: (0, viem_1.encodeFunctionData)({
+                    abi: [
+                        {
+                            inputs: [
+                                { name: "spender", type: "address" },
+                                { name: "amount", type: "uint256" },
+                            ],
+                            name: "approve",
+                            outputs: [{ name: "", type: "bool" }],
+                            stateMutability: "nonpayable",
+                            type: "function",
+                        },
+                    ],
+                    functionName: "approve",
+                    args: [MOCK_SPENDER_ADDRESS, MOCK_AMOUNT],
+                }),
+            });
+            expect(mockWallet.waitForTransactionReceipt).toHaveBeenCalledWith(MOCK_TX_HASH);
+            expect(response).toBe(`Successfully approved ${MOCK_SPENDER_ADDRESS} to spend ${MOCK_AMOUNT} tokens`);
+        });
+        it("should handle approval errors", async () => {
+            const error = new Error("Failed to approve");
+            mockWallet.sendTransaction.mockRejectedValue(error);
+            const response = await (0, utils_1.approve)(mockWallet, MOCK_TOKEN_ADDRESS, MOCK_SPENDER_ADDRESS, MOCK_AMOUNT);
+            expect(response).toBe(`Error approving tokens: ${error}`);
+        });
+    });
+});

package/dist/wallet-providers/cdpWalletProvider.d.ts

@@ -0,0 +1,218 @@
+import { ReadContractParameters, ReadContractReturnType, TransactionRequest, TransactionSerializable } from "viem";
+import { EvmWalletProvider } from "./evmWalletProvider";
+import { Network } from "../network";
+import { CreateERC20Options, CreateTradeOptions, SmartContract, Trade, Wallet, WalletData } from "@coinbase/coinbase-sdk";
+/**
+ * Configuration options for the CDP Providers.
+ */
+export interface CdpProviderConfig {
+    /**
+     * The CDP API Key Name.
+     */
+    apiKeyName?: string;
+    /**
+     * The CDP API Key Private Key.
+     */
+    apiKeyPrivateKey?: string;
+}
+/**
+ * Configuration options for the CdpActionProvider.
+ */
+export interface CdpWalletProviderConfig extends CdpProviderConfig {
+    /**
+     * The CDP Wallet.
+     */
+    wallet?: Wallet;
+    /**
+     * The address of the wallet.
+     */
+    address?: string;
+    /**
+     * The network of the wallet.
+     */
+    network?: Network;
+    /**
+     * The network ID of the wallet.
+     */
+    networkId?: string;
+}
+/**
+ * Configuration options for the CDP Agentkit with a Wallet.
+ */
+interface ConfigureCdpAgentkitWithWalletOptions extends CdpWalletProviderConfig {
+    /**
+     * The data of the CDP Wallet as a JSON string.
+     */
+    cdpWalletData?: string;
+    /**
+     * The mnemonic phrase of the wallet.
+     */
+    mnemonicPhrase?: string;
+}
+/**
+ * A wallet provider that uses the Coinbase SDK.
+ */
+export declare class CdpWalletProvider extends EvmWalletProvider {
+    #private;
+    /**
+     * Constructs a new CdpWalletProvider.
+     *
+     * @param config - The configuration options for the CdpWalletProvider.
+     */
+    private constructor();
+    /**
+     * Configures a new CdpWalletProvider with a wallet.
+     *
+     * @param config - Optional configuration parameters
+     * @returns A Promise that resolves to a new CdpWalletProvider instance
+     * @throws Error if required environment variables are missing or wallet initialization fails
+     */
+    static configureWithWallet(config?: ConfigureCdpAgentkitWithWalletOptions): Promise<CdpWalletProvider>;
+    /**
+     * Signs a message.
+     *
+     * @param message - The message to sign.
+     * @returns The signed message.
+     */
+    signMessage(message: string): Promise<`0x${string}`>;
+    /**
+     * Signs a typed data object.
+     *
+     * @param typedData - The typed data object to sign.
+     * @returns The signed typed data object.
+     */
+    signTypedData(typedData: any): Promise<`0x${string}`>;
+    /**
+     * Signs a transaction.
+     *
+     * @param transaction - The transaction to sign.
+     * @returns The signed transaction.
+     */
+    signTransaction(transaction: TransactionRequest): Promise<`0x${string}`>;
+    /**
+     * Sends a transaction.
+     *
+     * @param transaction - The transaction to send.
+     * @returns The hash of the transaction.
+     */
+    sendTransaction(transaction: TransactionRequest): Promise<`0x${string}`>;
+    /**
+     * Prepares a transaction.
+     *
+     * @param to - The address to send the transaction to.
+     * @param value - The value of the transaction.
+     * @param data - The data of the transaction.
+     * @returns The prepared transaction.
+     */
+    prepareTransaction(to: `0x${string}`, value: bigint, data: `0x${string}`): Promise<TransactionSerializable>;
+    /**
+     * Adds signature to a transaction and serializes it for broadcast.
+     *
+     * @param transaction - The transaction to sign.
+     * @param signature - The signature to add to the transaction.
+     * @returns A serialized transaction.
+     */
+    addSignatureAndSerialize(transaction: TransactionSerializable, signature: `0x${string}`): Promise<string>;
+    /**
+     * Gets the address of the wallet.
+     *
+     * @returns The address of the wallet.
+     */
+    getAddress(): string;
+    /**
+     * Gets the network of the wallet.
+     *
+     * @returns The network of the wallet.
+     */
+    getNetwork(): Network;
+    /**
+     * Gets the name of the wallet provider.
+     *
+     * @returns The name of the wallet provider.
+     */
+    getName(): string;
+    /**
+     * Gets the balance of the wallet.
+     *
+     * @returns The balance of the wallet in wei
+     */
+    getBalance(): Promise<bigint>;
+    /**
+     * Waits for a transaction receipt.
+     *
+     * @param txHash - The hash of the transaction to wait for.
+     * @returns The transaction receipt.
+     */
+    waitForTransactionReceipt(txHash: `0x${string}`): Promise<any>;
+    /**
+     * Reads a contract.
+     *
+     * @param params - The parameters to read the contract.
+     * @returns The response from the contract.
+     */
+    readContract(params: ReadContractParameters): Promise<ReadContractReturnType>;
+    /**
+     * Creates a trade.
+     *
+     * @param options - The options for the trade.
+     * @returns The trade.
+     */
+    createTrade(options: CreateTradeOptions): Promise<Trade>;
+    /**
+     * Deploys a token.
+     *
+     * @param options - The options for the token deployment.
+     * @returns The deployed token.
+     */
+    deployToken(options: CreateERC20Options): Promise<SmartContract>;
+    /**
+     * Deploys a contract.
+     *
+     * @param options - The options for contract deployment
+     * @param options.solidityVersion - The version of the Solidity compiler to use (e.g. "0.8.0+commit.c7dfd78e")
+     * @param options.solidityInputJson - The JSON input for the Solidity compiler containing contract source and settings
+     * @param options.contractName - The name of the contract to deploy
+     * @param options.constructorArgs - Key-value map of constructor args
+     *
+     * @returns A Promise that resolves to the deployed contract instance
+     * @throws Error if wallet is not initialized
+     */
+    deployContract(options: {
+        solidityVersion: string;
+        solidityInputJson: string;
+        contractName: string;
+        constructorArgs: Record<string, unknown>;
+    }): Promise<SmartContract>;
+    /**
+     * Deploys a new NFT (ERC-721) smart contract.
+     *
+     * @param options - Configuration options for the NFT contract deployment
+     * @param options.name - The name of the collection
+     * @param options.symbol - The token symbol for the collection
+     * @param options.baseURI - The base URI for token metadata.
+     *
+     * @returns A Promise that resolves to the deployed SmartContract instance
+     * @throws Error if the wallet is not properly initialized
+     * @throws Error if the deployment fails for any reason (network issues, insufficient funds, etc.)
+     */
+    deployNFT(options: {
+        name: string;
+        symbol: string;
+        baseURI: string;
+    }): Promise<SmartContract>;
+    /**
+     * Transfer the native asset of the network.
+     *
+     * @param to - The destination address.
+     * @param value - The amount to transfer in Wei.
+     * @returns The transaction hash.
+     */
+    nativeTransfer(to: `0x${string}`, value: string): Promise<`0x${string}`>;
+    /**
+     * Exports the wallet.
+     *
+     * @returns The wallet's data.
+     */
+    exportWallet(): Promise<WalletData>;
+}
+export {};