@distilled.cloud/coinbase 0.27.0 → 0.28.0

package/src/operations/getWebhookSubscription.ts

@@ -1,9 +1,13 @@
 import * as Schema from "effect/Schema";
 import { API } from "../client.ts";
 import * as T from "../traits.ts";
-import { SensitiveString } from "../sensitive.ts";
+import { SensitiveOutputString } from "../sensitive.ts";
+import * as Redacted from "effect/Redacted";
 
 // Input Schema
+export interface GetWebhookSubscriptionInput {
+  subscriptionId: string;
+}
 export const GetWebhookSubscriptionInput =
   /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
     subscriptionId: Schema.String.pipe(T.PathParam()),
@@ -12,37 +16,95 @@ export const GetWebhookSubscriptionInput =
       method: "GET",
       path: "/v2/data/webhooks/subscriptions/{subscriptionId}",
     }),
-  );
-export type GetWebhookSubscriptionInput =
-  typeof GetWebhookSubscriptionInput.Type;
+  ) as unknown as Schema.Codec<GetWebhookSubscriptionInput>;
 
 // Output Schema
+export interface GetWebhookSubscriptionOutput {
+  createdAt: string;
+  updatedAt?: string;
+  description?: string;
+  eventTypes: (
+    | "onchain.activity.detected"
+    | "wallet.activity.detected"
+    | "wallet.activity.multi"
+    | "wallet.transaction.created"
+    | "wallet.transaction.signed"
+    | "wallet.transaction.broadcast"
+    | "wallet.transaction.replaced"
+    | "wallet.transaction.pending"
+    | "wallet.transaction.confirmed"
+    | "wallet.transaction.failed"
+    | "wallet.delegation.created"
+    | "wallet.delegation.revoked"
+    | "wallet.typed_data.signed"
+    | "wallet.message.signed"
+    | "wallet.hash.signed"
+    | "onramp.transaction.created"
+    | "onramp.transaction.updated"
+    | "onramp.transaction.success"
+    | "onramp.transaction.failed"
+    | "offramp.transaction.created"
+    | "offramp.transaction.updated"
+    | "offramp.transaction.success"
+    | "offramp.transaction.failed"
+  )[];
+  isEnabled: boolean;
+  metadata?: { secret?: Redacted.Redacted<string> };
+  secret: Redacted.Redacted<string>;
+  subscriptionId: string;
+  target: { url: string; headers?: Record<string, string> };
+  labels?: Record<string, string>;
+}
 export const GetWebhookSubscriptionOutput =
   /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
     createdAt: Schema.String,
     updatedAt: Schema.optional(Schema.String),
     description: Schema.optional(Schema.String),
-    eventTypes: Schema.Array(Schema.String),
+    eventTypes: Schema.Array(
+      Schema.Literals([
+        "onchain.activity.detected",
+        "wallet.activity.detected",
+        "wallet.activity.multi",
+        "wallet.transaction.created",
+        "wallet.transaction.signed",
+        "wallet.transaction.broadcast",
+        "wallet.transaction.replaced",
+        "wallet.transaction.pending",
+        "wallet.transaction.confirmed",
+        "wallet.transaction.failed",
+        "wallet.delegation.created",
+        "wallet.delegation.revoked",
+        "wallet.typed_data.signed",
+        "wallet.message.signed",
+        "wallet.hash.signed",
+        "onramp.transaction.created",
+        "onramp.transaction.updated",
+        "onramp.transaction.success",
+        "onramp.transaction.failed",
+        "offramp.transaction.created",
+        "offramp.transaction.updated",
+        "offramp.transaction.success",
+        "offramp.transaction.failed",
+      ]),
+    ),
     isEnabled: Schema.Boolean,
     metadata: Schema.optional(
       Schema.Struct({
-        secret: Schema.optional(SensitiveString),
+        secret: Schema.optional(SensitiveOutputString),
       }),
     ),
-    secret: SensitiveString,
+    secret: SensitiveOutputString,
     subscriptionId: Schema.String,
     target: Schema.Struct({
       url: Schema.String,
       headers: Schema.optional(Schema.Record(Schema.String, Schema.String)),
     }),
     labels: Schema.optional(Schema.Record(Schema.String, Schema.String)),
-  });
-export type GetWebhookSubscriptionOutput =
-  typeof GetWebhookSubscriptionOutput.Type;
+  }) as unknown as Schema.Codec<GetWebhookSubscriptionOutput>;
 
 // The operation
 /**
- * Get webhook subscription details
+ * Get webhook subscription
  *
  * Retrieve detailed information about a specific webhook subscription including
  * configuration, status, creation timestamp, and webhook signature secret.

package/src/operations/importEndUser.ts

@@ -3,18 +3,159 @@ import { API } from "../client.ts";
 import * as T from "../traits.ts";
 
 // Input Schema
+export interface ImportEndUserInput {
+  userId: string;
+  authenticationMethods: (
+    | { type: "email"; email: string }
+    | { type: "sms"; phoneNumber: string }
+    | { type: "jwt"; kid: string; sub: string }
+    | {
+        type: "google" | "apple" | "x" | "telegram" | "github";
+        sub: string;
+        email?: string;
+        name?: string;
+        username?: string;
+      }
+    | {
+        type: "google" | "apple" | "x" | "telegram" | "github";
+        id: number;
+        firstName?: string;
+        lastName?: string;
+        photoUrl?: string;
+        authDate: number;
+        username?: string;
+      }
+    | { type: "siwe"; address: string }
+  )[];
+  encryptedPrivateKey: string;
+  keyType: "evm" | "solana";
+}
 export const ImportEndUserInput = /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
   userId: Schema.String,
-  authenticationMethods: Schema.Array(Schema.Unknown),
+  authenticationMethods: Schema.Array(
+    Schema.Union([
+      Schema.Struct({
+        type: Schema.Literals(["email"]),
+        email: Schema.String,
+      }),
+      Schema.Struct({
+        type: Schema.Literals(["sms"]),
+        phoneNumber: Schema.String,
+      }),
+      Schema.Struct({
+        type: Schema.Literals(["jwt"]),
+        kid: Schema.String,
+        sub: Schema.String,
+      }),
+      Schema.Struct({
+        type: Schema.Literals(["google", "apple", "x", "telegram", "github"]),
+        sub: Schema.String,
+        email: Schema.optional(Schema.String),
+        name: Schema.optional(Schema.String),
+        username: Schema.optional(Schema.String),
+      }),
+      Schema.Struct({
+        type: Schema.Literals(["google", "apple", "x", "telegram", "github"]),
+        id: Schema.Number,
+        firstName: Schema.optional(Schema.String),
+        lastName: Schema.optional(Schema.String),
+        photoUrl: Schema.optional(Schema.String),
+        authDate: Schema.Number,
+        username: Schema.optional(Schema.String),
+      }),
+      Schema.Struct({
+        type: Schema.Literals(["siwe"]),
+        address: Schema.String,
+      }),
+    ]),
+  ),
   encryptedPrivateKey: Schema.String,
   keyType: Schema.Literals(["evm", "solana"]),
-}).pipe(T.Http({ method: "POST", path: "/v2/end-users/import" }));
-export type ImportEndUserInput = typeof ImportEndUserInput.Type;
+}).pipe(
+  T.Http({ method: "POST", path: "/v2/end-users/import" }),
+) as unknown as Schema.Codec<ImportEndUserInput>;
 
 // Output Schema
+export interface ImportEndUserOutput {
+  userId: string;
+  authenticationMethods: (
+    | { type: "email"; email: string }
+    | { type: "sms"; phoneNumber: string }
+    | { type: "jwt"; kid: string; sub: string }
+    | {
+        type: "google" | "apple" | "x" | "telegram" | "github";
+        sub: string;
+        email?: string;
+        name?: string;
+        username?: string;
+      }
+    | {
+        type: "google" | "apple" | "x" | "telegram" | "github";
+        id: number;
+        firstName?: string;
+        lastName?: string;
+        photoUrl?: string;
+        authDate: number;
+        username?: string;
+      }
+    | { type: "siwe"; address: string }
+  )[];
+  mfaMethods?: {
+    enrollmentPromptedAt?: string;
+    totp?: { enrolledAt: string };
+    sms?: { enrolledAt: string };
+  };
+  evmAccounts: string[];
+  evmAccountObjects: { address: string; createdAt: string }[];
+  evmSmartAccounts: string[];
+  evmSmartAccountObjects: {
+    address: string;
+    ownerAddresses: string[];
+    createdAt: string;
+  }[];
+  solanaAccounts: string[];
+  solanaAccountObjects: { address: string; createdAt: string }[];
+  createdAt: string;
+}
 export const ImportEndUserOutput = /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
   userId: Schema.String,
-  authenticationMethods: Schema.Array(Schema.Unknown),
+  authenticationMethods: Schema.Array(
+    Schema.Union([
+      Schema.Struct({
+        type: Schema.Literals(["email"]),
+        email: Schema.String,
+      }),
+      Schema.Struct({
+        type: Schema.Literals(["sms"]),
+        phoneNumber: Schema.String,
+      }),
+      Schema.Struct({
+        type: Schema.Literals(["jwt"]),
+        kid: Schema.String,
+        sub: Schema.String,
+      }),
+      Schema.Struct({
+        type: Schema.Literals(["google", "apple", "x", "telegram", "github"]),
+        sub: Schema.String,
+        email: Schema.optional(Schema.String),
+        name: Schema.optional(Schema.String),
+        username: Schema.optional(Schema.String),
+      }),
+      Schema.Struct({
+        type: Schema.Literals(["google", "apple", "x", "telegram", "github"]),
+        id: Schema.Number,
+        firstName: Schema.optional(Schema.String),
+        lastName: Schema.optional(Schema.String),
+        photoUrl: Schema.optional(Schema.String),
+        authDate: Schema.Number,
+        username: Schema.optional(Schema.String),
+      }),
+      Schema.Struct({
+        type: Schema.Literals(["siwe"]),
+        address: Schema.String,
+      }),
+    ]),
+  ),
   mfaMethods: Schema.optional(
     Schema.Struct({
       enrollmentPromptedAt: Schema.optional(Schema.String),
@@ -53,12 +194,11 @@ export const ImportEndUserOutput = /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
     }),
   ),
   createdAt: Schema.String,
-});
-export type ImportEndUserOutput = typeof ImportEndUserOutput.Type;
+}) as unknown as Schema.Codec<ImportEndUserOutput>;
 
 // The operation
 /**
- * Import a private key for an end user
+ * Import end user private key
  *
  * Imports an existing private key for an end user into the developer's CDP Project. The private key must be encrypted using the CDP SDK's encryption scheme before being sent to this endpoint. This API should be called from the [CDP SDK](https://github.com/coinbase/cdp-sdk) to ensure that the associated private key is properly encrypted.
  * This endpoint allows developers to import existing keys for their end users, supporting both EVM and Solana key types. The end user must have at least one authentication method configured.

package/src/operations/importEvmAccount.ts

@@ -3,14 +3,27 @@ import { API } from "../client.ts";
 import * as T from "../traits.ts";
 
 // Input Schema
+export interface ImportEvmAccountInput {
+  encryptedPrivateKey: string;
+  name?: string;
+  accountPolicy?: string;
+}
 export const ImportEvmAccountInput = /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
   encryptedPrivateKey: Schema.String,
   name: Schema.optional(Schema.String),
   accountPolicy: Schema.optional(Schema.String),
-}).pipe(T.Http({ method: "POST", path: "/v2/evm/accounts/import" }));
-export type ImportEvmAccountInput = typeof ImportEvmAccountInput.Type;
+}).pipe(
+  T.Http({ method: "POST", path: "/v2/evm/accounts/import" }),
+) as unknown as Schema.Codec<ImportEvmAccountInput>;
 
 // Output Schema
+export interface ImportEvmAccountOutput {
+  address: string;
+  name?: string;
+  policies?: string[];
+  createdAt?: string;
+  updatedAt?: string;
+}
 export const ImportEvmAccountOutput = /*@__PURE__*/ /*#__PURE__*/ Schema.Struct(
   {
     address: Schema.String,
@@ -19,12 +32,11 @@ export const ImportEvmAccountOutput = /*@__PURE__*/ /*#__PURE__*/ Schema.Struct(
     createdAt: Schema.optional(Schema.String),
     updatedAt: Schema.optional(Schema.String),
   },
-);
-export type ImportEvmAccountOutput = typeof ImportEvmAccountOutput.Type;
+) as unknown as Schema.Codec<ImportEvmAccountOutput>;
 
 // The operation
 /**
- * Import an EVM account
+ * Import EVM account
  *
  * Import an existing EVM account into the developer's CDP Project. This API should be called from the [CDP SDK](https://github.com/coinbase/cdp-sdk) to ensure that the associated private key is properly encrypted.
  *

package/src/operations/importSolanaAccount.ts

@@ -3,14 +3,26 @@ import { API } from "../client.ts";
 import * as T from "../traits.ts";
 
 // Input Schema
+export interface ImportSolanaAccountInput {
+  encryptedPrivateKey: string;
+  name?: string;
+}
 export const ImportSolanaAccountInput =
   /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
     encryptedPrivateKey: Schema.String,
     name: Schema.optional(Schema.String),
-  }).pipe(T.Http({ method: "POST", path: "/v2/solana/accounts/import" }));
-export type ImportSolanaAccountInput = typeof ImportSolanaAccountInput.Type;
+  }).pipe(
+    T.Http({ method: "POST", path: "/v2/solana/accounts/import" }),
+  ) as unknown as Schema.Codec<ImportSolanaAccountInput>;
 
 // Output Schema
+export interface ImportSolanaAccountOutput {
+  address: string;
+  name?: string;
+  policies?: string[];
+  createdAt?: string;
+  updatedAt?: string;
+}
 export const ImportSolanaAccountOutput =
   /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
     address: Schema.String,
@@ -18,12 +30,11 @@ export const ImportSolanaAccountOutput =
     policies: Schema.optional(Schema.Array(Schema.String)),
     createdAt: Schema.optional(Schema.String),
     updatedAt: Schema.optional(Schema.String),
-  });
-export type ImportSolanaAccountOutput = typeof ImportSolanaAccountOutput.Type;
+  }) as unknown as Schema.Codec<ImportSolanaAccountOutput>;
 
 // The operation
 /**
- * Import a Solana account
+ * Import Solana account
  *
  * Import an existing Solana account into the developer's CDP Project. This API should be called from the [CDP SDK](https://github.com/coinbase/cdp-sdk) to ensure that the associated private key is properly encrypted.
  *

package/src/operations/index.ts

@@ -1,11 +1,41 @@
+export * from "./listFoundationAccounts.ts";
+export * from "./createFoundationAccount.ts";
+export * from "./getFoundationAccountById.ts";
+export * from "./listBalances.ts";
+export * from "./getBalanceByAsset.ts";
+export * from "./listDepositDestinations.ts";
+export * from "./createDepositDestination.ts";
+export * from "./getDepositDestinationById.ts";
+export * from "./listTransfers.ts";
+export * from "./createTransfer.ts";
+export * from "./getTransferById.ts";
+export * from "./executeFundTransfer.ts";
+export * from "./submitDepositTravelRule.ts";
 export * from "./listEndUsers.ts";
 export * from "./createEndUser.ts";
 export * from "./validateEndUserAccessToken.ts";
 export * from "./getEndUser.ts";
+export * from "./lookupEndUser.ts";
 export * from "./addEndUserEvmAccount.ts";
 export * from "./addEndUserEvmSmartAccount.ts";
 export * from "./addEndUserSolanaAccount.ts";
 export * from "./importEndUser.ts";
+export * from "./signEvmTransactionWithEndUserAccount.ts";
+export * from "./sendEvmTransactionWithEndUserAccount.ts";
+export * from "./sendEvmAssetWithEndUserAccount.ts";
+export * from "./signEvmMessageWithEndUserAccount.ts";
+export * from "./signEvmTypedDataWithEndUserAccount.ts";
+export * from "./getDelegationForEndUser.ts";
+export * from "./revokeDelegationForEndUser.ts";
+export * from "./getDelegationForEndUserAccount.ts";
+export * from "./createDelegationForEndUserAccount.ts";
+export * from "./revokeDelegationForEndUserAccount.ts";
+export * from "./createEvmEip7702DelegationWithEndUserAccount.ts";
+export * from "./sendUserOperationWithEndUserAccount.ts";
+export * from "./signSolanaMessageWithEndUserAccount.ts";
+export * from "./signSolanaTransactionWithEndUserAccount.ts";
+export * from "./sendSolanaTransactionWithEndUserAccount.ts";
+export * from "./sendSolanaAssetWithEndUserAccount.ts";
 export * from "./listEvmAccounts.ts";
 export * from "./createEvmAccount.ts";
 export * from "./getEvmAccount.ts";
@@ -69,7 +99,17 @@ export * from "./listWebhookSubscriptionEvents.ts";
 export * from "./verifyX402Payment.ts";
 export * from "./settleX402Payment.ts";
 export * from "./supportedX402PaymentKinds.ts";
+export * from "./listX402DiscoveryResources.ts";
+export * from "./listX402DiscoveryMerchant.ts";
+export * from "./searchX402Resources.ts";
+export * from "./postX402DiscoveryMcp.ts";
+export * from "./validateX402Resource.ts";
+export * from "./initiateOnrampVerification.ts";
+export * from "./submitOnrampVerification.ts";
 export * from "./createOnrampOrder.ts";
 export * from "./getOnrampOrderById.ts";
 export * from "./createOnrampSession.ts";
 export * from "./getOnrampUserLimits.ts";
+export * from "./requestLimitsUpgrade.ts";
+export * from "./listPaymentMethods.ts";
+export * from "./getPaymentMethod.ts";

package/src/operations/initiateOnrampVerification.ts

@@ -0,0 +1,46 @@
+import * as Schema from "effect/Schema";
+import { API } from "../client.ts";
+import * as T from "../traits.ts";
+
+// Input Schema
+export interface InitiateOnrampVerificationInput {
+  channel: "sms" | "email";
+  destination: string;
+}
+export const InitiateOnrampVerificationInput =
+  /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
+    channel: Schema.Literals(["sms", "email"]),
+    destination: Schema.String,
+  }).pipe(
+    T.Http({ method: "POST", path: "/v2/onramp/verifications" }),
+  ) as unknown as Schema.Codec<InitiateOnrampVerificationInput>;
+
+// Output Schema
+export interface InitiateOnrampVerificationOutput {
+  verificationId: string;
+  otpExpiresAt: string;
+}
+export const InitiateOnrampVerificationOutput =
+  /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
+    verificationId: Schema.String,
+    otpExpiresAt: Schema.String,
+  }) as unknown as Schema.Codec<InitiateOnrampVerificationOutput>;
+
+// The operation
+/**
+ * Initiate onramp verification
+ *
+ * Initiates OTP verification by sending a 6-digit code to the user via the specified channel (SMS or email). Returns a `verificationId` that must be passed to the Submit Onramp Verification endpoint along with the OTP code within 10 minutes.
+ * **Access to this API requires allowlisting.** During Onramp Headless API onboarding, contact the Onramp team to enable Onramp-managed verification for your application.
+ *
+ * @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 initiateOnrampVerification = /*@__PURE__*/ /*#__PURE__*/ API.make(
+  () => ({
+    inputSchema: InitiateOnrampVerificationInput,
+    outputSchema: InitiateOnrampVerificationOutput,
+  }),
+);

package/src/operations/listBalances.ts

@@ -0,0 +1,66 @@
+import * as Schema from "effect/Schema";
+import { API } from "../client.ts";
+import * as T from "../traits.ts";
+
+// Input Schema
+export interface ListBalancesInput {
+  accountId: string;
+  pageSize?: number;
+  pageToken?: string;
+}
+export const ListBalancesInput = /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
+  accountId: Schema.String.pipe(T.PathParam()),
+  pageSize: Schema.optional(Schema.Number),
+  pageToken: Schema.optional(Schema.String),
+}).pipe(
+  T.Http({ method: "GET", path: "/v2/accounts/{accountId}/balances" }),
+) as unknown as Schema.Codec<ListBalancesInput>;
+
+// Output Schema
+export interface ListBalancesOutput {
+  balances: {
+    asset: {
+      symbol: string;
+      type: "fiat" | "crypto";
+      name: string;
+      decimals: number;
+    };
+    amount: Record<string, { available: string; total: string }>;
+  }[];
+  nextPageToken?: string;
+}
+export const ListBalancesOutput = /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
+  balances: Schema.Array(
+    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,
+        }),
+      ),
+    }),
+  ),
+  nextPageToken: Schema.optional(Schema.String),
+}) as unknown as Schema.Codec<ListBalancesOutput>;
+
+// The operation
+/**
+ * List balances for account
+ *
+ * List the balances for an account. Results are sorted by native-fiat equivalent balance in descending order.
+ *
+ * @param accountId - The unique identifier of the account.
+ * @param pageSize - The number of resources to return per page.
+ * @param pageToken - The token for the next page of resources, if any.
+ */
+export const listBalances = /*@__PURE__*/ /*#__PURE__*/ API.make(() => ({
+  inputSchema: ListBalancesInput,
+  outputSchema: ListBalancesOutput,
+}));

package/src/operations/listDataTokenBalances.ts

@@ -3,6 +3,12 @@ import { API } from "../client.ts";
 import * as T from "../traits.ts";
 
 // Input Schema
+export interface ListDataTokenBalancesInput {
+  address: string;
+  network: string;
+  pageSize?: number;
+  pageToken?: string;
+}
 export const ListDataTokenBalancesInput =
   /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
     address: Schema.String.pipe(T.PathParam()),
@@ -14,10 +20,21 @@ export const ListDataTokenBalancesInput =
       method: "GET",
       path: "/v2/data/evm/token-balances/{network}/{address}",
     }),
-  );
-export type ListDataTokenBalancesInput = typeof ListDataTokenBalancesInput.Type;
+  ) as unknown as Schema.Codec<ListDataTokenBalancesInput>;
 
 // Output Schema
+export interface ListDataTokenBalancesOutput {
+  balances: {
+    amount: { amount: string; decimals: number };
+    token: {
+      network: "base" | "base-sepolia" | "ethereum";
+      symbol?: string;
+      name?: string;
+      contractAddress: string;
+    };
+  }[];
+  nextPageToken?: string;
+}
 export const ListDataTokenBalancesOutput =
   /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
     balances: Schema.Array(
@@ -35,9 +52,7 @@ export const ListDataTokenBalancesOutput =
       }),
     ),
     nextPageToken: Schema.optional(Schema.String),
-  });
-export type ListDataTokenBalancesOutput =
-  typeof ListDataTokenBalancesOutput.Type;
+  }) as unknown as Schema.Codec<ListDataTokenBalancesOutput>;
 
 // The operation
 /**