@coinbase/cdp-sdk 0.0.0 → 1.0.1

package/README.md

@@ -0,0 +1,165 @@
+# Coinbase Developer Platform (CDP) TypeScript SDK
+
+## Table of Contents
+
+- [CDP SDK](#cdp-sdk)
+- [Installation](#installation)
+- [API Keys](#api-keys)
+- [Usage](#usage)
+- [Authentication tools](#authentication-tools)
+- [Error Reporting](#error-reporting)
+- [License](#license)
+- [Support](#support)
+- [Security](#security)
+
+> [!TIP]
+> If you're looking to contribute to the SDK, please see the [Contributing Guide](https://github.com/coinbase/cdp-sdk/blob/main/typescript/CONTRIBUTING.md).
+
+## CDP SDK
+
+This module contains the TypeScript CDP SDK, which is a library that provides a client for interacting with the [Coinbase Developer Platform (CDP)](https://docs.cdp.coinbase.com/). It includes a CDP Client for interacting with EVM and Solana APIs to create accounts and send transactions, as well as authentication tools for interacting directly with the CDP APIs.
+
+## Installation
+
+```bash
+npm install @coinbase/cdp-sdk
+```
+
+## API Keys
+
+To start, [create a CDP API Key](https://portal.cdp.coinbase.com/access/api). Save the `API Key ID` and `API Key Secret` for use in the SDK. You will also need to create a wallet secret in the [CDP Portal](https://portal.cdp.coinbase.com/products/wallet-api) to sign transactions.
+
+## Usage
+
+### Initialization
+
+#### You can import the SDK as follows:
+
+```typescript
+import { CdpClient } from "@coinbase/cdp-sdk";
+```
+
+#### Then, initialize the client as follows:
+
+```typescript
+const cdp = new CdpClient({
+  apiKeyId: "YOUR_API_KEY_ID",
+  apiKeySecret: "YOUR_API_KEY_SECRET",
+  walletSecret: "YOUR_WALLET_SECRET",
+});
+```
+
+### Creating EVM or Solana accounts
+
+#### Create an EVM account as follows:
+
+```typescript
+const evmAccount = await cdp.evm.createAccount();
+```
+
+#### Create a Solana account as follows:
+
+```typescript
+const solanaAccount = await cdp.solana.createAccount();
+```
+
+### Testnet faucet
+
+You can use the faucet function to request testnet ETH or SOL from the CDP.
+
+#### Request testnet ETH as follows:
+
+```typescript
+const faucetResp = await cdp.evm.requestFaucet({
+  address: evmAccount.address,
+  network: "base-sepolia",
+  token: "eth",
+});
+```
+
+#### Request testnet SOL as follows:
+
+```typescript
+const faucetResp = await cdp.solana.requestFaucet({
+  address: fromAddress,
+  token: "sol",
+});
+```
+
+### Sending transactions
+
+For EVM, we recommend using viem to send transactions. See the [examples](https://github.com/coinbase/cdp-sdk/tree/main/typescript/src/examples/evm/sendTransaction.ts). For Solana, we recommend using the `@solana/web3.js` library to send transactions. See the [examples](https://github.com/coinbase/cdp-sdk/tree/main/typescript/src/examples/solana/signAndSendTransaction.ts).
+
+### EVM Smart Accounts
+
+For EVM, we support Smart Accounts which are account-abstraction (ERC-4337) accounts. Currently there is only support for Base Sepolia and Base Mainnet for Smart Accounts.
+
+#### Create an EVM account and a smart account as follows:
+
+```typescript
+const evmAccount = await cdp.evm.createAccount();
+const smartAccount = await cdp.evm.createSmartAccount({
+  owner: evmAccount,
+});
+```
+
+#### Sending User Operations
+
+```typescript
+const userOperation = await cdp.evm.sendUserOperation({
+  smartAccount: smartAccount,
+  network: "base-sepolia",
+  calls: [
+    {
+      to: "0x0000000000000000000000000000000000000000",
+      value: parseEther("0.000001"),
+      data: "0x",
+    },
+  ],
+});
+```
+
+#### In Base Sepolia, all user operations are gasless by default. If you'd like to specify a different paymaster, you can do so as follows:
+
+```typescript
+const userOperation = await cdp.sendUserOperation({
+  smartAccount: smartAccount,
+  network: "base-sepolia",
+  calls: [
+    {
+      to: "0x0000000000000000000000000000000000000000",
+      value: parseEther("0"),
+      data: "0x",
+    },
+  ],
+  paymasterUrl: "https://some-paymaster-url.com",
+});
+```
+
+## Authentication tools
+
+This SDK also contains simple tools for authenticating REST API requests to the [Coinbase Developer Platform (CDP)](https://docs.cdp.coinbase.com/). See the [Auth README](src/auth/README.md) for more details.
+
+## Error Reporting
+
+This SDK contains error reporting functionality that sends error events to the CDP. If you would like to disable this behavior, you can set the `DISABLE_CDP_ERROR_REPORTING` environment variable to `true`.
+
+```bash
+DISABLE_CDP_ERROR_REPORTING=true
+```
+
+## License
+
+This project is licensed under the MIT License - see the [LICENSE](https://github.com/coinbase/cdp-sdk/tree/main/LICENSE.md) file for details.
+
+## Support
+
+For feature requests, feedback, or questions, please reach out to us in the **#cdp-sdk** channel of the [Coinbase Developer Platform Discord](https://discord.com/invite/cdp).
+
+- [API Reference](https://docs.cdp.coinbase.com/api-v2/docs/welcome)
+- [SDK Docs](https://coinbase.github.io/cdp-sdk/typescript)
+- [GitHub Issues](https://github.com/coinbase/cdp-sdk/issues)
+
+## Security
+
+If you discover a security vulnerability within this SDK, please see our [Security Policy](https://github.com/coinbase/cdp-sdk/tree/main/SECURITY.md) for disclosure information.

package/dist/accounts/evm/toEvmServerAccount.d.ts

@@ -0,0 +1,19 @@
+import { EvmServerAccount } from "../types";
+import { CdpOpenApiClientType, EvmAccount } from "../../openapi-client";
+/**
+ * Options for converting a pre-existing EvmAccount to a EvmServerAccount.
+ */
+export type ToEvmServerAccountOptions = {
+    /** The EvmAccount that was previously created. */
+    account: EvmAccount;
+};
+/**
+ * Creates a Server-managed EvmAccount instance from an existing EvmAccount.
+ * Use this to interact with previously deployed EvmAccounts, rather than creating new ones.
+ *
+ * @param {CdpOpenApiClientType} apiClient - The API client.
+ * @param {ToEvmServerAccountOptions} options - Configuration options.
+ * @param {EvmAccount} options.account - The EvmAccount that was previously created.
+ * @returns {EvmServerAccount} A configured EvmAccount instance ready for signing.
+ */
+export declare function toEvmServerAccount(apiClient: CdpOpenApiClientType, options: ToEvmServerAccountOptions): EvmServerAccount;

package/dist/accounts/evm/toEvmServerAccount.js

@@ -0,0 +1,42 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.toEvmServerAccount = toEvmServerAccount;
+const viem_1 = require("viem");
+/**
+ * Creates a Server-managed EvmAccount instance from an existing EvmAccount.
+ * Use this to interact with previously deployed EvmAccounts, rather than creating new ones.
+ *
+ * @param {CdpOpenApiClientType} apiClient - The API client.
+ * @param {ToEvmServerAccountOptions} options - Configuration options.
+ * @param {EvmAccount} options.account - The EvmAccount that was previously created.
+ * @returns {EvmServerAccount} A configured EvmAccount instance ready for signing.
+ */
+function toEvmServerAccount(apiClient, options) {
+    const account = {
+        address: options.account.address,
+        async signMessage({ message }) {
+            const result = await apiClient.signEvmMessage(options.account.address, {
+                message: message.toString(),
+            });
+            return result.signature;
+        },
+        async sign(parameters) {
+            const result = await apiClient.signEvmHash(options.account.address, {
+                hash: parameters.hash,
+            });
+            return result.signature;
+        },
+        async signTransaction(transaction) {
+            const result = await apiClient.signEvmTransaction(options.account.address, {
+                transaction: (0, viem_1.serializeTransaction)(transaction),
+            });
+            return result.signedTransaction;
+        },
+        async signTypedData() {
+            throw new Error("Not implemented");
+        },
+        name: options.account.name,
+        type: "evm-server",
+    };
+    return account;
+}

package/dist/accounts/evm/toEvmSmartAccount.d.ts

@@ -0,0 +1,24 @@
+import { EvmAccount, EvmSmartAccount } from "../types";
+import { EvmSmartAccount as EvmSmartAccountModel } from "../../openapi-client";
+/**
+ * Options for converting a pre-existing EvmSmartAccount and owner to a EvmSmartAccount
+ */
+export type ToEvmSmartAccountOptions = {
+    /** The pre-existing EvmSmartAccount. */
+    smartAccount: EvmSmartAccountModel;
+    /** The owner of the smart account. */
+    owner: EvmAccount;
+};
+/**
+ * Creates a EvmSmartAccount instance from an existing EvmSmartAccount and owner.
+ * Use this to interact with previously deployed EvmSmartAccounts, rather than creating new ones.
+ *
+ * The owner must be the original owner of the evm smart account.
+ *
+ * @param {ToEvmSmartAccountOptions} options - Configuration options.
+ * @param {EvmSmartAccount} options.smartAccount - The deployed evm smart account.
+ * @param {EvmAccount} options.owner - The owner which signs for the smart account.
+ * @returns {EvmSmartAccount} A configured EvmSmartAccount instance ready for user operation submission.
+ * @throws {Error} If the account is not an original owner of the smart account.
+ */
+export declare function toEvmSmartAccount(options: ToEvmSmartAccountOptions): EvmSmartAccount;

package/dist/accounts/evm/toEvmSmartAccount.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.toEvmSmartAccount = toEvmSmartAccount;
+/**
+ * Creates a EvmSmartAccount instance from an existing EvmSmartAccount and owner.
+ * Use this to interact with previously deployed EvmSmartAccounts, rather than creating new ones.
+ *
+ * The owner must be the original owner of the evm smart account.
+ *
+ * @param {ToEvmSmartAccountOptions} options - Configuration options.
+ * @param {EvmSmartAccount} options.smartAccount - The deployed evm smart account.
+ * @param {EvmAccount} options.owner - The owner which signs for the smart account.
+ * @returns {EvmSmartAccount} A configured EvmSmartAccount instance ready for user operation submission.
+ * @throws {Error} If the account is not an original owner of the smart account.
+ */
+function toEvmSmartAccount(options) {
+    const account = {
+        address: options.smartAccount.address,
+        owners: [options.owner],
+        name: options.smartAccount.name,
+        type: "evm-smart",
+    };
+    return account;
+}

package/dist/accounts/types.d.ts

@@ -0,0 +1,45 @@
+import { SignableMessage, TransactionSerializable, TypedData, TypedDataDefinition } from "viem";
+import type { Hash, Hex, Address } from "../types/misc";
+import { Prettify } from "../types/utils";
+/**
+ * Base type for any Ethereum account with signing capabilities.
+ * For example, this could be an EVM ServerAccount, or a viem LocalAccount.
+ */
+export type EvmAccount = {
+    /** The address of the signer. */
+    address: Address;
+    /** Signs a message hash and returns the signature as a hex string. */
+    sign: (parameters: {
+        hash: Hash;
+    }) => Promise<Hex>;
+    /** Signs a message and returns the signature as a hex string. */
+    signMessage: (parameters: {
+        message: SignableMessage;
+    }) => Promise<Hex>;
+    /** Signs a transaction and returns the signed transaction as a hex string. */
+    signTransaction: (transaction: TransactionSerializable) => Promise<Hex>;
+    /** Signs a typed data and returns the signature as a hex string. */
+    signTypedData: <const typedData extends TypedData | Record<string, unknown>, primaryType extends keyof typedData | "EIP712Domain" = keyof typedData>(parameters: TypedDataDefinition<typedData, primaryType>) => Promise<Hex>;
+};
+/**
+ * Server-managed ethereum account
+ */
+export type EvmServerAccount = Prettify<EvmAccount & {
+    /** Optional name for the server account. */
+    name?: string;
+    /** Indicates this is a server-managed account. */
+    type: "evm-server";
+}>;
+/**
+ * Ethereum smart account which supports account abstraction features like user operations, batch transactions, and paymaster.
+ */
+export type EvmSmartAccount = {
+    /** The smart account's address. */
+    address: Address;
+    /** The name of the smart account. */
+    name?: string;
+    /** Array of accounts that own and can sign for the smart account (currently only supports one owner but will be extended to support multiple owners in the future). */
+    owners: EvmAccount[];
+    /** Identifier for the smart account type. */
+    type: "evm-smart";
+};

package/dist/accounts/types.js

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

package/dist/actions/evm/sendUserOperation.d.ts

@@ -0,0 +1,95 @@
+import type { EvmSmartAccount } from "../../accounts/types";
+import { EvmUserOperationNetwork, EvmUserOperationStatus } from "../../openapi-client";
+import type { Address, Hex } from "../../types/misc";
+import type { Calls } from "../../types/calls";
+import { CdpOpenApiClientType } from "../../openapi-client";
+/**
+ * Options for sending a user operation.
+ *
+ * @template T - Array type for the calls parameter.
+ */
+export type SendUserOperationOptions<T extends readonly unknown[]> = {
+    /**
+     * Array of contract calls to execute in the user operation.
+     * Each call can either be:
+     * - A direct call with `to`, `value`, and `data`.
+     * - A contract call with `to`, `abi`, `functionName`, and `args`.
+     *
+     * @example
+     * ```ts
+     * const calls = [
+     *   {
+     *     to: "0x1234567890123456789012345678901234567890",
+     *     value: parseEther("0.0000005"),
+     *     data: "0x",
+     *   },
+     *   {
+     *     to: "0x1234567890123456789012345678901234567890",
+     *     abi: erc20Abi,
+     *     functionName: "transfer",
+     *     args: [to, amount],
+     *   },
+     * ]
+     * ```
+     */
+    calls: Calls<T>;
+    /** Chain ID of the network to execute on. */
+    network: EvmUserOperationNetwork;
+    /** Optional URL of the paymaster service to use for gas sponsorship. Must be ERC-7677 compliant. */
+    paymasterUrl?: string;
+    /** The idempotency key. */
+    idempotencyKey?: string;
+};
+/**
+ * Return type for the sendUserOperation function.
+ */
+export type SendUserOperationReturnType = {
+    /** The address of the smart wallet. */
+    smartAccountAddress: Address;
+    /** The status of the user operation. */
+    status: typeof EvmUserOperationStatus.broadcast;
+    /** The hash of the user operation. This is not the transaction hash which is only available after the operation is completed.*/
+    userOpHash: Hex;
+};
+/**
+ * Sends a user operation to the network.
+ *
+ * @example
+ * ```ts
+ * import { sendUserOperation } from "@coinbase/cdp-sdk";
+ * import { parseEther } from "viem";
+ * import { CdpClient } from "@coinbase/cdp-sdk";
+ *
+ * const client = new CdpClient({
+ *   apiKeyId: "your-api-key-id",
+ *   apiKeySecret: "your-api-key-secret",
+ *   walletSecret: "your-wallet-secret",
+ * });
+ *
+ * const ethAccount = await client.createEvmServerAccount()
+ * const smartAccount = await client.createEvmSmartAccount({ owner: ethAccount })
+ *
+ * const result = await sendUserOperation(client, smartAccount, {
+ *   calls: [
+ *     {
+ *       abi: erc20Abi,
+ *       functionName: "transfer",
+ *       args: [to, amount],
+ *     },
+ *     {
+ *       to: "0x1234567890123456789012345678901234567890",
+ *       data: "0x",
+ *       value: parseEther("0.0000005"),
+ *     },
+ *   ],
+ *   network: "base-sepolia",
+ *   paymasterUrl: "https://api.developer.coinbase.com/rpc/v1/base/someapikey",
+ * });
+ * ```
+ *
+ * @param {CdpOpenApiClientType} client - The client to use to send the user operation.
+ * @param {EvmSmartAccount} smartAccount - The smart account to send the user operation from.
+ * @param {SendUserOperationOptions<T>} options - The options for the user operation.
+ * @returns {Promise<SendUserOperationReturnType>} The result of the user operation.
+ */
+export declare function sendUserOperation<T extends readonly unknown[]>(client: CdpOpenApiClientType, smartAccount: EvmSmartAccount, options: SendUserOperationOptions<T>): Promise<SendUserOperationReturnType>;

package/dist/actions/evm/sendUserOperation.js

@@ -0,0 +1,87 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.sendUserOperation = sendUserOperation;
+const viem_1 = require("viem");
+/**
+ * Sends a user operation to the network.
+ *
+ * @example
+ * ```ts
+ * import { sendUserOperation } from "@coinbase/cdp-sdk";
+ * import { parseEther } from "viem";
+ * import { CdpClient } from "@coinbase/cdp-sdk";
+ *
+ * const client = new CdpClient({
+ *   apiKeyId: "your-api-key-id",
+ *   apiKeySecret: "your-api-key-secret",
+ *   walletSecret: "your-wallet-secret",
+ * });
+ *
+ * const ethAccount = await client.createEvmServerAccount()
+ * const smartAccount = await client.createEvmSmartAccount({ owner: ethAccount })
+ *
+ * const result = await sendUserOperation(client, smartAccount, {
+ *   calls: [
+ *     {
+ *       abi: erc20Abi,
+ *       functionName: "transfer",
+ *       args: [to, amount],
+ *     },
+ *     {
+ *       to: "0x1234567890123456789012345678901234567890",
+ *       data: "0x",
+ *       value: parseEther("0.0000005"),
+ *     },
+ *   ],
+ *   network: "base-sepolia",
+ *   paymasterUrl: "https://api.developer.coinbase.com/rpc/v1/base/someapikey",
+ * });
+ * ```
+ *
+ * @param {CdpOpenApiClientType} client - The client to use to send the user operation.
+ * @param {EvmSmartAccount} smartAccount - The smart account to send the user operation from.
+ * @param {SendUserOperationOptions<T>} options - The options for the user operation.
+ * @returns {Promise<SendUserOperationReturnType>} The result of the user operation.
+ */
+async function sendUserOperation(client, smartAccount, options) {
+    const { calls, network, paymasterUrl } = options;
+    if (calls.length === 0) {
+        throw new Error("Calls array is empty");
+    }
+    const encodedCalls = calls.map(call => {
+        const value = (call.value ?? BigInt(0)).toString();
+        if ("abi" in call && call.abi && "functionName" in call) {
+            return {
+                to: call.to,
+                data: (0, viem_1.encodeFunctionData)({
+                    abi: call.abi,
+                    functionName: call.functionName,
+                    args: call.args,
+                }),
+                value,
+            };
+        }
+        return {
+            to: call.to,
+            data: call.data ?? "0x",
+            value,
+        };
+    });
+    const createOpResponse = await client.prepareUserOperation(smartAccount.address, {
+        network,
+        calls: encodedCalls,
+        paymasterUrl,
+    });
+    const owner = smartAccount.owners[0];
+    const signature = await owner.sign({
+        hash: createOpResponse.userOpHash,
+    });
+    const broadcastResponse = await client.sendUserOperation(smartAccount.address, createOpResponse.userOpHash, {
+        signature,
+    }, options.idempotencyKey);
+    return {
+        smartAccountAddress: smartAccount.address,
+        status: broadcastResponse.status,
+        userOpHash: createOpResponse.userOpHash,
+    };
+}

package/dist/actions/evm/waitForUserOperation.d.ts

@@ -0,0 +1,63 @@
+import type { Address, Hex } from "../../types/misc";
+import { WaitOptions } from "../../utils/wait";
+import { EvmUserOperationStatus, CdpOpenApiClientType } from "../../openapi-client";
+/**
+ * Options for waiting for a user operation.
+ */
+export type WaitForUserOperationOptions = {
+    /** The hash of the user operation. */
+    userOpHash: Hex;
+    /** The address of the smart account. */
+    smartAccountAddress: Address;
+    /** Optional options for the wait operation. */
+    waitOptions?: WaitOptions;
+};
+/**
+ * Represents a failed user operation.
+ */
+export type FailedOperation = {
+    /** The address of the smart account. */
+    smartAccountAddress: Address;
+    /** The status of the user operation. */
+    status: typeof EvmUserOperationStatus.failed;
+    /** The hash of the user operation. This is not the transaction hash which is only available after the operation is completed.*/
+    userOpHash: Hex;
+};
+/**
+ * Represents a completed user operation.
+ */
+export type CompletedOperation = {
+    /** The address of the smart account. */
+    smartAccountAddress: Address;
+    /** The transaction hash that executed the completed user operation. */
+    transactionHash: string;
+    /** The status of the user operation. */
+    status: typeof EvmUserOperationStatus.complete;
+    /** The hash of the user operation. This is not the transaction hash which is only available after the operation is completed.*/
+    userOpHash: Hex;
+};
+/**
+ * Represents the return type of the waitForUserOperation function.
+ */
+export type WaitForUserOperationReturnType = FailedOperation | CompletedOperation;
+/**
+ * Waits for a user operation to complete or fail.
+ *
+ * @example
+ * ```ts
+ * import { waitForUserOperation } from "@coinbase/cdp-sdk";
+ *
+ * const result = await waitForUserOperation(client, {
+ *   userOpHash: "0x1234567890123456789012345678901234567890",
+ *   smartAccountAddress: "0x1234567890123456789012345678901234567890",
+ *   waitOptions: {
+ *     timeoutSeconds: 30,
+ *   },
+ * });
+ * ```
+ *
+ * @param {CdpOpenApiClientType} client - The client to use to wait for the user operation.
+ * @param {WaitForUserOperationOptions} options - The options for the wait operation.
+ * @returns {Promise<WaitForUserOperationReturnType>} The result of the user operation.
+ */
+export declare function waitForUserOperation(client: CdpOpenApiClientType, options: WaitForUserOperationOptions): Promise<WaitForUserOperationReturnType>;

package/dist/actions/evm/waitForUserOperation.js

@@ -0,0 +1,60 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.waitForUserOperation = waitForUserOperation;
+const wait_1 = require("../../utils/wait");
+const openapi_client_1 = require("../../openapi-client");
+/**
+ * Waits for a user operation to complete or fail.
+ *
+ * @example
+ * ```ts
+ * import { waitForUserOperation } from "@coinbase/cdp-sdk";
+ *
+ * const result = await waitForUserOperation(client, {
+ *   userOpHash: "0x1234567890123456789012345678901234567890",
+ *   smartAccountAddress: "0x1234567890123456789012345678901234567890",
+ *   waitOptions: {
+ *     timeoutSeconds: 30,
+ *   },
+ * });
+ * ```
+ *
+ * @param {CdpOpenApiClientType} client - The client to use to wait for the user operation.
+ * @param {WaitForUserOperationOptions} options - The options for the wait operation.
+ * @returns {Promise<WaitForUserOperationReturnType>} The result of the user operation.
+ */
+async function waitForUserOperation(client, options) {
+    const { userOpHash, smartAccountAddress } = options;
+    const reload = async () => {
+        const response = await client.getUserOperation(smartAccountAddress, userOpHash);
+        return response;
+    };
+    const transform = (operation) => {
+        if (operation.status === openapi_client_1.EvmUserOperationStatus.failed) {
+            return {
+                smartAccountAddress: smartAccountAddress,
+                status: openapi_client_1.EvmUserOperationStatus.failed,
+                userOpHash: operation.userOpHash,
+            };
+        }
+        else if (operation.status === openapi_client_1.EvmUserOperationStatus.complete) {
+            return {
+                smartAccountAddress: smartAccountAddress,
+                transactionHash: operation.transactionHash,
+                status: openapi_client_1.EvmUserOperationStatus.complete,
+                userOpHash: operation.userOpHash,
+            };
+        }
+        else {
+            throw new Error("User operation is not terminal");
+        }
+    };
+    const waitOptions = options.waitOptions || {
+        timeoutSeconds: 30,
+    };
+    return await (0, wait_1.wait)(reload, isTerminal, transform, waitOptions);
+}
+const isTerminal = (operation) => {
+    return (operation.status === openapi_client_1.EvmUserOperationStatus.complete ||
+        operation.status === openapi_client_1.EvmUserOperationStatus.failed);
+};

package/dist/analytics.d.ts

@@ -0,0 +1,30 @@
+/**
+ * The data in an error event
+ */
+type ErrorEventData = {
+    /**
+     * The API method where the error occurred, e.g. createAccount, getAccount
+     */
+    method: string;
+    /**
+     * The error message
+     */
+    message: string;
+    /**
+     * The error stack trace
+     */
+    stack?: string;
+    /**
+     * The name of the event. This should match the name in AEC
+     */
+    name: "error";
+};
+type EventData = ErrorEventData;
+/**
+ * Sends an analytics event to the default endpoint
+ *
+ * @param event - The event data containing event-specific fields
+ * @returns Promise that resolves when the event is sent
+ */
+export declare function sendEvent(event: EventData): Promise<void>;
+export {};