@distilled.cloud/coinbase 0.26.1 → 0.28.0

package/src/operations/deletePolicy.ts

@@ -3,20 +3,23 @@ import { API } from "../client.ts";
 import * as T from "../traits.ts";
 
 // Input Schema
+export interface DeletePolicyInput {
+  policyId: string;
+}
 export const DeletePolicyInput = /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
   policyId: Schema.String.pipe(T.PathParam()),
 }).pipe(
   T.Http({ method: "DELETE", path: "/v2/policy-engine/policies/{policyId}" }),
-);
-export type DeletePolicyInput = typeof DeletePolicyInput.Type;
+) as unknown as Schema.Codec<DeletePolicyInput>;
 
 // Output Schema
-export const DeletePolicyOutput = /*@__PURE__*/ /*#__PURE__*/ Schema.Void;
-export type DeletePolicyOutput = typeof DeletePolicyOutput.Type;
+export type DeletePolicyOutput = void;
+export const DeletePolicyOutput =
+  /*@__PURE__*/ /*#__PURE__*/ Schema.Void as unknown as Schema.Codec<DeletePolicyOutput>;
 
 // The operation
 /**
- * Delete a policy
+ * Delete policy
  *
  * Delete a policy by its ID. This will have the effect of removing the policy from all accounts that are currently using it.
  *

package/src/operations/deleteWebhookSubscription.ts

@@ -3,6 +3,9 @@ import { API } from "../client.ts";
 import * as T from "../traits.ts";
 
 // Input Schema
+export interface DeleteWebhookSubscriptionInput {
+  subscriptionId: string;
+}
 export const DeleteWebhookSubscriptionInput =
   /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
     subscriptionId: Schema.String.pipe(T.PathParam()),
@@ -11,15 +14,12 @@ export const DeleteWebhookSubscriptionInput =
       method: "DELETE",
       path: "/v2/data/webhooks/subscriptions/{subscriptionId}",
     }),
-  );
-export type DeleteWebhookSubscriptionInput =
-  typeof DeleteWebhookSubscriptionInput.Type;
+  ) as unknown as Schema.Codec<DeleteWebhookSubscriptionInput>;
 
 // Output Schema
+export type DeleteWebhookSubscriptionOutput = void;
 export const DeleteWebhookSubscriptionOutput =
-  /*@__PURE__*/ /*#__PURE__*/ Schema.Void;
-export type DeleteWebhookSubscriptionOutput =
-  typeof DeleteWebhookSubscriptionOutput.Type;
+  /*@__PURE__*/ /*#__PURE__*/ Schema.Void as unknown as Schema.Codec<DeleteWebhookSubscriptionOutput>;
 
 // The operation
 /**

package/src/operations/executeFundTransfer.ts

@@ -0,0 +1,282 @@
+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__*/ /*#__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__*/ /*#__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__*/ /*#__PURE__*/ API.make(() => ({
+  inputSchema: ExecuteFundTransferInput,
+  outputSchema: ExecuteFundTransferOutput,
+}));

package/src/operations/exportEvmAccount.ts

@@ -3,23 +3,30 @@ import { API } from "../client.ts";
 import * as T from "../traits.ts";
 
 // Input Schema
+export interface ExportEvmAccountInput {
+  address: string;
+  exportEncryptionKey: string;
+}
 export const ExportEvmAccountInput = /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
   address: Schema.String.pipe(T.PathParam()),
   exportEncryptionKey: Schema.String,
-}).pipe(T.Http({ method: "POST", path: "/v2/evm/accounts/{address}/export" }));
-export type ExportEvmAccountInput = typeof ExportEvmAccountInput.Type;
+}).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__*/ /*#__PURE__*/ Schema.Struct(
   {
     encryptedPrivateKey: Schema.String,
   },
-);
-export type ExportEvmAccountOutput = typeof ExportEvmAccountOutput.Type;
+) as unknown as Schema.Codec<ExportEvmAccountOutput>;
 
 // The operation
 /**
- * Export an EVM account
+ * 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.
  *

package/src/operations/exportEvmAccountByName.ts

@@ -3,27 +3,30 @@ import { API } from "../client.ts";
 import * as T from "../traits.ts";
 
 // Input Schema
+export interface ExportEvmAccountByNameInput {
+  name: string;
+  exportEncryptionKey: string;
+}
 export const ExportEvmAccountByNameInput =
   /*@__PURE__*/ /*#__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}" }),
-  );
-export type ExportEvmAccountByNameInput =
-  typeof ExportEvmAccountByNameInput.Type;
+  ) as unknown as Schema.Codec<ExportEvmAccountByNameInput>;
 
 // Output Schema
+export interface ExportEvmAccountByNameOutput {
+  encryptedPrivateKey: string;
+}
 export const ExportEvmAccountByNameOutput =
   /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
     encryptedPrivateKey: Schema.String,
-  });
-export type ExportEvmAccountByNameOutput =
-  typeof ExportEvmAccountByNameOutput.Type;
+  }) as unknown as Schema.Codec<ExportEvmAccountByNameOutput>;
 
 // The operation
 /**
- * Export an EVM account by name
+ * 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.
  *

package/src/operations/exportSolanaAccount.ts

@@ -3,25 +3,30 @@ import { API } from "../client.ts";
 import * as T from "../traits.ts";
 
 // Input Schema
+export interface ExportSolanaAccountInput {
+  address: string;
+  exportEncryptionKey: string;
+}
 export const ExportSolanaAccountInput =
   /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
     address: Schema.String.pipe(T.PathParam()),
     exportEncryptionKey: Schema.String,
   }).pipe(
     T.Http({ method: "POST", path: "/v2/solana/accounts/{address}/export" }),
-  );
-export type ExportSolanaAccountInput = typeof ExportSolanaAccountInput.Type;
+  ) as unknown as Schema.Codec<ExportSolanaAccountInput>;
 
 // Output Schema
+export interface ExportSolanaAccountOutput {
+  encryptedPrivateKey: string;
+}
 export const ExportSolanaAccountOutput =
   /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
     encryptedPrivateKey: Schema.String,
-  });
-export type ExportSolanaAccountOutput = typeof ExportSolanaAccountOutput.Type;
+  }) as unknown as Schema.Codec<ExportSolanaAccountOutput>;
 
 // The operation
 /**
- * Export an Solana account
+ * 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.
  *

package/src/operations/exportSolanaAccountByName.ts

@@ -3,6 +3,10 @@ import { API } from "../client.ts";
 import * as T from "../traits.ts";
 
 // Input Schema
+export interface ExportSolanaAccountByNameInput {
+  name: string;
+  exportEncryptionKey: string;
+}
 export const ExportSolanaAccountByNameInput =
   /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
     name: Schema.String.pipe(T.PathParam()),
@@ -12,21 +16,20 @@ export const ExportSolanaAccountByNameInput =
       method: "POST",
       path: "/v2/solana/accounts/export/by-name/{name}",
     }),
-  );
-export type ExportSolanaAccountByNameInput =
-  typeof ExportSolanaAccountByNameInput.Type;
+  ) as unknown as Schema.Codec<ExportSolanaAccountByNameInput>;
 
 // Output Schema
+export interface ExportSolanaAccountByNameOutput {
+  encryptedPrivateKey: string;
+}
 export const ExportSolanaAccountByNameOutput =
   /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
     encryptedPrivateKey: Schema.String,
-  });
-export type ExportSolanaAccountByNameOutput =
-  typeof ExportSolanaAccountByNameOutput.Type;
+  }) as unknown as Schema.Codec<ExportSolanaAccountByNameOutput>;
 
 // The operation
 /**
- * Export a Solana account by name
+ * 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.
  *

package/src/operations/getBalanceByAsset.ts

@@ -0,0 +1,58 @@
+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__*/ /*#__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__*/ /*#__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__*/ /*#__PURE__*/ API.make(() => ({
+  inputSchema: GetBalanceByAssetInput,
+  outputSchema: GetBalanceByAssetOutput,
+}));

package/src/operations/getDelegationForEndUser.ts

@@ -3,6 +3,10 @@ import { API } from "../client.ts";
 import * as T from "../traits.ts";
 
 // Input Schema
+export interface GetDelegationForEndUserInput {
+  userId: string;
+  projectID?: string;
+}
 export const GetDelegationForEndUserInput =
   /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
     userId: Schema.String.pipe(T.PathParam()),
@@ -12,17 +16,16 @@ export const GetDelegationForEndUserInput =
       method: "GET",
       path: "/v2/embedded-wallet-api/end-users/{userId}/delegation",
     }),
-  );
-export type GetDelegationForEndUserInput =
-  typeof GetDelegationForEndUserInput.Type;
+  ) as unknown as Schema.Codec<GetDelegationForEndUserInput>;
 
 // Output Schema
+export interface GetDelegationForEndUserOutput {
+  expiresAt: string;
+}
 export const GetDelegationForEndUserOutput =
   /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
     expiresAt: Schema.String,
-  });
-export type GetDelegationForEndUserOutput =
-  typeof GetDelegationForEndUserOutput.Type;
+  }) as unknown as Schema.Codec<GetDelegationForEndUserOutput>;
 
 // The operation
 /**

package/src/operations/getDelegationForEndUserAccount.ts

@@ -0,0 +1,47 @@
+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__*/ /*#__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__*/ /*#__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__*/ /*#__PURE__*/ API.make(() => ({
+    inputSchema: GetDelegationForEndUserAccountInput,
+    outputSchema: GetDelegationForEndUserAccountOutput,
+  }));