@distilled.cloud/coinbase 0.30.3 → 1.0.0-rc.2

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,
-  }));

package/src/operations/getDepositDestinationById.ts

@@ -1,87 +0,0 @@
-import * as Schema from "effect/Schema";
-import { API } from "../client.ts";
-import * as T from "../traits.ts";
-
-// Input Schema
-export interface GetDepositDestinationByIdInput {
-  depositDestinationId: string;
-}
-export const GetDepositDestinationByIdInput =
-  /*@__PURE__*/ Schema.Struct({
-    depositDestinationId: Schema.String.pipe(T.PathParam()),
-  }).pipe(
-    T.Http({
-      method: "GET",
-      path: "/v2/deposit-destinations/{depositDestinationId}",
-    }),
-  ) as unknown as Schema.Codec<GetDepositDestinationByIdInput>;
-
-// Output Schema
-export interface GetDepositDestinationByIdOutput {
-  depositDestinationId: string;
-  accountId: string;
-  type: "crypto";
-  crypto: {
-    network:
-      | "base"
-      | "ethereum"
-      | "solana"
-      | "aptos"
-      | "arbitrum"
-      | "arbitrum-sepolia"
-      | "optimism"
-      | "polygon"
-      | "world"
-      | "world-sepolia";
-    address: string;
-  };
-  target?: { accountId?: string; asset: string };
-  status: "active" | "inactive" | "pending";
-  metadata?: Record<string, string>;
-  createdAt: string;
-  updatedAt: string;
-}
-export const GetDepositDestinationByIdOutput =
-  /*@__PURE__*/ Schema.Struct({
-    depositDestinationId: Schema.String,
-    accountId: Schema.String,
-    type: Schema.Literals(["crypto"]),
-    crypto: Schema.Struct({
-      network: Schema.Literals([
-        "base",
-        "ethereum",
-        "solana",
-        "aptos",
-        "arbitrum",
-        "arbitrum-sepolia",
-        "optimism",
-        "polygon",
-        "world",
-        "world-sepolia",
-      ]),
-      address: Schema.String,
-    }),
-    target: Schema.optional(
-      Schema.Struct({
-        accountId: Schema.optional(Schema.String),
-        asset: Schema.String,
-      }),
-    ),
-    status: Schema.Literals(["active", "inactive", "pending"]),
-    metadata: Schema.optional(Schema.Record(Schema.String, Schema.String)),
-    createdAt: Schema.String,
-    updatedAt: Schema.String,
-  }) as unknown as Schema.Codec<GetDepositDestinationByIdOutput>;
-
-// The operation
-/**
- * Get deposit destination
- *
- * Get a specific deposit destination by its ID.
- *
- * @param depositDestinationId - The ID of the deposit address to retrieve.
- */
-export const getDepositDestinationById = /*@__PURE__*/ API.make(() => ({
-  inputSchema: GetDepositDestinationByIdInput,
-  outputSchema: GetDepositDestinationByIdOutput,
-}));

package/src/operations/getEndUser.ts

@@ -1,148 +0,0 @@
-import * as Schema from "effect/Schema";
-import { API } from "../client.ts";
-import * as T from "../traits.ts";
-
-// Input Schema
-export interface GetEndUserInput {
-  userId: string;
-}
-export const GetEndUserInput = /*@__PURE__*/ Schema.Struct({
-  userId: Schema.String.pipe(T.PathParam()),
-}).pipe(
-  T.Http({ method: "GET", path: "/v2/end-users/{userId}" }),
-) as unknown as Schema.Codec<GetEndUserInput>;
-
-// Output Schema
-export interface GetEndUserOutput {
-  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 GetEndUserOutput = /*@__PURE__*/ Schema.Struct({
-  userId: Schema.String,
-  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),
-      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,
-}) as unknown as Schema.Codec<GetEndUserOutput>;
-
-// The operation
-/**
- * Get end user
- *
- * Gets an end user by ID.
- * This API is intended to be used by the developer's own backend, and is authenticated using the developer's CDP API key.
- *
- * @param userId - The ID of the end user to get.
- */
-export const getEndUser = /*@__PURE__*/ API.make(() => ({
-  inputSchema: GetEndUserInput,
-  outputSchema: GetEndUserOutput,
-}));

package/src/operations/getEvmAccount.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 GetEvmAccountInput {
-  address: string;
-}
-export const GetEvmAccountInput = /*@__PURE__*/ Schema.Struct({
-  address: Schema.String.pipe(T.PathParam()),
-}).pipe(
-  T.Http({ method: "GET", path: "/v2/evm/accounts/{address}" }),
-) as unknown as Schema.Codec<GetEvmAccountInput>;
-
-// Output Schema
-export interface GetEvmAccountOutput {
-  address: string;
-  name?: string;
-  policies?: string[];
-  createdAt?: string;
-  updatedAt?: string;
-}
-export const GetEvmAccountOutput = /*@__PURE__*/ 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),
-}) as unknown as Schema.Codec<GetEvmAccountOutput>;
-
-// The operation
-/**
- * Get EVM account by address
- *
- * Gets an EVM account by its address.
- *
- * @param address - The 0x-prefixed address of the EVM account. The address does not need to be checksummed.
- */
-export const getEvmAccount = /*@__PURE__*/ API.make(() => ({
-  inputSchema: GetEvmAccountInput,
-  outputSchema: GetEvmAccountOutput,
-}));

package/src/operations/getEvmAccountByName.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 GetEvmAccountByNameInput {
-  name: string;
-}
-export const GetEvmAccountByNameInput =
-  /*@__PURE__*/ Schema.Struct({
-    name: Schema.String.pipe(T.PathParam()),
-  }).pipe(
-    T.Http({ method: "GET", path: "/v2/evm/accounts/by-name/{name}" }),
-  ) as unknown as Schema.Codec<GetEvmAccountByNameInput>;
-
-// Output Schema
-export interface GetEvmAccountByNameOutput {
-  address: string;
-  name?: string;
-  policies?: string[];
-  createdAt?: string;
-  updatedAt?: string;
-}
-export const GetEvmAccountByNameOutput =
-  /*@__PURE__*/ 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),
-  }) as unknown as Schema.Codec<GetEvmAccountByNameOutput>;
-
-// The operation
-/**
- * Get EVM account by name
- *
- * Gets an EVM account by its name.
- *
- * @param name - The name of the EVM account.
- */
-export const getEvmAccountByName = /*@__PURE__*/ API.make(() => ({
-  inputSchema: GetEvmAccountByNameInput,
-  outputSchema: GetEvmAccountByNameOutput,
-}));

package/src/operations/getEvmEip7702DelegationOperationById.ts

@@ -1,69 +0,0 @@
-import * as Schema from "effect/Schema";
-import { API } from "../client.ts";
-import * as T from "../traits.ts";
-
-// Input Schema
-export interface GetEvmEip7702DelegationOperationByIdInput {
-  delegationOperationId: string;
-}
-export const GetEvmEip7702DelegationOperationByIdInput =
-  /*@__PURE__*/ Schema.Struct({
-    delegationOperationId: Schema.String.pipe(T.PathParam()),
-  }).pipe(
-    T.Http({
-      method: "GET",
-      path: "/v2/evm/eip7702/delegation-operations/{delegationOperationId}",
-    }),
-  ) as unknown as Schema.Codec<GetEvmEip7702DelegationOperationByIdInput>;
-
-// Output Schema
-export interface GetEvmEip7702DelegationOperationByIdOutput {
-  delegationOperationId: string;
-  status: "UNSPECIFIED" | "PENDING" | "SUBMITTED" | "COMPLETED" | "FAILED";
-  transactionHash?: string;
-  network:
-    | "base-sepolia"
-    | "base"
-    | "arbitrum"
-    | "optimism"
-    | "polygon"
-    | "ethereum"
-    | "ethereum-sepolia";
-  delegateAddress?: string;
-}
-export const GetEvmEip7702DelegationOperationByIdOutput =
-  /*@__PURE__*/ Schema.Struct({
-    delegationOperationId: Schema.String,
-    status: Schema.Literals([
-      "UNSPECIFIED",
-      "PENDING",
-      "SUBMITTED",
-      "COMPLETED",
-      "FAILED",
-    ]),
-    transactionHash: Schema.optional(Schema.String),
-    network: Schema.Literals([
-      "base-sepolia",
-      "base",
-      "arbitrum",
-      "optimism",
-      "polygon",
-      "ethereum",
-      "ethereum-sepolia",
-    ]),
-    delegateAddress: Schema.optional(Schema.String),
-  }) as unknown as Schema.Codec<GetEvmEip7702DelegationOperationByIdOutput>;
-
-// The operation
-/**
- * Get EIP-7702 delegation operation by ID
- *
- * Returns the EIP-7702 delegation operation. Use the delegationOperationId returned by the Create EIP-7702 delegation endpoint to poll for operation completion.
- *
- * @param delegationOperationId - The unique identifier for the delegation operation.
- */
-export const getEvmEip7702DelegationOperationById =
-  /*@__PURE__*/ API.make(() => ({
-    inputSchema: GetEvmEip7702DelegationOperationByIdInput,
-    outputSchema: GetEvmEip7702DelegationOperationByIdOutput,
-  }));

package/src/operations/getEvmSmartAccount.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 GetEvmSmartAccountInput {
-  address: string;
-}
-export const GetEvmSmartAccountInput =
-  /*@__PURE__*/ Schema.Struct({
-    address: Schema.String.pipe(T.PathParam()),
-  }).pipe(
-    T.Http({ method: "GET", path: "/v2/evm/smart-accounts/{address}" }),
-  ) as unknown as Schema.Codec<GetEvmSmartAccountInput>;
-
-// Output Schema
-export interface GetEvmSmartAccountOutput {
-  address: string;
-  owners: string[];
-  name?: string;
-  policies?: string[];
-  createdAt?: string;
-  updatedAt?: string;
-}
-export const GetEvmSmartAccountOutput =
-  /*@__PURE__*/ 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),
-  }) as unknown as Schema.Codec<GetEvmSmartAccountOutput>;
-
-// The operation
-/**
- * Get Smart Account by address
- *
- * Gets a Smart Account by its address.
- *
- * @param address - The 0x-prefixed address of the Smart Account.
- */
-export const getEvmSmartAccount = /*@__PURE__*/ API.make(() => ({
-  inputSchema: GetEvmSmartAccountInput,
-  outputSchema: GetEvmSmartAccountOutput,
-}));

package/src/operations/getEvmSmartAccountByName.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 GetEvmSmartAccountByNameInput {
-  name: string;
-}
-export const GetEvmSmartAccountByNameInput =
-  /*@__PURE__*/ Schema.Struct({
-    name: Schema.String.pipe(T.PathParam()),
-  }).pipe(
-    T.Http({ method: "GET", path: "/v2/evm/smart-accounts/by-name/{name}" }),
-  ) as unknown as Schema.Codec<GetEvmSmartAccountByNameInput>;
-
-// Output Schema
-export interface GetEvmSmartAccountByNameOutput {
-  address: string;
-  owners: string[];
-  name?: string;
-  policies?: string[];
-  createdAt?: string;
-  updatedAt?: string;
-}
-export const GetEvmSmartAccountByNameOutput =
-  /*@__PURE__*/ 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),
-  }) as unknown as Schema.Codec<GetEvmSmartAccountByNameOutput>;
-
-// The operation
-/**
- * Get Smart Account by name
- *
- * Gets a Smart Account by its name.
- *
- * @param name - The name of the Smart Account.
- */
-export const getEvmSmartAccountByName = /*@__PURE__*/ API.make(() => ({
-  inputSchema: GetEvmSmartAccountByNameInput,
-  outputSchema: GetEvmSmartAccountByNameOutput,
-}));