@distilled.cloud/coinbase 0.0.0 → 0.2.5-alpha2

package/src/operations/index.ts

@@ -0,0 +1,73 @@
+export * from "./listEndUsers";
+export * from "./createEndUser";
+export * from "./validateEndUserAccessToken";
+export * from "./getEndUser";
+export * from "./addEndUserEvmAccount";
+export * from "./addEndUserEvmSmartAccount";
+export * from "./addEndUserSolanaAccount";
+export * from "./importEndUser";
+export * from "./listEvmAccounts";
+export * from "./createEvmAccount";
+export * from "./getEvmAccount";
+export * from "./updateEvmAccount";
+export * from "./getEvmAccountByName";
+export * from "./sendEvmTransaction";
+export * from "./signEvmTransaction";
+export * from "./signEvmHash";
+export * from "./signEvmMessage";
+export * from "./signEvmTypedData";
+export * from "./createEvmEip7702Delegation";
+export * from "./getEvmEip7702DelegationOperationById";
+export * from "./listEvmSmartAccounts";
+export * from "./createEvmSmartAccount";
+export * from "./getEvmSmartAccountByName";
+export * from "./importEvmAccount";
+export * from "./exportEvmAccount";
+export * from "./exportEvmAccountByName";
+export * from "./getEvmSmartAccount";
+export * from "./updateEvmSmartAccount";
+export * from "./prepareUserOperation";
+export * from "./prepareAndSendUserOperation";
+export * from "./getUserOperation";
+export * from "./sendUserOperation";
+export * from "./createSpendPermission";
+export * from "./listSpendPermissions";
+export * from "./revokeSpendPermission";
+export * from "./getEvmSwapPrice";
+export * from "./createEvmSwapQuote";
+export * from "./listEvmTokenBalances";
+export * from "./requestEvmFaucet";
+export * from "./listPolicies";
+export * from "./createPolicy";
+export * from "./getPolicyById";
+export * from "./updatePolicy";
+export * from "./deletePolicy";
+export * from "./listSolanaAccounts";
+export * from "./createSolanaAccount";
+export * from "./getSolanaAccount";
+export * from "./updateSolanaAccount";
+export * from "./getSolanaAccountByName";
+export * from "./importSolanaAccount";
+export * from "./exportSolanaAccount";
+export * from "./exportSolanaAccountByName";
+export * from "./signSolanaTransaction";
+export * from "./signSolanaMessage";
+export * from "./sendSolanaTransaction";
+export * from "./requestSolanaFaucet";
+export * from "./listSolanaTokenBalances";
+export * from "./runSQLQuery";
+export * from "./getSQLGrammar";
+export * from "./listTokensForAccount";
+export * from "./listDataTokenBalances";
+export * from "./listWebhookSubscriptions";
+export * from "./createWebhookSubscription";
+export * from "./getWebhookSubscription";
+export * from "./updateWebhookSubscription";
+export * from "./deleteWebhookSubscription";
+export * from "./verifyX402Payment";
+export * from "./settleX402Payment";
+export * from "./supportedX402PaymentKinds";
+export * from "./createOnrampOrder";
+export * from "./getOnrampOrderById";
+export * from "./createOnrampSession";
+export * from "./getOnrampUserLimits";

package/src/operations/listDataTokenBalances.ts

@@ -0,0 +1,59 @@
+import * as Schema from "effect/Schema";
+import { API } from "../client";
+import * as T from "../traits";
+
+// Input Schema
+export const ListDataTokenBalancesInput =
+  /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
+    address: Schema.String.pipe(T.PathParam()),
+    network: Schema.String.pipe(T.PathParam()),
+    pageSize: Schema.optional(Schema.Number),
+    pageToken: Schema.optional(Schema.String),
+  }).pipe(
+    T.Http({
+      method: "GET",
+      path: "/v2/data/evm/token-balances/{network}/{address}",
+    }),
+  );
+export type ListDataTokenBalancesInput = typeof ListDataTokenBalancesInput.Type;
+
+// Output Schema
+export const ListDataTokenBalancesOutput =
+  /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
+    balances: Schema.Array(
+      Schema.Struct({
+        amount: Schema.Struct({
+          amount: Schema.String,
+          decimals: Schema.Number,
+        }),
+        token: Schema.Struct({
+          network: Schema.Literals(["base", "base-sepolia", "ethereum"]),
+          symbol: Schema.optional(Schema.String),
+          name: Schema.optional(Schema.String),
+          contractAddress: Schema.String,
+        }),
+      }),
+    ),
+    nextPageToken: Schema.optional(Schema.String),
+  });
+export type ListDataTokenBalancesOutput =
+  typeof ListDataTokenBalancesOutput.Type;
+
+// The operation
+/**
+ * List EVM token balances
+ *
+ * Lists the token balances of an EVM address on a given network. The balances include ERC-20 tokens and the native gas token (usually ETH). The response is paginated, and by default, returns 20 balances per page.
+ * **Note:** This endpoint provides <1 second freshness from chain tip, <500ms response latency for wallets with reasonable token history, and 99.9% uptime for production use.
+ *
+ * @param address - The 0x-prefixed EVM address to get balances for. The address does not need to be checksummed.
+ * @param network - The human-readable network name to get the balances for.
+ * @param pageSize - The number of resources to return per page.
+ * @param pageToken - The token for the next page of resources, if any.
+ */
+export const listDataTokenBalances = /*@__PURE__*/ /*#__PURE__*/ API.make(
+  () => ({
+    inputSchema: ListDataTokenBalancesInput,
+    outputSchema: ListDataTokenBalancesOutput,
+  }),
+);

package/src/operations/listEndUsers.ts

@@ -0,0 +1,77 @@
+import * as Schema from "effect/Schema";
+import { API } from "../client";
+import * as T from "../traits";
+
+// Input Schema
+export const ListEndUsersInput = /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
+  pageSize: Schema.optional(Schema.Number),
+  pageToken: Schema.optional(Schema.String),
+  sort: Schema.optional(Schema.String),
+}).pipe(T.Http({ method: "GET", path: "/v2/end-users" }));
+export type ListEndUsersInput = typeof ListEndUsersInput.Type;
+
+// Output Schema
+export const ListEndUsersOutput = /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
+  endUsers: Schema.Array(
+    Schema.Struct({
+      userId: Schema.String,
+      authenticationMethods: Schema.Array(Schema.Unknown),
+      mfaMethods: Schema.optional(
+        Schema.Struct({
+          enrollmentPromptedAt: Schema.optional(Schema.String),
+          totp: Schema.optional(
+            Schema.Struct({
+              enrolledAt: Schema.String,
+            }),
+          ),
+          sms: Schema.optional(
+            Schema.Struct({
+              enrolledAt: Schema.String,
+            }),
+          ),
+        }),
+      ),
+      evmAccounts: Schema.Array(Schema.String),
+      evmAccountObjects: Schema.Array(
+        Schema.Struct({
+          address: Schema.String,
+          createdAt: Schema.String,
+        }),
+      ),
+      evmSmartAccounts: Schema.Array(Schema.String),
+      evmSmartAccountObjects: Schema.Array(
+        Schema.Struct({
+          address: Schema.String,
+          ownerAddresses: Schema.Array(Schema.String),
+          createdAt: Schema.String,
+        }),
+      ),
+      solanaAccounts: Schema.Array(Schema.String),
+      solanaAccountObjects: Schema.Array(
+        Schema.Struct({
+          address: Schema.String,
+          createdAt: Schema.String,
+        }),
+      ),
+      createdAt: Schema.String,
+    }),
+  ),
+  nextPageToken: Schema.optional(Schema.String),
+});
+export type ListEndUsersOutput = typeof ListEndUsersOutput.Type;
+
+// The operation
+/**
+ * List end users
+ *
+ * Lists the end users belonging to the developer's CDP Project.
+ * By default, the response is sorted by creation date in ascending order and paginated to 20 users per page.
+ *
+ * @param pageSize - The number of end users to return per page.
+ * @param pageToken - The token for the desired page of end users. Will be empty if there are no more end users to fetch.
+ * @param sort - Sort end users. Defaults to ascending order (oldest first).
+ */
+export const listEndUsers = /*@__PURE__*/ /*#__PURE__*/ API.make(() => ({
+  inputSchema: ListEndUsersInput,
+  outputSchema: ListEndUsersOutput,
+}));

package/src/operations/listEvmAccounts.ts

@@ -0,0 +1,40 @@
+import * as Schema from "effect/Schema";
+import { API } from "../client";
+import * as T from "../traits";
+
+// Input Schema
+export const ListEvmAccountsInput = /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
+  pageSize: Schema.optional(Schema.Number),
+  pageToken: Schema.optional(Schema.String),
+}).pipe(T.Http({ method: "GET", path: "/v2/evm/accounts" }));
+export type ListEvmAccountsInput = typeof ListEvmAccountsInput.Type;
+
+// Output Schema
+export const ListEvmAccountsOutput = /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
+  accounts: Schema.Array(
+    Schema.Struct({
+      address: Schema.String,
+      name: Schema.optional(Schema.String),
+      policies: Schema.optional(Schema.Array(Schema.String)),
+      createdAt: Schema.optional(Schema.String),
+      updatedAt: Schema.optional(Schema.String),
+    }),
+  ),
+  nextPageToken: Schema.optional(Schema.String),
+});
+export type ListEvmAccountsOutput = typeof ListEvmAccountsOutput.Type;
+
+// The operation
+/**
+ * List EVM accounts
+ *
+ * Lists the EVM accounts belonging to the developer's CDP Project.
+ * The response is paginated, and by default, returns 20 accounts per page.
+ *
+ * @param pageSize - The number of resources to return per page.
+ * @param pageToken - The token for the next page of resources, if any.
+ */
+export const listEvmAccounts = /*@__PURE__*/ /*#__PURE__*/ API.make(() => ({
+  inputSchema: ListEvmAccountsInput,
+  outputSchema: ListEvmAccountsOutput,
+}));

package/src/operations/listEvmSmartAccounts.ts

@@ -0,0 +1,45 @@
+import * as Schema from "effect/Schema";
+import { API } from "../client";
+import * as T from "../traits";
+
+// Input Schema
+export const ListEvmSmartAccountsInput =
+  /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
+    pageSize: Schema.optional(Schema.Number),
+    pageToken: Schema.optional(Schema.String),
+  }).pipe(T.Http({ method: "GET", path: "/v2/evm/smart-accounts" }));
+export type ListEvmSmartAccountsInput = typeof ListEvmSmartAccountsInput.Type;
+
+// Output Schema
+export const ListEvmSmartAccountsOutput =
+  /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
+    accounts: Schema.Array(
+      Schema.Struct({
+        address: Schema.String,
+        owners: Schema.Array(Schema.String),
+        name: Schema.optional(Schema.String),
+        policies: Schema.optional(Schema.Array(Schema.String)),
+        createdAt: Schema.optional(Schema.String),
+        updatedAt: Schema.optional(Schema.String),
+      }),
+    ),
+    nextPageToken: Schema.optional(Schema.String),
+  });
+export type ListEvmSmartAccountsOutput = typeof ListEvmSmartAccountsOutput.Type;
+
+// The operation
+/**
+ * List Smart Accounts
+ *
+ * Lists the Smart Accounts belonging to the developer's CDP Project.
+ * The response is paginated, and by default, returns 20 accounts per page.
+ *
+ * @param pageSize - The number of resources to return per page.
+ * @param pageToken - The token for the next page of resources, if any.
+ */
+export const listEvmSmartAccounts = /*@__PURE__*/ /*#__PURE__*/ API.make(
+  () => ({
+    inputSchema: ListEvmSmartAccountsInput,
+    outputSchema: ListEvmSmartAccountsOutput,
+  }),
+);

package/src/operations/listEvmTokenBalances.ts

@@ -0,0 +1,58 @@
+import * as Schema from "effect/Schema";
+import { API } from "../client";
+import * as T from "../traits";
+
+// Input Schema
+export const ListEvmTokenBalancesInput =
+  /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
+    address: Schema.String.pipe(T.PathParam()),
+    network: Schema.String.pipe(T.PathParam()),
+    pageSize: Schema.optional(Schema.Number),
+    pageToken: Schema.optional(Schema.String),
+  }).pipe(
+    T.Http({
+      method: "GET",
+      path: "/v2/evm/token-balances/{network}/{address}",
+    }),
+  );
+export type ListEvmTokenBalancesInput = typeof ListEvmTokenBalancesInput.Type;
+
+// Output Schema
+export const ListEvmTokenBalancesOutput =
+  /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
+    balances: Schema.Array(
+      Schema.Struct({
+        amount: Schema.Struct({
+          amount: Schema.String,
+          decimals: Schema.Number,
+        }),
+        token: Schema.Struct({
+          network: Schema.Literals(["base", "base-sepolia", "ethereum"]),
+          symbol: Schema.optional(Schema.String),
+          name: Schema.optional(Schema.String),
+          contractAddress: Schema.String,
+        }),
+      }),
+    ),
+    nextPageToken: Schema.optional(Schema.String),
+  });
+export type ListEvmTokenBalancesOutput = typeof ListEvmTokenBalancesOutput.Type;
+
+// The operation
+/**
+ * List EVM token balances
+ *
+ * Lists the token balances of an EVM address on a given network. The balances include ERC-20 tokens and the native gas token (usually ETH). The response is paginated, and by default, returns 20 balances per page.
+ * **Note:** This endpoint is still under development and does not yet provide strong freshness guarantees. Specifically, balances of new tokens can, on occasion, take up to ~30 seconds to appear, while balances of tokens already belonging to an address will generally be close to chain tip. Freshness of new token balances will improve over the coming weeks.
+ *
+ * @param address - The 0x-prefixed EVM address to get balances for. The address does not need to be checksummed.
+ * @param network - The human-readable network name to get the balances for.
+ * @param pageSize - The number of resources to return per page.
+ * @param pageToken - The token for the next page of resources, if any.
+ */
+export const listEvmTokenBalances = /*@__PURE__*/ /*#__PURE__*/ API.make(
+  () => ({
+    inputSchema: ListEvmTokenBalancesInput,
+    outputSchema: ListEvmTokenBalancesOutput,
+  }),
+);

package/src/operations/listPolicies.ts

@@ -0,0 +1,43 @@
+import * as Schema from "effect/Schema";
+import { API } from "../client";
+import * as T from "../traits";
+
+// Input Schema
+export const ListPoliciesInput = /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
+  pageSize: Schema.optional(Schema.Number),
+  pageToken: Schema.optional(Schema.String),
+  scope: Schema.optional(Schema.Literals(["project", "account"])),
+}).pipe(T.Http({ method: "GET", path: "/v2/policy-engine/policies" }));
+export type ListPoliciesInput = typeof ListPoliciesInput.Type;
+
+// Output Schema
+export const ListPoliciesOutput = /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
+  policies: Schema.Array(
+    Schema.Struct({
+      id: Schema.String,
+      description: Schema.optional(Schema.String),
+      scope: Schema.Literals(["project", "account"]),
+      rules: Schema.Array(Schema.Unknown),
+      createdAt: Schema.String,
+      updatedAt: Schema.String,
+    }),
+  ),
+  nextPageToken: Schema.optional(Schema.String),
+});
+export type ListPoliciesOutput = typeof ListPoliciesOutput.Type;
+
+// The operation
+/**
+ * List policies
+ *
+ * Lists the policies belonging to the developer's CDP Project. Use the `scope` parameter to filter the policies by scope.
+ * The response is paginated, and by default, returns 20 policies per page.
+ *
+ * @param pageSize - The number of resources to return per page.
+ * @param pageToken - The token for the next page of resources, if any.
+ * @param scope - The scope of the policies to return. If `project`, the response will include exactly one policy, which is the project-level policy. If `account`, the response will include all account-level policies for the developer's CDP Project.
+ */
+export const listPolicies = /*@__PURE__*/ /*#__PURE__*/ API.make(() => ({
+  inputSchema: ListPoliciesInput,
+  outputSchema: ListPoliciesOutput,
+}));

package/src/operations/listSolanaAccounts.ts

@@ -0,0 +1,43 @@
+import * as Schema from "effect/Schema";
+import { API } from "../client";
+import * as T from "../traits";
+
+// Input Schema
+export const ListSolanaAccountsInput =
+  /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
+    pageSize: Schema.optional(Schema.Number),
+    pageToken: Schema.optional(Schema.String),
+  }).pipe(T.Http({ method: "GET", path: "/v2/solana/accounts" }));
+export type ListSolanaAccountsInput = typeof ListSolanaAccountsInput.Type;
+
+// Output Schema
+export const ListSolanaAccountsOutput =
+  /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
+    accounts: Schema.Array(
+      Schema.Struct({
+        address: Schema.String,
+        name: Schema.optional(Schema.String),
+        policies: Schema.optional(Schema.Array(Schema.String)),
+        createdAt: Schema.optional(Schema.String),
+        updatedAt: Schema.optional(Schema.String),
+      }),
+    ),
+    nextPageToken: Schema.optional(Schema.String),
+  });
+export type ListSolanaAccountsOutput = typeof ListSolanaAccountsOutput.Type;
+
+// The operation
+/**
+ * List Solana accounts or get account by name
+ *
+ * Lists the Solana accounts belonging to the developer.
+ * The response is paginated, and by default, returns 20 accounts per page.
+ * If a name is provided, the response will contain only the account with that name.
+ *
+ * @param pageSize - The number of resources to return per page.
+ * @param pageToken - The token for the next page of resources, if any.
+ */
+export const listSolanaAccounts = /*@__PURE__*/ /*#__PURE__*/ API.make(() => ({
+  inputSchema: ListSolanaAccountsInput,
+  outputSchema: ListSolanaAccountsOutput,
+}));

package/src/operations/listSolanaTokenBalances.ts

@@ -0,0 +1,59 @@
+import * as Schema from "effect/Schema";
+import { API } from "../client";
+import * as T from "../traits";
+
+// Input Schema
+export const ListSolanaTokenBalancesInput =
+  /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
+    address: Schema.String.pipe(T.PathParam()),
+    network: Schema.String.pipe(T.PathParam()),
+    pageSize: Schema.optional(Schema.Number),
+    pageToken: Schema.optional(Schema.String),
+  }).pipe(
+    T.Http({
+      method: "GET",
+      path: "/v2/solana/token-balances/{network}/{address}",
+    }),
+  );
+export type ListSolanaTokenBalancesInput =
+  typeof ListSolanaTokenBalancesInput.Type;
+
+// Output Schema
+export const ListSolanaTokenBalancesOutput =
+  /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
+    balances: Schema.Array(
+      Schema.Struct({
+        amount: Schema.Struct({
+          amount: Schema.String,
+          decimals: Schema.Number,
+        }),
+        token: Schema.Struct({
+          symbol: Schema.optional(Schema.String),
+          name: Schema.optional(Schema.String),
+          mintAddress: Schema.String,
+        }),
+      }),
+    ),
+    nextPageToken: Schema.optional(Schema.String),
+  });
+export type ListSolanaTokenBalancesOutput =
+  typeof ListSolanaTokenBalancesOutput.Type;
+
+// The operation
+/**
+ * List Solana token balances
+ *
+ * Lists the token balances of a Solana address on a given network. The balances include SPL tokens and the native SOL token. The response is paginated, and by default, returns 20 balances per page.
+ * **Note:** This endpoint is still under development and does not yet provide strong availability or freshness guarantees. Freshness and availability of new token balances will improve over the coming weeks.
+ *
+ * @param address - The base58 encoded Solana address to get balances for.
+ * @param network - The human-readable network name to get the balances for.
+ * @param pageSize - The number of balances to return per page.
+ * @param pageToken - The token for the next page of balances. Will be empty if there are no more balances to fetch.
+ */
+export const listSolanaTokenBalances = /*@__PURE__*/ /*#__PURE__*/ API.make(
+  () => ({
+    inputSchema: ListSolanaTokenBalancesInput,
+    outputSchema: ListSolanaTokenBalancesOutput,
+  }),
+);

package/src/operations/listSpendPermissions.ts

@@ -0,0 +1,70 @@
+import * as Schema from "effect/Schema";
+import { API } from "../client";
+import * as T from "../traits";
+
+// Input Schema
+export const ListSpendPermissionsInput =
+  /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
+    address: Schema.String.pipe(T.PathParam()),
+    pageSize: Schema.optional(Schema.Number),
+    pageToken: Schema.optional(Schema.String),
+  }).pipe(
+    T.Http({
+      method: "GET",
+      path: "/v2/evm/smart-accounts/{address}/spend-permissions/list",
+    }),
+  );
+export type ListSpendPermissionsInput = typeof ListSpendPermissionsInput.Type;
+
+// Output Schema
+export const ListSpendPermissionsOutput =
+  /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
+    spendPermissions: Schema.Array(
+      Schema.Struct({
+        permission: Schema.Struct({
+          account: Schema.String,
+          spender: Schema.String,
+          token: Schema.String,
+          allowance: Schema.String,
+          period: Schema.String,
+          start: Schema.String,
+          end: Schema.String,
+          salt: Schema.String,
+          extraData: Schema.String,
+        }),
+        permissionHash: Schema.String,
+        revoked: Schema.Boolean,
+        revokedAt: Schema.optional(Schema.String),
+        createdAt: Schema.String,
+        network: Schema.Literals([
+          "base",
+          "base-sepolia",
+          "ethereum",
+          "ethereum-sepolia",
+          "optimism",
+          "arbitrum",
+          "avalanche",
+          "polygon",
+        ]),
+      }),
+    ),
+    nextPageToken: Schema.optional(Schema.String),
+  });
+export type ListSpendPermissionsOutput = typeof ListSpendPermissionsOutput.Type;
+
+// The operation
+/**
+ * List spend permissions
+ *
+ * Lists spend permission for the given smart account address.
+ *
+ * @param address - The address of the Smart account to list spend permissions for.
+ * @param pageSize - The number of spend permissions to return per page.
+ * @param pageToken - The token for the next page of spend permissions. Will be empty if there are no more spend permissions to fetch.
+ */
+export const listSpendPermissions = /*@__PURE__*/ /*#__PURE__*/ API.make(
+  () => ({
+    inputSchema: ListSpendPermissionsInput,
+    outputSchema: ListSpendPermissionsOutput,
+  }),
+);

package/src/operations/listTokensForAccount.ts

@@ -0,0 +1,42 @@
+import * as Schema from "effect/Schema";
+import { API } from "../client";
+import * as T from "../traits";
+
+// Input Schema
+export const ListTokensForAccountInput =
+  /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
+    network: Schema.Literals(["base", "base-sepolia"]).pipe(T.PathParam()),
+    address: Schema.String.pipe(T.PathParam()),
+  }).pipe(
+    T.Http({
+      method: "GET",
+      path: "/v2/data/evm/token-ownership/{network}/{address}",
+    }),
+  );
+export type ListTokensForAccountInput = typeof ListTokensForAccountInput.Type;
+
+// Output Schema
+export const ListTokensForAccountOutput =
+  /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
+    accountAddress: Schema.optional(Schema.String),
+    tokenAddresses: Schema.optional(Schema.Array(Schema.String)),
+    totalCount: Schema.optional(Schema.Number),
+  });
+export type ListTokensForAccountOutput = typeof ListTokensForAccountOutput.Type;
+
+// The operation
+/**
+ * List token addresses for account
+ *
+ * Retrieve all ERC-20 token contract addresses that an account has ever received tokens from.
+ * Analyzes transaction history to discover token interactions.
+ *
+ * @param network - The blockchain network to query.
+ * @param address - The account address to analyze for token interactions.
+ */
+export const listTokensForAccount = /*@__PURE__*/ /*#__PURE__*/ API.make(
+  () => ({
+    inputSchema: ListTokensForAccountInput,
+    outputSchema: ListTokensForAccountOutput,
+  }),
+);

package/src/operations/listWebhookSubscriptions.ts

@@ -0,0 +1,62 @@
+import * as Schema from "effect/Schema";
+import { API } from "../client";
+import * as T from "../traits";
+
+// Input Schema
+export const ListWebhookSubscriptionsInput =
+  /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
+    pageSize: Schema.optional(Schema.Number),
+    pageToken: Schema.optional(Schema.String),
+  }).pipe(T.Http({ method: "GET", path: "/v2/data/webhooks/subscriptions" }));
+export type ListWebhookSubscriptionsInput =
+  typeof ListWebhookSubscriptionsInput.Type;
+
+// Output Schema
+export const ListWebhookSubscriptionsOutput =
+  /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
+    subscriptions: Schema.Array(
+      Schema.Struct({
+        createdAt: Schema.String,
+        description: Schema.optional(Schema.Struct({})),
+        eventTypes: Schema.Array(Schema.String),
+        isEnabled: Schema.Boolean,
+        metadata: Schema.optional(
+          Schema.Struct({
+            secret: Schema.optional(Schema.String),
+          }),
+        ),
+        secret: Schema.String,
+        subscriptionId: Schema.String,
+        target: Schema.Struct({
+          url: Schema.Struct({}),
+          headers: Schema.optional(Schema.Record(Schema.String, Schema.String)),
+        }),
+        labels: Schema.optional(Schema.Record(Schema.String, Schema.String)),
+      }),
+    ),
+    nextPageToken: Schema.optional(Schema.String),
+  });
+export type ListWebhookSubscriptionsOutput =
+  typeof ListWebhookSubscriptionsOutput.Type;
+
+// The operation
+/**
+ * List webhook subscriptions
+ *
+ * Retrieve a paginated list of webhook subscriptions for the authenticated project.
+ * Returns subscriptions for all CDP product events (onchain, onramp/offramp, wallet, etc.)
+ * in descending order by creation time.
+ * ### Use Cases
+ * - Monitor all active webhook subscriptions across CDP products
+ * - Audit webhook configurations
+ * - Manage subscription lifecycle
+ *
+ * @param pageSize - The number of subscriptions to return per page.
+ * @param pageToken - The token for the next page of subscriptions, if any.
+ */
+export const listWebhookSubscriptions = /*@__PURE__*/ /*#__PURE__*/ API.make(
+  () => ({
+    inputSchema: ListWebhookSubscriptionsInput,
+    outputSchema: ListWebhookSubscriptionsOutput,
+  }),
+);