@coinbase/cdp-sdk 1.51.1 → 1.52.0

package/src/_vendor/api/types/TravelRule.ts

@@ -0,0 +1,39 @@
+// This file was auto-generated by Fern from our API Definition.
+
+import type * as CoinbaseApi from "../index.js";
+
+/**
+ * Required Travel Rule fields differ by region. These requirements are determined based on which Coinbase entity the customer has signed the service agreement for.
+ */
+export interface TravelRule {
+    /** Indicates whether the user attests that the receiving wallet belongs to them. */
+    isSelf?: boolean | undefined;
+    /**
+     * Indicates whether Coinbase is being used as an intermediary Virtual Asset Service Provider (VASP) to send crypto on behalf of your customer.
+     *
+     * **Background:**
+     *
+     * The Travel Rule (FATF Recommendation 16) requires VASPs to share originator and beneficiary information for virtual asset transfers. When Coinbase acts as an intermediary, additional Travel Rule data must be provided to satisfy compliance requirements.
+     *
+     * **Set to `true` when:**
+     *
+     * - Your organization is a VASP using Coinbase to send crypto **on behalf of your end customer**
+     * - In this scenario, Coinbase acts as an intermediary in the transfer chain and handles Travel Rule data exchange with the beneficiary VASP
+     *
+     * **Set to `false` (or omit) when:**
+     *
+     * - You are transferring funds directly from your own Coinbase account, where **Coinbase is your primary VASP** rather than an intermediary for another institution
+     *
+     * **Impact on required fields:**
+     *
+     * When `isIntermediary` is `true`, you must provide the `originator` object with details about the **original sender**, including:
+     * - Originator name
+     * - Originator address
+     * - Your VASP information (`virtualAssetServiceProvider` object with `name`, `address`, and `identifier`)
+     *
+     * For jurisdictions that require them (such as Coinbase Luxembourg), `personalIdentification` and `dateOfBirth` must also reflect the **original sender's** identity — not the intermediary's. These fields will not be auto-populated from any internal KYC data when `isIntermediary` is `true`.
+     */
+    isIntermediary?: boolean | undefined;
+    originator?: CoinbaseApi.TravelRuleOriginator | undefined;
+    beneficiary?: CoinbaseApi.TravelRuleBeneficiary | undefined;
+}

package/src/_vendor/api/types/TravelRuleBeneficiary.ts

@@ -0,0 +1,25 @@
+// This file was auto-generated by Fern from our API Definition.
+
+import type * as CoinbaseApi from "../index.js";
+
+/**
+ * Beneficiary (receiver) party.
+ */
+export interface TravelRuleBeneficiary {
+    /** Name of the financial institution. */
+    financialInstitution?: string | undefined;
+    /** Full name of the party. */
+    name?: string | undefined;
+    address?: CoinbaseApi.PhysicalAddress | undefined;
+    /** The type of the beneficiary's wallet. */
+    walletType?: TravelRuleBeneficiary.WalletType | undefined;
+}
+
+export namespace TravelRuleBeneficiary {
+    /** The type of the beneficiary's wallet. */
+    export const WalletType = {
+        Custodial: "custodial",
+        SelfCustody: "self_custody",
+    } as const;
+    export type WalletType = (typeof WalletType)[keyof typeof WalletType];
+}

package/src/_vendor/api/types/TravelRuleOriginator.ts

@@ -0,0 +1,34 @@
+// This file was auto-generated by Fern from our API Definition.
+
+import type * as CoinbaseApi from "../index.js";
+
+/**
+ * Originator (sender) party.
+ */
+export interface TravelRuleOriginator {
+    /** Name of the financial institution. */
+    financialInstitution?: string | undefined;
+    /** Full name of the party. */
+    name?: string | undefined;
+    address?: CoinbaseApi.PhysicalAddress | undefined;
+    /** Information about the originating Virtual Asset Service Provider (VASP) that handles cryptocurrency or other virtual assets on behalf of customers. */
+    virtualAssetServiceProvider?: TravelRuleOriginator.VirtualAssetServiceProvider | undefined;
+    /** Personal identifier for travel rule compliance. For individuals: passport number, national ID, or driver's license. For institutions: LEI (Legal Entity Identifier). */
+    personalId?: string | undefined;
+    /** Date of birth of the originator. Required by certain jurisdictions (such as Coinbase Luxembourg) to satisfy Travel Rule reporting obligations. */
+    dateOfBirth?: CoinbaseApi.DateOfBirth | undefined;
+}
+
+export namespace TravelRuleOriginator {
+    /**
+     * Information about the originating Virtual Asset Service Provider (VASP) that handles cryptocurrency or other virtual assets on behalf of customers.
+     */
+    export interface VirtualAssetServiceProvider {
+        /** The name of the originating Virtual Asset Service Provider (VASP). */
+        name?: string | undefined;
+        /** The address of the originating Virtual Asset Service Provider (VASP). */
+        address?: CoinbaseApi.PhysicalAddress | undefined;
+        /** The Legal Entity Identifier of the originating Virtual Asset Service Provider (VASP). */
+        identifier?: string | undefined;
+    }
+}

package/src/_vendor/api/types/TravelRuleStatus.ts

@@ -0,0 +1,8 @@
+// This file was auto-generated by Fern from our API Definition.
+
+/** The status of a travel rule submission. */
+export const TravelRuleStatus = {
+    Incomplete: "incomplete",
+    Completed: "completed",
+} as const;
+export type TravelRuleStatus = (typeof TravelRuleStatus)[keyof typeof TravelRuleStatus];

package/src/_vendor/api/types/Url.ts

@@ -0,0 +1,6 @@
+// This file was auto-generated by Fern from our API Definition.
+
+/**
+ * A valid HTTP or HTTPS URL.
+ */
+export type Url = string;

package/src/_vendor/api/types/index.ts

@@ -0,0 +1,63 @@
+export * from "./Account.js";
+export * from "./AccountId.js";
+export * from "./AccountName.js";
+export * from "./AccountType.js";
+export * from "./AmountDetail.js";
+export * from "./Asset.js";
+export * from "./AssetType.js";
+export * from "./Balance.js";
+export * from "./BalancesAsset.js";
+export * from "./BlockchainAddress.js";
+export * from "./CapabilityName.js";
+export * from "./CreateCryptoDepositDestinationRequest.js";
+export * from "./CreateDepositDestinationCrypto.js";
+export * from "./CreateDepositDestinationRequest.js";
+export * from "./CreateTransferSource.js";
+export * from "./CryptoDepositDestination.js";
+export * from "./DateOfBirth.js";
+export * from "./DepositDestination.js";
+export * from "./DepositDestinationCrypto.js";
+export * from "./DepositDestinationId.js";
+export * from "./DepositDestinationReference.js";
+export * from "./DepositDestinationStatus.js";
+export * from "./DepositDestinationTarget.js";
+export * from "./DepositDestinationTargetAccount.js";
+export * from "./DepositDestinationType.js";
+export * from "./DepositTravelRuleBeneficiary.js";
+export * from "./DepositTravelRuleOriginator.js";
+export * from "./DepositTravelRuleResponse.js";
+export * from "./DepositTravelRuleVasp.js";
+export * from "./Email.js";
+export * from "./EmailInstrument.js";
+export * from "./Error_.js";
+export * from "./ErrorType.js";
+export * from "./FedwireDetails.js";
+export * from "./FedwirePaymentMethod.js";
+export * from "./Metadata.js";
+export * from "./Network.js";
+export * from "./OnchainAddress.js";
+export * from "./OriginatingBankAccountUs.js";
+export * from "./Owner.js";
+export * from "./PaymentMethod.js";
+export * from "./PaymentMethodId.js";
+export * from "./PaymentMethodsPaymentMethod.js";
+export * from "./PhysicalAddress.js";
+export * from "./SepaDetails.js";
+export * from "./SepaPaymentMethod.js";
+export * from "./SwiftDetails.js";
+export * from "./SwiftPaymentMethod.js";
+export * from "./Transfer.js";
+export * from "./TransferDetails.js";
+export * from "./TransferEstimate.js";
+export * from "./TransferExchangeRate.js";
+export * from "./TransferFee.js";
+export * from "./TransferFees.js";
+export * from "./TransferSource.js";
+export * from "./TransferStatus.js";
+export * from "./TransfersAccount.js";
+export * from "./TransferTarget.js";
+export * from "./TravelRule.js";
+export * from "./TravelRuleBeneficiary.js";
+export * from "./TravelRuleOriginator.js";
+export * from "./TravelRuleStatus.js";
+export * from "./Url.js";

package/src/_vendor/auth/BearerAuthProvider.ts

@@ -0,0 +1,47 @@
+// This file was auto-generated by Fern from our API Definition.
+
+import * as core from "../core/index.js";
+import * as errors from "../errors/index.js";
+
+const TOKEN_PARAM = "token" as const;
+
+export class BearerAuthProvider implements core.AuthProvider {
+    private readonly options: BearerAuthProvider.Options;
+
+    constructor(options: BearerAuthProvider.Options) {
+        this.options = options;
+    }
+
+    public static canCreate(options: Partial<BearerAuthProvider.Options>): boolean {
+        return options?.[TOKEN_PARAM] != null;
+    }
+
+    public async getAuthRequest({
+        endpointMetadata,
+    }: {
+        endpointMetadata?: core.EndpointMetadata;
+    } = {}): Promise<core.AuthRequest> {
+        const token = await core.EndpointSupplier.get(this.options[TOKEN_PARAM], { endpointMetadata });
+        if (token == null) {
+            throw new errors.CoinbaseApiError({
+                message: BearerAuthProvider.AUTH_CONFIG_ERROR_MESSAGE,
+            });
+        }
+
+        return {
+            headers: { Authorization: `Bearer ${token}` },
+        };
+    }
+}
+
+export namespace BearerAuthProvider {
+    export const AUTH_SCHEME = "apiKeyAuth" as const;
+    export const AUTH_CONFIG_ERROR_MESSAGE: string =
+        `Please provide '${TOKEN_PARAM}' when initializing the client` as const;
+    export type Options = AuthOptions;
+    export type AuthOptions = { [TOKEN_PARAM]: core.EndpointSupplier<core.BearerToken> };
+
+    export function createInstance(options: Options): core.AuthProvider {
+        return new BearerAuthProvider(options);
+    }
+}

package/src/_vendor/auth/index.ts

@@ -0,0 +1 @@
+export { BearerAuthProvider } from "./BearerAuthProvider.js";

package/src/_vendor/core/auth/AuthProvider.ts

@@ -0,0 +1,34 @@
+import type { EndpointMetadata } from "../fetcher/EndpointMetadata.js";
+import type { AuthRequest } from "./AuthRequest.js";
+
+/**
+ * Per-request information made available to an `auth` callback so it can compute request-scoped
+ * credentials (e.g. signed JWTs whose claims depend on the HTTP method or request body).
+ */
+export interface AuthRequestInfo {
+    /** The HTTP method of the outgoing request (e.g. "POST"). */
+    method: string;
+    /** The (unserialized) request body, if any. */
+    body?: unknown;
+    /** Headers assembled for the outgoing request so far. */
+    headers?: Record<string, string>;
+}
+
+export interface AuthProvider {
+    getAuthRequest(arg?: {
+        endpointMetadata?: EndpointMetadata;
+        /** The client's constructor options (including any config-declared extra fields). */
+        clientOptions?: Record<string, unknown>;
+        /** Per-request information for request-scoped auth. */
+        request?: AuthRequestInfo;
+    }): Promise<AuthRequest>;
+}
+
+export function isAuthProvider(value: unknown): value is AuthProvider {
+    return (
+        typeof value === "object" &&
+        value !== null &&
+        "getAuthRequest" in value &&
+        typeof value.getAuthRequest === "function"
+    );
+}

package/src/_vendor/core/auth/AuthRequest.ts

@@ -0,0 +1,9 @@
+/**
+ * Request parameters for authentication requests.
+ */
+export interface AuthRequest {
+    /**
+     * The headers to be included in the request.
+     */
+    headers: Record<string, string>;
+}

package/src/_vendor/core/auth/BasicAuth.ts

@@ -0,0 +1,37 @@
+import { base64Decode, base64Encode } from "../base64.js";
+
+export interface BasicAuth {
+    username?: string;
+    password?: string;
+}
+
+const BASIC_AUTH_HEADER_PREFIX = /^Basic /i;
+
+export const BasicAuth = {
+    toAuthorizationHeader: (basicAuth: BasicAuth | undefined): string | undefined => {
+        if (basicAuth == null) {
+            return undefined;
+        }
+        const username = basicAuth.username ?? "";
+        const password = basicAuth.password ?? "";
+        if (username === "" && password === "") {
+            return undefined;
+        }
+        const token = base64Encode(`${username}:${password}`);
+        return `Basic ${token}`;
+    },
+    fromAuthorizationHeader: (header: string): BasicAuth => {
+        const credentials = header.replace(BASIC_AUTH_HEADER_PREFIX, "");
+        const decoded = base64Decode(credentials);
+        const [username, ...passwordParts] = decoded.split(":");
+        const password = passwordParts.length > 0 ? passwordParts.join(":") : undefined;
+
+        if (username == null || password == null) {
+            throw new Error("Invalid basic auth");
+        }
+        return {
+            username,
+            password,
+        };
+    },
+};

package/src/_vendor/core/auth/BearerToken.ts

@@ -0,0 +1,20 @@
+export type BearerToken = string;
+
+const BEARER_AUTH_HEADER_PREFIX = /^Bearer /i;
+
+function toAuthorizationHeader(token: string | undefined): string | undefined {
+    if (token == null) {
+        return undefined;
+    }
+    return `Bearer ${token}`;
+}
+
+export const BearerToken: {
+    toAuthorizationHeader: typeof toAuthorizationHeader;
+    fromAuthorizationHeader: (header: string) => BearerToken;
+} = {
+    toAuthorizationHeader: toAuthorizationHeader,
+    fromAuthorizationHeader: (header: string): BearerToken => {
+        return header.replace(BEARER_AUTH_HEADER_PREFIX, "").trim() as BearerToken;
+    },
+};

package/src/_vendor/core/auth/NoOpAuthProvider.ts

@@ -0,0 +1,8 @@
+import type { AuthProvider } from "./AuthProvider.js";
+import type { AuthRequest } from "./AuthRequest.js";
+
+export class NoOpAuthProvider implements AuthProvider {
+    public getAuthRequest(): Promise<AuthRequest> {
+        return Promise.resolve({ headers: {} });
+    }
+}

package/src/_vendor/core/auth/index.ts

@@ -0,0 +1,5 @@
+export { type AuthProvider, isAuthProvider } from "./AuthProvider.js";
+export type { AuthRequest } from "./AuthRequest.js";
+export { BasicAuth } from "./BasicAuth.js";
+export { BearerToken } from "./BearerToken.js";
+export { NoOpAuthProvider } from "./NoOpAuthProvider.js";

package/src/_vendor/core/base64.ts

@@ -0,0 +1,27 @@
+function base64ToBytes(base64: string): Uint8Array {
+    const binString = atob(base64);
+    return Uint8Array.from(binString, (m) => m.codePointAt(0)!);
+}
+
+function bytesToBase64(bytes: Uint8Array): string {
+    const binString = String.fromCodePoint(...bytes);
+    return btoa(binString);
+}
+
+export function base64Encode(input: string): string {
+    if (typeof Buffer !== "undefined") {
+        return Buffer.from(input, "utf8").toString("base64");
+    }
+
+    const bytes = new TextEncoder().encode(input);
+    return bytesToBase64(bytes);
+}
+
+export function base64Decode(input: string): string {
+    if (typeof Buffer !== "undefined") {
+        return Buffer.from(input, "base64").toString("utf8");
+    }
+
+    const bytes = base64ToBytes(input);
+    return new TextDecoder().decode(bytes);
+}

package/src/_vendor/core/exports.ts

@@ -0,0 +1 @@
+export * from "./logging/exports.js";

package/src/_vendor/core/fetcher/APIResponse.ts

@@ -0,0 +1,23 @@
+import type { RawResponse } from "./RawResponse.js";
+
+/**
+ * The response of an API call.
+ * It is a successful response or a failed response.
+ */
+export type APIResponse<Success, Failure> = SuccessfulResponse<Success> | FailedResponse<Failure>;
+
+export interface SuccessfulResponse<T> {
+    ok: true;
+    body: T;
+    /**
+     * @deprecated Use `rawResponse` instead
+     */
+    headers?: Record<string, any>;
+    rawResponse: RawResponse;
+}
+
+export interface FailedResponse<T> {
+    ok: false;
+    error: T;
+    rawResponse: RawResponse;
+}

package/src/_vendor/core/fetcher/BinaryResponse.ts

@@ -0,0 +1,34 @@
+export type BinaryResponse = {
+    /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/Request/bodyUsed) */
+    bodyUsed: Response["bodyUsed"];
+    /**
+     * Returns a ReadableStream of the response body.
+     * [MDN Reference](https://developer.mozilla.org/docs/Web/API/Request/body)
+     */
+    stream: () => Response["body"];
+    /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/Request/arrayBuffer) */
+    arrayBuffer: () => ReturnType<Response["arrayBuffer"]>;
+    /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/Request/blob) */
+    blob: () => ReturnType<Response["blob"]>;
+    /**
+     * [MDN Reference](https://developer.mozilla.org/docs/Web/API/Request/bytes)
+     * Some versions of the Fetch API may not support this method.
+     */
+    bytes?(): Promise<Uint8Array>;
+};
+
+export function getBinaryResponse(response: Response): BinaryResponse {
+    const binaryResponse: BinaryResponse = {
+        get bodyUsed() {
+            return response.bodyUsed;
+        },
+        stream: () => response.body,
+        arrayBuffer: response.arrayBuffer.bind(response),
+        blob: response.blob.bind(response),
+    };
+    if ("bytes" in response && typeof response.bytes === "function") {
+        binaryResponse.bytes = response.bytes.bind(response);
+    }
+
+    return binaryResponse;
+}

package/src/_vendor/core/fetcher/EndpointMetadata.ts

@@ -0,0 +1,29 @@
+export type SecuritySchemeKey = string;
+/**
+ * A collection of security schemes, where the key is the name of the security scheme and the value is the list of scopes required for that scheme.
+ * All schemes in the collection must be satisfied for authentication to be successful.
+ */
+export type SecuritySchemeCollection = Record<SecuritySchemeKey, AuthScope[]>;
+export type AuthScope = string;
+export type EndpointMetadata = {
+    /**
+     * An array of security scheme collections. Each collection represents an alternative way to authenticate.
+     */
+    security?: SecuritySchemeCollection[];
+    /**
+     * The HTTP method of the endpoint (e.g. "POST").
+     */
+    method?: string;
+    /**
+     * The endpoint's path, including path parameter placeholders (e.g. "/v2/end-users/{userId}").
+     */
+    path?: string;
+    /**
+     * A stable identifier for the endpoint (operation id).
+     */
+    operationId?: string;
+    /**
+     * The wire names of headers declared on the endpoint (including managed headers such as "X-Wallet-Auth").
+     */
+    headers?: string[];
+};

package/src/_vendor/core/fetcher/EndpointSupplier.ts

@@ -0,0 +1,14 @@
+import type { EndpointMetadata } from "./EndpointMetadata.js";
+import type { Supplier } from "./Supplier.js";
+
+type EndpointSupplierFn<T> = (arg: { endpointMetadata?: EndpointMetadata }) => T | Promise<T>;
+export type EndpointSupplier<T> = Supplier<T> | EndpointSupplierFn<T>;
+export const EndpointSupplier = {
+    get: async <T>(supplier: EndpointSupplier<T>, arg: { endpointMetadata?: EndpointMetadata }): Promise<T> => {
+        if (typeof supplier === "function") {
+            return (supplier as EndpointSupplierFn<T>)(arg);
+        } else {
+            return supplier;
+        }
+    },
+};