@distilled.cloud/coinbase 0.27.0 → 0.28.0

package/src/operations/getPaymentMethod.ts

@@ -0,0 +1,106 @@
+import * as Schema from "effect/Schema";
+import { API } from "../client.ts";
+import * as T from "../traits.ts";
+
+// Input Schema
+export interface GetPaymentMethodInput {
+  paymentMethodId: string;
+}
+export const GetPaymentMethodInput = /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
+  paymentMethodId: Schema.String.pipe(T.PathParam()),
+}).pipe(
+  T.Http({ method: "GET", path: "/v2/payment-methods/{paymentMethodId}" }),
+) as unknown as Schema.Codec<GetPaymentMethodInput>;
+
+// Output Schema
+export type GetPaymentMethodOutput =
+  | {
+      paymentMethodId: string;
+      active: boolean;
+      createdAt: string;
+      updatedAt: string;
+      paymentRail: "fedwire";
+      fedwire: {
+        asset: string;
+        bankName: string;
+        accountLast4: string;
+        routingNumber: string;
+      };
+    }
+  | {
+      paymentMethodId: string;
+      active: boolean;
+      createdAt: string;
+      updatedAt: string;
+      paymentRail: "swift";
+      swift: {
+        asset: string;
+        bankName: string;
+        accountLast4: string;
+        ibanLast4?: string;
+        bic: string;
+      };
+    }
+  | {
+      paymentMethodId: string;
+      active: boolean;
+      createdAt: string;
+      updatedAt: string;
+      paymentRail: "sepa";
+      sepa: { asset: string; bankName: string; ibanLast4: string; bic: string };
+    };
+export const GetPaymentMethodOutput = /*@__PURE__*/ /*#__PURE__*/ Schema.Union([
+  Schema.Struct({
+    paymentMethodId: Schema.String,
+    active: Schema.Boolean,
+    createdAt: Schema.String,
+    updatedAt: Schema.String,
+    paymentRail: Schema.Literals(["fedwire"]),
+    fedwire: Schema.Struct({
+      asset: Schema.String,
+      bankName: Schema.String,
+      accountLast4: Schema.String,
+      routingNumber: Schema.String,
+    }),
+  }),
+  Schema.Struct({
+    paymentMethodId: Schema.String,
+    active: Schema.Boolean,
+    createdAt: Schema.String,
+    updatedAt: Schema.String,
+    paymentRail: Schema.Literals(["swift"]),
+    swift: Schema.Struct({
+      asset: Schema.String,
+      bankName: Schema.String,
+      accountLast4: Schema.String,
+      ibanLast4: Schema.optional(Schema.String),
+      bic: Schema.String,
+    }),
+  }),
+  Schema.Struct({
+    paymentMethodId: Schema.String,
+    active: Schema.Boolean,
+    createdAt: Schema.String,
+    updatedAt: Schema.String,
+    paymentRail: Schema.Literals(["sepa"]),
+    sepa: Schema.Struct({
+      asset: Schema.String,
+      bankName: Schema.String,
+      ibanLast4: Schema.String,
+      bic: Schema.String,
+    }),
+  }),
+]) as unknown as Schema.Codec<GetPaymentMethodOutput>;
+
+// The operation
+/**
+ * Get payment method
+ *
+ * Get details of a specific payment method by its ID. Returns 404 if the payment method is not found or not owned by the requesting entity.
+ *
+ * @param paymentMethodId - The unique identifier of the payment method.
+ */
+export const getPaymentMethod = /*@__PURE__*/ /*#__PURE__*/ API.make(() => ({
+  inputSchema: GetPaymentMethodInput,
+  outputSchema: GetPaymentMethodOutput,
+}));

package/src/operations/getPolicyById.ts

@@ -3,14 +3,24 @@ import { API } from "../client.ts";
 import * as T from "../traits.ts";
 
 // Input Schema
+export interface GetPolicyByIdInput {
+  policyId: string;
+}
 export const GetPolicyByIdInput = /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
   policyId: Schema.String.pipe(T.PathParam()),
 }).pipe(
   T.Http({ method: "GET", path: "/v2/policy-engine/policies/{policyId}" }),
-);
-export type GetPolicyByIdInput = typeof GetPolicyByIdInput.Type;
+) as unknown as Schema.Codec<GetPolicyByIdInput>;
 
 // Output Schema
+export interface GetPolicyByIdOutput {
+  id: string;
+  description?: string;
+  scope: "project" | "account";
+  rules: unknown[];
+  createdAt: string;
+  updatedAt: string;
+}
 export const GetPolicyByIdOutput = /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
   id: Schema.String,
   description: Schema.optional(Schema.String),
@@ -18,12 +28,11 @@ export const GetPolicyByIdOutput = /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
   rules: Schema.Array(Schema.Unknown),
   createdAt: Schema.String,
   updatedAt: Schema.String,
-});
-export type GetPolicyByIdOutput = typeof GetPolicyByIdOutput.Type;
+}) as unknown as Schema.Codec<GetPolicyByIdOutput>;
 
 // The operation
 /**
- * Get a policy by ID
+ * Get policy by ID
  *
  * Get a policy by its ID.
  *

package/src/operations/getSQLGrammar.ts

@@ -3,14 +3,17 @@ import { API } from "../client.ts";
 import * as T from "../traits.ts";
 
 // Input Schema
+export interface GetSQLGrammarInput {}
 export const GetSQLGrammarInput = /*@__PURE__*/ /*#__PURE__*/ Schema.Struct(
   {},
-).pipe(T.Http({ method: "GET", path: "/v2/data/query/grammar" }));
-export type GetSQLGrammarInput = typeof GetSQLGrammarInput.Type;
+).pipe(
+  T.Http({ method: "GET", path: "/v2/data/query/grammar" }),
+) as unknown as Schema.Codec<GetSQLGrammarInput>;
 
 // Output Schema
-export const GetSQLGrammarOutput = /*@__PURE__*/ /*#__PURE__*/ Schema.String;
-export type GetSQLGrammarOutput = typeof GetSQLGrammarOutput.Type;
+export type GetSQLGrammarOutput = string;
+export const GetSQLGrammarOutput =
+  /*@__PURE__*/ /*#__PURE__*/ Schema.String as unknown as Schema.Codec<GetSQLGrammarOutput>;
 
 // The operation
 /**

package/src/operations/getSQLSchema.ts

@@ -3,13 +3,33 @@ import { API } from "../client.ts";
 import * as T from "../traits.ts";
 
 // Input Schema
+export interface GetSQLSchemaInput {
+  database?: "base" | "base_sepolia" | "solana" | "hyperevm";
+  table?: string;
+}
 export const GetSQLSchemaInput = /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
-  database: Schema.optional(Schema.Literals(["base", "base_sepolia"])),
+  database: Schema.optional(
+    Schema.Literals(["base", "base_sepolia", "solana", "hyperevm"]),
+  ),
   table: Schema.optional(Schema.String),
-}).pipe(T.Http({ method: "GET", path: "/v2/data/query/schema" }));
-export type GetSQLSchemaInput = typeof GetSQLSchemaInput.Type;
+}).pipe(
+  T.Http({ method: "GET", path: "/v2/data/query/schema" }),
+) as unknown as Schema.Codec<GetSQLSchemaInput>;
 
 // Output Schema
+export interface GetSQLSchemaOutput {
+  tables?: {
+    database?: string;
+    table?: string;
+    columns?: {
+      name?: string;
+      type?: string;
+      nullable?: boolean;
+      description?: string;
+      indexOrder?: number;
+    }[];
+  }[];
+}
 export const GetSQLSchemaOutput = /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
   tables: Schema.optional(
     Schema.Array(
@@ -30,12 +50,11 @@ export const GetSQLSchemaOutput = /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
       }),
     ),
   ),
-});
-export type GetSQLSchemaOutput = typeof GetSQLSchemaOutput.Type;
+}) as unknown as Schema.Codec<GetSQLSchemaOutput>;
 
 // The operation
 /**
- * Get schemas details
+ * Get schema details
  *
  * Retrieve the schema information for the available tables in the SQL API's indexed data.
  * This includes table names, column definitions, data types, and indexed fields.

package/src/operations/getSolanaAccount.ts

@@ -3,12 +3,23 @@ import { API } from "../client.ts";
 import * as T from "../traits.ts";
 
 // Input Schema
+export interface GetSolanaAccountInput {
+  address: string;
+}
 export const GetSolanaAccountInput = /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
   address: Schema.String.pipe(T.PathParam()),
-}).pipe(T.Http({ method: "GET", path: "/v2/solana/accounts/{address}" }));
-export type GetSolanaAccountInput = typeof GetSolanaAccountInput.Type;
+}).pipe(
+  T.Http({ method: "GET", path: "/v2/solana/accounts/{address}" }),
+) as unknown as Schema.Codec<GetSolanaAccountInput>;
 
 // Output Schema
+export interface GetSolanaAccountOutput {
+  address: string;
+  name?: string;
+  policies?: string[];
+  createdAt?: string;
+  updatedAt?: string;
+}
 export const GetSolanaAccountOutput = /*@__PURE__*/ /*#__PURE__*/ Schema.Struct(
   {
     address: Schema.String,
@@ -17,12 +28,11 @@ export const GetSolanaAccountOutput = /*@__PURE__*/ /*#__PURE__*/ Schema.Struct(
     createdAt: Schema.optional(Schema.String),
     updatedAt: Schema.optional(Schema.String),
   },
-);
-export type GetSolanaAccountOutput = typeof GetSolanaAccountOutput.Type;
+) as unknown as Schema.Codec<GetSolanaAccountOutput>;
 
 // The operation
 /**
- * Get a Solana account by address
+ * Get Solana account by address
  *
  * Gets a Solana account by its address.
  *

package/src/operations/getSolanaAccountByName.ts

@@ -3,16 +3,24 @@ import { API } from "../client.ts";
 import * as T from "../traits.ts";
 
 // Input Schema
+export interface GetSolanaAccountByNameInput {
+  name: string;
+}
 export const GetSolanaAccountByNameInput =
   /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
     name: Schema.String.pipe(T.PathParam()),
   }).pipe(
     T.Http({ method: "GET", path: "/v2/solana/accounts/by-name/{name}" }),
-  );
-export type GetSolanaAccountByNameInput =
-  typeof GetSolanaAccountByNameInput.Type;
+  ) as unknown as Schema.Codec<GetSolanaAccountByNameInput>;
 
 // Output Schema
+export interface GetSolanaAccountByNameOutput {
+  address: string;
+  name?: string;
+  policies?: string[];
+  createdAt?: string;
+  updatedAt?: string;
+}
 export const GetSolanaAccountByNameOutput =
   /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
     address: Schema.String,
@@ -20,13 +28,11 @@ export const GetSolanaAccountByNameOutput =
     policies: Schema.optional(Schema.Array(Schema.String)),
     createdAt: Schema.optional(Schema.String),
     updatedAt: Schema.optional(Schema.String),
-  });
-export type GetSolanaAccountByNameOutput =
-  typeof GetSolanaAccountByNameOutput.Type;
+  }) as unknown as Schema.Codec<GetSolanaAccountByNameOutput>;
 
 // The operation
 /**
- * Get a Solana account by name
+ * Get Solana account by name
  *
  * Gets a Solana account by its name.
  *

package/src/operations/getTransferById.ts

@@ -0,0 +1,274 @@
+import * as Schema from "effect/Schema";
+import { API } from "../client.ts";
+import * as T from "../traits.ts";
+
+// Input Schema
+export interface GetTransferByIdInput {
+  transferId: string;
+}
+export const GetTransferByIdInput = /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
+  transferId: Schema.String.pipe(T.PathParam()),
+}).pipe(
+  T.Http({ method: "GET", path: "/v2/transfers/{transferId}" }),
+) as unknown as Schema.Codec<GetTransferByIdInput>;
+
+// Output Schema
+export interface GetTransferByIdOutput {
+  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 GetTransferByIdOutput = /*@__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<GetTransferByIdOutput>;
+
+// The operation
+/**
+ * Get transfer
+ *
+ * Get a transfer by its ID.
+ *
+ * @param transferId - The unique identifier of the transfer.
+ */
+export const getTransferById = /*@__PURE__*/ /*#__PURE__*/ API.make(() => ({
+  inputSchema: GetTransferByIdInput,
+  outputSchema: GetTransferByIdOutput,
+}));

package/src/operations/getUserOperation.ts

@@ -3,6 +3,10 @@ import { API } from "../client.ts";
 import * as T from "../traits.ts";
 
 // Input Schema
+export interface GetUserOperationInput {
+  address: string;
+  userOpHash: string;
+}
 export const GetUserOperationInput = /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
   address: Schema.String.pipe(T.PathParam()),
   userOpHash: Schema.String.pipe(T.PathParam()),
@@ -11,10 +15,45 @@ export const GetUserOperationInput = /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
     method: "GET",
     path: "/v2/evm/smart-accounts/{address}/user-operations/{userOpHash}",
   }),
-);
-export type GetUserOperationInput = typeof GetUserOperationInput.Type;
+) as unknown as Schema.Codec<GetUserOperationInput>;
 
 // Output Schema
+export interface GetUserOperationOutput {
+  network:
+    | "base-sepolia"
+    | "base"
+    | "arbitrum"
+    | "optimism"
+    | "zora"
+    | "polygon"
+    | "bnb"
+    | "avalanche"
+    | "ethereum"
+    | "ethereum-sepolia";
+  userOpHash: string;
+  calls: {
+    to: string;
+    value: string;
+    data: string;
+    overrideGasLimit?: string;
+  }[];
+  status:
+    | "pending"
+    | "signed"
+    | "broadcast"
+    | "complete"
+    | "dropped"
+    | "failed";
+  transactionHash?: string;
+  receipts?: {
+    revert?: { data: string; message: string };
+    transactionHash?: string;
+    blockHash?: string;
+    blockNumber?: number;
+    gasUsed?: string;
+  }[];
+  expiresAt?: string;
+}
 export const GetUserOperationOutput = /*@__PURE__*/ /*#__PURE__*/ Schema.Struct(
   {
     network: Schema.Literals([
@@ -63,13 +102,13 @@ export const GetUserOperationOutput = /*@__PURE__*/ /*#__PURE__*/ Schema.Struct(
         }),
       ),
     ),
+    expiresAt: Schema.optional(Schema.String),
   },
-);
-export type GetUserOperationOutput = typeof GetUserOperationOutput.Type;
+) as unknown as Schema.Codec<GetUserOperationOutput>;
 
 // The operation
 /**
- * Get a user operation
+ * Get user operation
  *
  * Gets a user operation by its hash.
  *