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

package/src/operations/getEvmSwapPrice.ts

@@ -1,112 +0,0 @@
-import * as Schema from "effect/Schema";
-import { API } from "../client.ts";
-import * as T from "../traits.ts";
-
-// Input Schema
-export interface GetEvmSwapPriceInput {
-  network: string;
-  toToken: string;
-  fromToken: string;
-  fromAmount: string;
-  taker: string;
-  signerAddress?: string;
-  gasPrice?: string;
-  slippageBps?: string;
-}
-export const GetEvmSwapPriceInput = /*@__PURE__*/ Schema.Struct({
-  network: Schema.String,
-  toToken: Schema.String,
-  fromToken: Schema.String,
-  fromAmount: Schema.String,
-  taker: Schema.String,
-  signerAddress: Schema.optional(Schema.String),
-  gasPrice: Schema.optional(Schema.String),
-  slippageBps: Schema.optional(Schema.String),
-}).pipe(
-  T.Http({ method: "GET", path: "/v2/evm/swaps/quote" }),
-) as unknown as Schema.Codec<GetEvmSwapPriceInput>;
-
-// Output Schema
-export type GetEvmSwapPriceOutput =
-  | {
-      blockNumber: string;
-      toAmount: string;
-      toToken: string;
-      fees: {
-        gasFee: { amount: string; token: string } | null;
-        protocolFee: { amount: string; token: string } | null;
-      };
-      issues: {
-        allowance: { currentAllowance: string; spender: string } | null;
-        balance: {
-          token: string;
-          currentBalance: string;
-          requiredBalance: string;
-        } | null;
-        simulationIncomplete: boolean;
-      };
-      liquidityAvailable: true;
-      minToAmount: string;
-      fromAmount: string;
-      fromToken: string;
-      gas: string | null;
-      gasPrice: string;
-    }
-  | { liquidityAvailable: false };
-export const GetEvmSwapPriceOutput = /*@__PURE__*/ Schema.Union([
-  Schema.Struct({
-    blockNumber: Schema.String,
-    toAmount: Schema.String,
-    toToken: Schema.String,
-    fees: Schema.Struct({
-      gasFee: Schema.NullOr(
-        Schema.Struct({
-          amount: Schema.String,
-          token: Schema.String,
-        }),
-      ),
-      protocolFee: Schema.NullOr(
-        Schema.Struct({
-          amount: Schema.String,
-          token: Schema.String,
-        }),
-      ),
-    }),
-    issues: Schema.Struct({
-      allowance: Schema.NullOr(
-        Schema.Struct({
-          currentAllowance: Schema.String,
-          spender: Schema.String,
-        }),
-      ),
-      balance: Schema.NullOr(
-        Schema.Struct({
-          token: Schema.String,
-          currentBalance: Schema.String,
-          requiredBalance: Schema.String,
-        }),
-      ),
-      simulationIncomplete: Schema.Boolean,
-    }),
-    liquidityAvailable: Schema.Literals([true]),
-    minToAmount: Schema.String,
-    fromAmount: Schema.String,
-    fromToken: Schema.String,
-    gas: Schema.NullOr(Schema.String),
-    gasPrice: Schema.String,
-  }),
-  Schema.Struct({
-    liquidityAvailable: Schema.Literals([false]),
-  }),
-]) as unknown as Schema.Codec<GetEvmSwapPriceOutput>;
-
-// The operation
-/**
- * Get swap price estimate
- *
- * Get a price estimate for a swap between two tokens on an EVM network.
- */
-export const getEvmSwapPrice = /*@__PURE__*/ API.make(() => ({
-  inputSchema: GetEvmSwapPriceInput,
-  outputSchema: GetEvmSwapPriceOutput,
-}));

package/src/operations/getFoundationAccountById.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 GetFoundationAccountByIdInput {
-  accountId: string;
-}
-export const GetFoundationAccountByIdInput =
-  /*@__PURE__*/ Schema.Struct({
-    accountId: Schema.String.pipe(T.PathParam()),
-  }).pipe(
-    T.Http({ method: "GET", path: "/v2/accounts/{accountId}" }),
-  ) as unknown as Schema.Codec<GetFoundationAccountByIdInput>;
-
-// Output Schema
-export interface GetFoundationAccountByIdOutput {
-  accountId: string;
-  type: "prime" | "business" | "cdp";
-  owner: string;
-  name?: string;
-  createdAt: string;
-  updatedAt: string;
-}
-export const GetFoundationAccountByIdOutput =
-  /*@__PURE__*/ Schema.Struct({
-    accountId: Schema.String,
-    type: Schema.Literals(["prime", "business", "cdp"]),
-    owner: Schema.String,
-    name: Schema.optional(Schema.String),
-    createdAt: Schema.String,
-    updatedAt: Schema.String,
-  }) as unknown as Schema.Codec<GetFoundationAccountByIdOutput>;
-
-// The operation
-/**
- * Get account
- *
- * Get an account by its ID.
- *
- * @param accountId - The ID of the account to retrieve.
- */
-export const getFoundationAccountById = /*@__PURE__*/ API.make(() => ({
-  inputSchema: GetFoundationAccountByIdInput,
-  outputSchema: GetFoundationAccountByIdOutput,
-}));

package/src/operations/getOnrampOrderById.ts

@@ -1,94 +0,0 @@
-import * as Schema from "effect/Schema";
-import { API } from "../client.ts";
-import * as T from "../traits.ts";
-
-// Input Schema
-export interface GetOnrampOrderByIdInput {
-  orderId: string;
-}
-export const GetOnrampOrderByIdInput =
-  /*@__PURE__*/ Schema.Struct({
-    orderId: Schema.String.pipe(T.PathParam()),
-  }).pipe(
-    T.Http({ method: "GET", path: "/v2/onramp/orders/{orderId}" }),
-  ) as unknown as Schema.Codec<GetOnrampOrderByIdInput>;
-
-// Output Schema
-export interface GetOnrampOrderByIdOutput {
-  order: {
-    orderId: string;
-    paymentTotal: string;
-    paymentSubtotal: string;
-    paymentCurrency: string;
-    paymentMethod: "GUEST_CHECKOUT_APPLE_PAY" | "GUEST_CHECKOUT_GOOGLE_PAY";
-    purchaseAmount: string;
-    purchaseCurrency: string;
-    fees: {
-      type: "FEE_TYPE_NETWORK" | "FEE_TYPE_EXCHANGE";
-      amount: string;
-      currency: string;
-    }[];
-    exchangeRate: string;
-    destinationAddress: string;
-    destinationNetwork: string;
-    status:
-      | "ONRAMP_ORDER_STATUS_PENDING_AUTH"
-      | "ONRAMP_ORDER_STATUS_PENDING_PAYMENT"
-      | "ONRAMP_ORDER_STATUS_PROCESSING"
-      | "ONRAMP_ORDER_STATUS_COMPLETED"
-      | "ONRAMP_ORDER_STATUS_FAILED";
-    txHash?: string;
-    createdAt: string;
-    updatedAt: string;
-    partnerUserRef?: string;
-  };
-}
-export const GetOnrampOrderByIdOutput =
-  /*@__PURE__*/ Schema.Struct({
-    order: Schema.Struct({
-      orderId: Schema.String,
-      paymentTotal: Schema.String,
-      paymentSubtotal: Schema.String,
-      paymentCurrency: Schema.String,
-      paymentMethod: Schema.Literals([
-        "GUEST_CHECKOUT_APPLE_PAY",
-        "GUEST_CHECKOUT_GOOGLE_PAY",
-      ]),
-      purchaseAmount: Schema.String,
-      purchaseCurrency: Schema.String,
-      fees: Schema.Array(
-        Schema.Struct({
-          type: Schema.Literals(["FEE_TYPE_NETWORK", "FEE_TYPE_EXCHANGE"]),
-          amount: Schema.String,
-          currency: Schema.String,
-        }),
-      ),
-      exchangeRate: Schema.String,
-      destinationAddress: Schema.String,
-      destinationNetwork: Schema.String,
-      status: Schema.Literals([
-        "ONRAMP_ORDER_STATUS_PENDING_AUTH",
-        "ONRAMP_ORDER_STATUS_PENDING_PAYMENT",
-        "ONRAMP_ORDER_STATUS_PROCESSING",
-        "ONRAMP_ORDER_STATUS_COMPLETED",
-        "ONRAMP_ORDER_STATUS_FAILED",
-      ]),
-      txHash: Schema.optional(Schema.String),
-      createdAt: Schema.String,
-      updatedAt: Schema.String,
-      partnerUserRef: Schema.optional(Schema.String),
-    }),
-  }) as unknown as Schema.Codec<GetOnrampOrderByIdOutput>;
-
-// The operation
-/**
- * Get an onramp order by ID
- *
- * Get an onramp order by ID.
- *
- * @param orderId - The ID of the onramp order to retrieve.
- */
-export const getOnrampOrderById = /*@__PURE__*/ API.make(() => ({
-  inputSchema: GetOnrampOrderByIdInput,
-  outputSchema: GetOnrampOrderByIdOutput,
-}));

package/src/operations/getOnrampUserLimits.ts

@@ -1,57 +0,0 @@
-import * as Schema from "effect/Schema";
-import { API } from "../client.ts";
-import * as T from "../traits.ts";
-
-// Input Schema
-export interface GetOnrampUserLimitsInput {
-  paymentMethodType: "GUEST_CHECKOUT_APPLE_PAY" | "GUEST_CHECKOUT_GOOGLE_PAY";
-  userId: string;
-  userIdType: "phone_number";
-}
-export const GetOnrampUserLimitsInput =
-  /*@__PURE__*/ Schema.Struct({
-    paymentMethodType: Schema.Literals([
-      "GUEST_CHECKOUT_APPLE_PAY",
-      "GUEST_CHECKOUT_GOOGLE_PAY",
-    ]),
-    userId: Schema.String,
-    userIdType: Schema.Literals(["phone_number"]),
-  }).pipe(
-    T.Http({ method: "POST", path: "/v2/onramp/limits" }),
-  ) as unknown as Schema.Codec<GetOnrampUserLimitsInput>;
-
-// Output Schema
-export interface GetOnrampUserLimitsOutput {
-  limits: {
-    limitType: "weekly_spending" | "lifetime_transactions";
-    currency?: string;
-    limit: string;
-    remaining: string;
-  }[];
-}
-export const GetOnrampUserLimitsOutput =
-  /*@__PURE__*/ Schema.Struct({
-    limits: Schema.Array(
-      Schema.Struct({
-        limitType: Schema.Literals([
-          "weekly_spending",
-          "lifetime_transactions",
-        ]),
-        currency: Schema.optional(Schema.String),
-        limit: Schema.String,
-        remaining: Schema.String,
-      }),
-    ),
-  }) as unknown as Schema.Codec<GetOnrampUserLimitsOutput>;
-
-// The operation
-/**
- * Get onramp user limits
- *
- * Returns the transaction limits for an onramp user based on their payment method and user identifier. Use this API to show users their remaining purchase capacity before initiating an onramp transaction.
- * Currently supports `GUEST_CHECKOUT_APPLE_PAY` payment method with phone number identification. The phone number must have been previously verified via OTP.
- */
-export const getOnrampUserLimits = /*@__PURE__*/ API.make(() => ({
-  inputSchema: GetOnrampUserLimitsInput,
-  outputSchema: GetOnrampUserLimitsOutput,
-}));

package/src/operations/getPaymentMethod.ts

@@ -1,106 +0,0 @@
-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__*/ 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__*/ 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__*/ API.make(() => ({
-  inputSchema: GetPaymentMethodInput,
-  outputSchema: GetPaymentMethodOutput,
-}));

package/src/operations/getPolicyById.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 GetPolicyByIdInput {
-  policyId: string;
-}
-export const GetPolicyByIdInput = /*@__PURE__*/ Schema.Struct({
-  policyId: Schema.String.pipe(T.PathParam()),
-}).pipe(
-  T.Http({ method: "GET", path: "/v2/policy-engine/policies/{policyId}" }),
-) 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__*/ Schema.Struct({
-  id: Schema.String,
-  description: Schema.optional(Schema.String),
-  scope: Schema.Literals(["project", "account"]),
-  rules: Schema.Array(Schema.Unknown),
-  createdAt: Schema.String,
-  updatedAt: Schema.String,
-}) as unknown as Schema.Codec<GetPolicyByIdOutput>;
-
-// The operation
-/**
- * Get policy by ID
- *
- * Get a policy by its ID.
- *
- * @param policyId - The ID of the policy to get.
- */
-export const getPolicyById = /*@__PURE__*/ API.make(() => ({
-  inputSchema: GetPolicyByIdInput,
-  outputSchema: GetPolicyByIdOutput,
-}));

package/src/operations/getSQLGrammar.ts

@@ -1,28 +0,0 @@
-import * as Schema from "effect/Schema";
-import { API } from "../client.ts";
-import * as T from "../traits.ts";
-
-// Input Schema
-export interface GetSQLGrammarInput {}
-export const GetSQLGrammarInput = /*@__PURE__*/ Schema.Struct({}).pipe(
-  T.Http({ method: "GET", path: "/v2/data/query/grammar" }),
-) as unknown as Schema.Codec<GetSQLGrammarInput>;
-
-// Output Schema
-export type GetSQLGrammarOutput = string;
-export const GetSQLGrammarOutput =
-  /*@__PURE__*/ Schema.String as unknown as Schema.Codec<GetSQLGrammarOutput>;
-
-// The operation
-/**
- * Get SQL grammar
- *
- * Retrieve the SQL grammar for the SQL API.
- * The SQL queries that are supported by the SQL API are defined in ANTLR4 grammar which is evaluated by server before executing the query. This ensures the safety and soundness of the SQL query before execution.
- * This endpoint returns the ANTLR4 grammar that is used to evaluate the SQL queries so that developers can understand the SQL API and build SQL queries with high confidence and correctness.
- * LLMs interact well with ANTLR4 grammar. You can feed the grammar directly into the LLMs to help generate SQL queries.
- */
-export const getSQLGrammar = /*@__PURE__*/ API.make(() => ({
-  inputSchema: GetSQLGrammarInput,
-  outputSchema: GetSQLGrammarOutput,
-}));

package/src/operations/getSQLSchema.ts

@@ -1,68 +0,0 @@
-import * as Schema from "effect/Schema";
-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__*/ Schema.Struct({
-  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" }),
-) 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__*/ Schema.Struct({
-  tables: Schema.optional(
-    Schema.Array(
-      Schema.Struct({
-        database: Schema.optional(Schema.String),
-        table: Schema.optional(Schema.String),
-        columns: Schema.optional(
-          Schema.Array(
-            Schema.Struct({
-              name: Schema.optional(Schema.String),
-              type: Schema.optional(Schema.String),
-              nullable: Schema.optional(Schema.Boolean),
-              description: Schema.optional(Schema.String),
-              indexOrder: Schema.optional(Schema.Number),
-            }),
-          ),
-        ),
-      }),
-    ),
-  ),
-}) as unknown as Schema.Codec<GetSQLSchemaOutput>;
-
-// The operation
-/**
- * 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.
- *
- * @param database - The name of the database to query. Defaults to "base" when not specified.
- * @param table - Get the schema for a specific table.
- */
-export const getSQLSchema = /*@__PURE__*/ API.make(() => ({
-  inputSchema: GetSQLSchemaInput,
-  outputSchema: GetSQLSchemaOutput,
-}));

package/src/operations/getSolanaAccount.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 GetSolanaAccountInput {
-  address: string;
-}
-export const GetSolanaAccountInput = /*@__PURE__*/ Schema.Struct({
-  address: Schema.String.pipe(T.PathParam()),
-}).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__*/ 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<GetSolanaAccountOutput>;
-
-// The operation
-/**
- * Get Solana account by address
- *
- * Gets a Solana account by its address.
- *
- * @param address - The base58 encoded address of the Solana account.
- */
-export const getSolanaAccount = /*@__PURE__*/ API.make(() => ({
-  inputSchema: GetSolanaAccountInput,
-  outputSchema: GetSolanaAccountOutput,
-}));

package/src/operations/getSolanaAccountByName.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 GetSolanaAccountByNameInput {
-  name: string;
-}
-export const GetSolanaAccountByNameInput =
-  /*@__PURE__*/ Schema.Struct({
-    name: Schema.String.pipe(T.PathParam()),
-  }).pipe(
-    T.Http({ method: "GET", path: "/v2/solana/accounts/by-name/{name}" }),
-  ) 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__*/ 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<GetSolanaAccountByNameOutput>;
-
-// The operation
-/**
- * Get Solana account by name
- *
- * Gets a Solana account by its name.
- *
- * @param name - The name of the Solana account.
- */
-export const getSolanaAccountByName = /*@__PURE__*/ API.make(() => ({
-  inputSchema: GetSolanaAccountByNameInput,
-  outputSchema: GetSolanaAccountByNameOutput,
-}));