@distilled.cloud/coinbase 0.30.2 → 1.0.0-rc.1

package/src/operations/deleteWebhookSubscription.ts

@@ -1,40 +0,0 @@
-import * as Schema from "effect/Schema";
-import { API } from "../client.ts";
-import * as T from "../traits.ts";
-
-// Input Schema
-export interface DeleteWebhookSubscriptionInput {
-  subscriptionId: string;
-}
-export const DeleteWebhookSubscriptionInput =
-  /*@__PURE__*/ Schema.Struct({
-    subscriptionId: Schema.String.pipe(T.PathParam()),
-  }).pipe(
-    T.Http({
-      method: "DELETE",
-      path: "/v2/data/webhooks/subscriptions/{subscriptionId}",
-    }),
-  ) as unknown as Schema.Codec<DeleteWebhookSubscriptionInput>;
-
-// Output Schema
-export type DeleteWebhookSubscriptionOutput = void;
-export const DeleteWebhookSubscriptionOutput =
-  /*@__PURE__*/ Schema.Void as unknown as Schema.Codec<DeleteWebhookSubscriptionOutput>;
-
-// The operation
-/**
- * Delete webhook subscription
- *
- * Permanently delete a webhook subscription and stop all event deliveries.
- * This action cannot be undone.
- * ### Important Notes
- * - All webhook deliveries will cease immediately
- * - Subscription cannot be recovered after deletion
- * - Consider disabling instead of deleting for temporary pauses
- *
- * @param subscriptionId - Unique identifier for the webhook subscription.
- */
-export const deleteWebhookSubscription = /*@__PURE__*/ API.make(() => ({
-  inputSchema: DeleteWebhookSubscriptionInput,
-  outputSchema: DeleteWebhookSubscriptionOutput,
-}));

package/src/operations/executeFundTransfer.ts

@@ -1,282 +0,0 @@
-import * as Schema from "effect/Schema";
-import { API } from "../client.ts";
-import * as T from "../traits.ts";
-
-// Input Schema
-export interface ExecuteFundTransferInput {
-  transferId: string;
-}
-export const ExecuteFundTransferInput =
-  /*@__PURE__*/ Schema.Struct({
-    transferId: Schema.String.pipe(T.PathParam()),
-  }).pipe(
-    T.Http({ method: "POST", path: "/v2/transfers/{transferId}/execute" }),
-  ) as unknown as Schema.Codec<ExecuteFundTransferInput>;
-
-// Output Schema
-export interface ExecuteFundTransferOutput {
-  transferId?: string;
-  status?: "quoted" | "processing" | "completed" | "failed";
-  source:
-    | { accountId: string; asset: string }
-    | { paymentMethodId: string; asset: string }
-    | {
-        address: string;
-        network:
-          | "base"
-          | "ethereum"
-          | "solana"
-          | "aptos"
-          | "arbitrum"
-          | "arbitrum-sepolia"
-          | "optimism"
-          | "polygon"
-          | "world"
-          | "world-sepolia";
-        destinationTag?: string;
-        asset: string;
-      }
-    | { bankName: string; accountLast4: string; currency: string };
-  target:
-    | { accountId: string; asset: string }
-    | { paymentMethodId: string; asset: string }
-    | {
-        address: string;
-        network:
-          | "base"
-          | "ethereum"
-          | "solana"
-          | "aptos"
-          | "arbitrum"
-          | "arbitrum-sepolia"
-          | "optimism"
-          | "polygon"
-          | "world"
-          | "world-sepolia";
-        destinationTag?: string;
-        asset: string;
-      }
-    | { email: string; asset: string };
-  sourceAmount?: string;
-  sourceAsset?: string;
-  targetAmount?: string;
-  targetAsset?: string;
-  exchangeRate?: { sourceAsset: string; targetAsset: string; rate: string };
-  fees?: {
-    type: "bank" | "conversion" | "network" | "other";
-    amount: string;
-    asset: string;
-  }[];
-  estimate?: {
-    exchangeRate?: { sourceAsset: string; targetAsset: string; rate: string };
-    targetAmount?: string;
-    targetAsset?: string;
-    fees?: {
-      type: "bank" | "conversion" | "network" | "other";
-      amount: string;
-      asset: string;
-    }[];
-    estimatedAt: string;
-  };
-  completedAt?: string;
-  failureReason?: string;
-  expiresAt?: string;
-  executedAt?: string;
-  createdAt?: string;
-  updatedAt?: string;
-  metadata?: Record<string, string>;
-  details?: {
-    depositDestination?: { id: string };
-    onchainTransactions?: {
-      transactionHash: string;
-      network:
-        | "base"
-        | "ethereum"
-        | "solana"
-        | "aptos"
-        | "arbitrum"
-        | "arbitrum-sepolia"
-        | "optimism"
-        | "polygon"
-        | "world"
-        | "world-sepolia";
-    }[];
-    travelRule?: {
-      status?: "incomplete" | "completed";
-      statusMessage?: string;
-    };
-  };
-}
-export const ExecuteFundTransferOutput =
-  /*@__PURE__*/ Schema.Struct({
-    transferId: Schema.optional(Schema.String),
-    status: Schema.optional(
-      Schema.Literals(["quoted", "processing", "completed", "failed"]),
-    ),
-    source: Schema.Union([
-      Schema.Struct({
-        accountId: Schema.String,
-        asset: Schema.String,
-      }),
-      Schema.Struct({
-        paymentMethodId: Schema.String,
-        asset: Schema.String,
-      }),
-      Schema.Struct({
-        address: Schema.String,
-        network: Schema.Literals([
-          "base",
-          "ethereum",
-          "solana",
-          "aptos",
-          "arbitrum",
-          "arbitrum-sepolia",
-          "optimism",
-          "polygon",
-          "world",
-          "world-sepolia",
-        ]),
-        destinationTag: Schema.optional(Schema.String),
-        asset: Schema.String,
-      }),
-      Schema.Struct({
-        bankName: Schema.String,
-        accountLast4: Schema.String,
-        currency: Schema.String,
-      }),
-    ]),
-    target: Schema.Union([
-      Schema.Struct({
-        accountId: Schema.String,
-        asset: Schema.String,
-      }),
-      Schema.Struct({
-        paymentMethodId: Schema.String,
-        asset: Schema.String,
-      }),
-      Schema.Struct({
-        address: Schema.String,
-        network: Schema.Literals([
-          "base",
-          "ethereum",
-          "solana",
-          "aptos",
-          "arbitrum",
-          "arbitrum-sepolia",
-          "optimism",
-          "polygon",
-          "world",
-          "world-sepolia",
-        ]),
-        destinationTag: Schema.optional(Schema.String),
-        asset: Schema.String,
-      }),
-      Schema.Struct({
-        email: Schema.String,
-        asset: Schema.String,
-      }),
-    ]),
-    sourceAmount: Schema.optional(Schema.String),
-    sourceAsset: Schema.optional(Schema.String),
-    targetAmount: Schema.optional(Schema.String),
-    targetAsset: Schema.optional(Schema.String),
-    exchangeRate: Schema.optional(
-      Schema.Struct({
-        sourceAsset: Schema.String,
-        targetAsset: Schema.String,
-        rate: Schema.String,
-      }),
-    ),
-    fees: Schema.optional(
-      Schema.Array(
-        Schema.Struct({
-          type: Schema.Literals(["bank", "conversion", "network", "other"]),
-          amount: Schema.String,
-          asset: Schema.String,
-        }),
-      ),
-    ),
-    estimate: Schema.optional(
-      Schema.Struct({
-        exchangeRate: Schema.optional(
-          Schema.Struct({
-            sourceAsset: Schema.String,
-            targetAsset: Schema.String,
-            rate: Schema.String,
-          }),
-        ),
-        targetAmount: Schema.optional(Schema.String),
-        targetAsset: Schema.optional(Schema.String),
-        fees: Schema.optional(
-          Schema.Array(
-            Schema.Struct({
-              type: Schema.Literals(["bank", "conversion", "network", "other"]),
-              amount: Schema.String,
-              asset: Schema.String,
-            }),
-          ),
-        ),
-        estimatedAt: Schema.String,
-      }),
-    ),
-    completedAt: Schema.optional(Schema.String),
-    failureReason: Schema.optional(Schema.String),
-    expiresAt: Schema.optional(Schema.String),
-    executedAt: Schema.optional(Schema.String),
-    createdAt: Schema.optional(Schema.String),
-    updatedAt: Schema.optional(Schema.String),
-    metadata: Schema.optional(Schema.Record(Schema.String, Schema.String)),
-    details: Schema.optional(
-      Schema.Struct({
-        depositDestination: Schema.optional(
-          Schema.Struct({
-            id: Schema.String,
-          }),
-        ),
-        onchainTransactions: Schema.optional(
-          Schema.Array(
-            Schema.Struct({
-              transactionHash: Schema.String,
-              network: Schema.Literals([
-                "base",
-                "ethereum",
-                "solana",
-                "aptos",
-                "arbitrum",
-                "arbitrum-sepolia",
-                "optimism",
-                "polygon",
-                "world",
-                "world-sepolia",
-              ]),
-            }),
-          ),
-        ),
-        travelRule: Schema.optional(
-          Schema.Struct({
-            status: Schema.optional(
-              Schema.Literals(["incomplete", "completed"]),
-            ),
-            statusMessage: Schema.optional(Schema.String),
-          }),
-        ),
-      }),
-    ),
-  }) as unknown as Schema.Codec<ExecuteFundTransferOutput>;
-
-// The operation
-/**
- * Execute transfer
- *
- * Executes a transfer which was created using the Create a transfer endpoint.
- *
- * @param transferId - The ID of the transfer.
- * @param X-Idempotency-Key - An optional string request header for making requests safely retryable.
-When included, duplicate requests with the same key will return identical responses.
-Refer to our [Idempotency docs](https://docs.cdp.coinbase.com/api-reference/v2/idempotency) for more information on using idempotency keys.
-
- */
-export const executeFundTransfer = /*@__PURE__*/ API.make(() => ({
-  inputSchema: ExecuteFundTransferInput,
-  outputSchema: ExecuteFundTransferOutput,
-}));

package/src/operations/exportEvmAccount.ts

@@ -1,44 +0,0 @@
-import * as Schema from "effect/Schema";
-import { API } from "../client.ts";
-import * as T from "../traits.ts";
-
-// Input Schema
-export interface ExportEvmAccountInput {
-  address: string;
-  exportEncryptionKey: string;
-}
-export const ExportEvmAccountInput = /*@__PURE__*/ Schema.Struct({
-  address: Schema.String.pipe(T.PathParam()),
-  exportEncryptionKey: Schema.String,
-}).pipe(
-  T.Http({ method: "POST", path: "/v2/evm/accounts/{address}/export" }),
-) as unknown as Schema.Codec<ExportEvmAccountInput>;
-
-// Output Schema
-export interface ExportEvmAccountOutput {
-  encryptedPrivateKey: string;
-}
-export const ExportEvmAccountOutput = /*@__PURE__*/ Schema.Struct({
-  encryptedPrivateKey: Schema.String,
-}) as unknown as Schema.Codec<ExportEvmAccountOutput>;
-
-// The operation
-/**
- * Export EVM account
- *
- * Export an existing EVM account's private key. It is important to store the private key in a secure place after it's exported.
- *
- * @param X-Wallet-Auth - A JWT signed using your Wallet Secret, encoded in base64. Refer to the
-[Generate Wallet Token](https://docs.cdp.coinbase.com/api-reference/v2/authentication#2-generate-wallet-token)
-section of our Authentication docs for more details on how to generate your Wallet Token.
-
- * @param X-Idempotency-Key - An optional string request header for making requests safely retryable.
-When included, duplicate requests with the same key will return identical responses.
-Refer to our [Idempotency docs](https://docs.cdp.coinbase.com/api-reference/v2/idempotency) for more information on using idempotency keys.
-
- * @param address - The 0x-prefixed address of the EVM account. The address does not need to be checksummed.
- */
-export const exportEvmAccount = /*@__PURE__*/ API.make(() => ({
-  inputSchema: ExportEvmAccountInput,
-  outputSchema: ExportEvmAccountOutput,
-}));

package/src/operations/exportEvmAccountByName.ts

@@ -1,46 +0,0 @@
-import * as Schema from "effect/Schema";
-import { API } from "../client.ts";
-import * as T from "../traits.ts";
-
-// Input Schema
-export interface ExportEvmAccountByNameInput {
-  name: string;
-  exportEncryptionKey: string;
-}
-export const ExportEvmAccountByNameInput =
-  /*@__PURE__*/ Schema.Struct({
-    name: Schema.String.pipe(T.PathParam()),
-    exportEncryptionKey: Schema.String,
-  }).pipe(
-    T.Http({ method: "POST", path: "/v2/evm/accounts/export/by-name/{name}" }),
-  ) as unknown as Schema.Codec<ExportEvmAccountByNameInput>;
-
-// Output Schema
-export interface ExportEvmAccountByNameOutput {
-  encryptedPrivateKey: string;
-}
-export const ExportEvmAccountByNameOutput =
-  /*@__PURE__*/ Schema.Struct({
-    encryptedPrivateKey: Schema.String,
-  }) as unknown as Schema.Codec<ExportEvmAccountByNameOutput>;
-
-// The operation
-/**
- * Export EVM account by name
- *
- * Export an existing EVM account's private key by its name. It is important to store the private key in a secure place after it's exported.
- *
- * @param X-Wallet-Auth - A JWT signed using your Wallet Secret, encoded in base64. Refer to the
-[Generate Wallet Token](https://docs.cdp.coinbase.com/api-reference/v2/authentication#2-generate-wallet-token)
-section of our Authentication docs for more details on how to generate your Wallet Token.
-
- * @param X-Idempotency-Key - An optional string request header for making requests safely retryable.
-When included, duplicate requests with the same key will return identical responses.
-Refer to our [Idempotency docs](https://docs.cdp.coinbase.com/api-reference/v2/idempotency) for more information on using idempotency keys.
-
- * @param name - The name of the EVM account.
- */
-export const exportEvmAccountByName = /*@__PURE__*/ API.make(() => ({
-  inputSchema: ExportEvmAccountByNameInput,
-  outputSchema: ExportEvmAccountByNameOutput,
-}));

package/src/operations/exportSolanaAccount.ts

@@ -1,46 +0,0 @@
-import * as Schema from "effect/Schema";
-import { API } from "../client.ts";
-import * as T from "../traits.ts";
-
-// Input Schema
-export interface ExportSolanaAccountInput {
-  address: string;
-  exportEncryptionKey: string;
-}
-export const ExportSolanaAccountInput =
-  /*@__PURE__*/ Schema.Struct({
-    address: Schema.String.pipe(T.PathParam()),
-    exportEncryptionKey: Schema.String,
-  }).pipe(
-    T.Http({ method: "POST", path: "/v2/solana/accounts/{address}/export" }),
-  ) as unknown as Schema.Codec<ExportSolanaAccountInput>;
-
-// Output Schema
-export interface ExportSolanaAccountOutput {
-  encryptedPrivateKey: string;
-}
-export const ExportSolanaAccountOutput =
-  /*@__PURE__*/ Schema.Struct({
-    encryptedPrivateKey: Schema.String,
-  }) as unknown as Schema.Codec<ExportSolanaAccountOutput>;
-
-// The operation
-/**
- * Export Solana account
- *
- * Export an existing Solana account's private key. It is important to store the private key in a secure place after it's exported.
- *
- * @param X-Wallet-Auth - A JWT signed using your Wallet Secret, encoded in base64. Refer to the
-[Generate Wallet Token](https://docs.cdp.coinbase.com/api-reference/v2/authentication#2-generate-wallet-token)
-section of our Authentication docs for more details on how to generate your Wallet Token.
-
- * @param X-Idempotency-Key - An optional string request header for making requests safely retryable.
-When included, duplicate requests with the same key will return identical responses.
-Refer to our [Idempotency docs](https://docs.cdp.coinbase.com/api-reference/v2/idempotency) for more information on using idempotency keys.
-
- * @param address - The base58 encoded address of the Solana account.
- */
-export const exportSolanaAccount = /*@__PURE__*/ API.make(() => ({
-  inputSchema: ExportSolanaAccountInput,
-  outputSchema: ExportSolanaAccountOutput,
-}));

package/src/operations/exportSolanaAccountByName.ts

@@ -1,49 +0,0 @@
-import * as Schema from "effect/Schema";
-import { API } from "../client.ts";
-import * as T from "../traits.ts";
-
-// Input Schema
-export interface ExportSolanaAccountByNameInput {
-  name: string;
-  exportEncryptionKey: string;
-}
-export const ExportSolanaAccountByNameInput =
-  /*@__PURE__*/ Schema.Struct({
-    name: Schema.String.pipe(T.PathParam()),
-    exportEncryptionKey: Schema.String,
-  }).pipe(
-    T.Http({
-      method: "POST",
-      path: "/v2/solana/accounts/export/by-name/{name}",
-    }),
-  ) as unknown as Schema.Codec<ExportSolanaAccountByNameInput>;
-
-// Output Schema
-export interface ExportSolanaAccountByNameOutput {
-  encryptedPrivateKey: string;
-}
-export const ExportSolanaAccountByNameOutput =
-  /*@__PURE__*/ Schema.Struct({
-    encryptedPrivateKey: Schema.String,
-  }) as unknown as Schema.Codec<ExportSolanaAccountByNameOutput>;
-
-// The operation
-/**
- * Export Solana account by name
- *
- * Export an existing Solana account's private key by its name. It is important to store the private key in a secure place after it's exported.
- *
- * @param X-Wallet-Auth - A JWT signed using your Wallet Secret, encoded in base64. Refer to the
-[Generate Wallet Token](https://docs.cdp.coinbase.com/api-reference/v2/authentication#2-generate-wallet-token)
-section of our Authentication docs for more details on how to generate your Wallet Token.
-
- * @param X-Idempotency-Key - An optional string request header for making requests safely retryable.
-When included, duplicate requests with the same key will return identical responses.
-Refer to our [Idempotency docs](https://docs.cdp.coinbase.com/api-reference/v2/idempotency) for more information on using idempotency keys.
-
- * @param name - The name of the Solana account.
- */
-export const exportSolanaAccountByName = /*@__PURE__*/ API.make(() => ({
-  inputSchema: ExportSolanaAccountByNameInput,
-  outputSchema: ExportSolanaAccountByNameOutput,
-}));

package/src/operations/getBalanceByAsset.ts

@@ -1,56 +0,0 @@
-import * as Schema from "effect/Schema";
-import { API } from "../client.ts";
-import * as T from "../traits.ts";
-
-// Input Schema
-export interface GetBalanceByAssetInput {
-  accountId: string;
-  asset: string;
-}
-export const GetBalanceByAssetInput = /*@__PURE__*/ Schema.Struct({
-  accountId: Schema.String.pipe(T.PathParam()),
-  asset: Schema.String.pipe(T.PathParam()),
-}).pipe(
-  T.Http({ method: "GET", path: "/v2/accounts/{accountId}/balances/{asset}" }),
-) as unknown as Schema.Codec<GetBalanceByAssetInput>;
-
-// Output Schema
-export interface GetBalanceByAssetOutput {
-  asset: {
-    symbol: string;
-    type: "fiat" | "crypto";
-    name: string;
-    decimals: number;
-  };
-  amount: Record<string, { available: string; total: string }>;
-}
-export const GetBalanceByAssetOutput =
-  /*@__PURE__*/ Schema.Struct({
-    asset: Schema.Struct({
-      symbol: Schema.String,
-      type: Schema.Literals(["fiat", "crypto"]),
-      name: Schema.String,
-      decimals: Schema.Number,
-    }),
-    amount: Schema.Record(
-      Schema.String,
-      Schema.Struct({
-        available: Schema.String,
-        total: Schema.String,
-      }),
-    ),
-  }) as unknown as Schema.Codec<GetBalanceByAssetOutput>;
-
-// The operation
-/**
- * Get balance for account
- *
- * Get the balance for an account by asset.
- *
- * @param accountId - The unique identifier of the account.
- * @param asset - The symbol of the asset.
- */
-export const getBalanceByAsset = /*@__PURE__*/ API.make(() => ({
-  inputSchema: GetBalanceByAssetInput,
-  outputSchema: GetBalanceByAssetOutput,
-}));

package/src/operations/getDelegationForEndUser.ts

@@ -1,42 +0,0 @@
-import * as Schema from "effect/Schema";
-import { API } from "../client.ts";
-import * as T from "../traits.ts";
-
-// Input Schema
-export interface GetDelegationForEndUserInput {
-  userId: string;
-  projectID?: string;
-}
-export const GetDelegationForEndUserInput =
-  /*@__PURE__*/ Schema.Struct({
-    userId: Schema.String.pipe(T.PathParam()),
-    projectID: Schema.optional(Schema.String),
-  }).pipe(
-    T.Http({
-      method: "GET",
-      path: "/v2/embedded-wallet-api/end-users/{userId}/delegation",
-    }),
-  ) as unknown as Schema.Codec<GetDelegationForEndUserInput>;
-
-// Output Schema
-export interface GetDelegationForEndUserOutput {
-  expiresAt: string;
-}
-export const GetDelegationForEndUserOutput =
-  /*@__PURE__*/ Schema.Struct({
-    expiresAt: Schema.String,
-  }) as unknown as Schema.Codec<GetDelegationForEndUserOutput>;
-
-// The operation
-/**
- * Get delegation for end user
- *
- * Returns the active delegation for the specified end user, if one exists. This operation can be performed by the end user themselves or by a developer using their API key.
- *
- * @param userId - The ID of the end user.
- * @param projectID - The ID of the CDP Project. Required for end users authenticated using custom auth (i.e. a non-CDP JWT provider).
- */
-export const getDelegationForEndUser = /*@__PURE__*/ API.make(() => ({
-  inputSchema: GetDelegationForEndUserInput,
-  outputSchema: GetDelegationForEndUserOutput,
-}));

package/src/operations/getDelegationForEndUserAccount.ts

@@ -1,47 +0,0 @@
-import * as Schema from "effect/Schema";
-import { API } from "../client.ts";
-import * as T from "../traits.ts";
-
-// Input Schema
-export interface GetDelegationForEndUserAccountInput {
-  userId: string;
-  address: string;
-  projectID?: string;
-}
-export const GetDelegationForEndUserAccountInput =
-  /*@__PURE__*/ Schema.Struct({
-    userId: Schema.String.pipe(T.PathParam()),
-    address: Schema.String.pipe(T.PathParam()),
-    projectID: Schema.optional(Schema.String),
-  }).pipe(
-    T.Http({
-      method: "GET",
-      path: "/v2/embedded-wallet-api/end-users/{userId}/address/{address}/delegation",
-    }),
-  ) as unknown as Schema.Codec<GetDelegationForEndUserAccountInput>;
-
-// Output Schema
-export interface GetDelegationForEndUserAccountOutput {
-  expiresAt: string;
-}
-export const GetDelegationForEndUserAccountOutput =
-  /*@__PURE__*/ Schema.Struct({
-    expiresAt: Schema.String,
-  }) as unknown as Schema.Codec<GetDelegationForEndUserAccountOutput>;
-
-// The operation
-/**
- * Get account-scoped delegation for end user
- *
- * Returns the active account-scoped delegation for the specified end user account, if one exists. Useful for showing delegation status in a UI.
- * When the address corresponds to an EVM Smart Account, this returns the delegation for the Smart Account's owner EOA.
- *
- * @param userId - The ID of the end user.
- * @param address - The blockchain address of the end user account to query. For EVM addresses, matching is case-insensitive.
- * @param projectID - The ID of the CDP Project. Required for end users authenticated using custom auth (i.e. a non-CDP JWT provider).
- */
-export const getDelegationForEndUserAccount =
-  /*@__PURE__*/ API.make(() => ({
-    inputSchema: GetDelegationForEndUserAccountInput,
-    outputSchema: GetDelegationForEndUserAccountOutput,
-  }));