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

package/src/operations/sendEvmAssetWithEndUserAccount.ts

@@ -1,103 +0,0 @@
-import * as Schema from "effect/Schema";
-import { API } from "../client.ts";
-import * as T from "../traits.ts";
-
-// Input Schema
-export interface SendEvmAssetWithEndUserAccountInput {
-  userId: string;
-  address: string;
-  asset: "usdc";
-  projectID?: string;
-  to: string;
-  amount: string;
-  network:
-    | "base"
-    | "base-sepolia"
-    | "ethereum"
-    | "ethereum-sepolia"
-    | "avalanche"
-    | "polygon"
-    | "optimism"
-    | "arbitrum"
-    | "arbitrum-sepolia"
-    | "world"
-    | "world-sepolia";
-  useCdpPaymaster?: boolean;
-  paymasterUrl?: string;
-  paymasterContext?: Record<string, unknown>;
-  walletSecretId?: string;
-}
-export const SendEvmAssetWithEndUserAccountInput =
-  /*@__PURE__*/ Schema.Struct({
-    userId: Schema.String.pipe(T.PathParam()),
-    address: Schema.String.pipe(T.PathParam()),
-    asset: Schema.Literals(["usdc"]).pipe(T.PathParam()),
-    projectID: Schema.optional(Schema.String),
-    to: Schema.String,
-    amount: Schema.String,
-    network: Schema.Literals([
-      "base",
-      "base-sepolia",
-      "ethereum",
-      "ethereum-sepolia",
-      "avalanche",
-      "polygon",
-      "optimism",
-      "arbitrum",
-      "arbitrum-sepolia",
-      "world",
-      "world-sepolia",
-    ]),
-    useCdpPaymaster: Schema.optional(Schema.Boolean),
-    paymasterUrl: Schema.optional(Schema.String),
-    paymasterContext: Schema.optional(
-      Schema.Record(Schema.String, Schema.Unknown),
-    ),
-    walletSecretId: Schema.optional(Schema.String),
-  }).pipe(
-    T.Http({
-      method: "POST",
-      path: "/v2/embedded-wallet-api/end-users/{userId}/evm/{address}/send/{asset}",
-    }),
-  ) as unknown as Schema.Codec<SendEvmAssetWithEndUserAccountInput>;
-
-// Output Schema
-export interface SendEvmAssetWithEndUserAccountOutput {
-  transactionHash?: string | null;
-  userOpHash?: string | null;
-}
-export const SendEvmAssetWithEndUserAccountOutput =
-  /*@__PURE__*/ Schema.Struct({
-    transactionHash: Schema.optional(Schema.NullOr(Schema.String)),
-    userOpHash: Schema.optional(Schema.NullOr(Schema.String)),
-  }) as unknown as Schema.Codec<SendEvmAssetWithEndUserAccountOutput>;
-
-// The operation
-/**
- * Send USDC on EVM
- *
- * Sends USDC from an end user's EVM account (EOA or Smart Account) to a recipient address on a supported EVM network. This endpoint simplifies USDC transfers by automatically handling contract resolution, decimal conversion, gas estimation, and transaction encoding.
- * The `amount` field accepts human-readable amounts as decimal strings (e.g., "1.5", "25.50").
- *
- * @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 userId - The ID of the end user.
- * @param address - The 0x-prefixed address of the EVM account (EOA or Smart Account) to send USDC from. The address does not need to be checksummed.
- * @param asset - The asset to send. Currently only "usdc" is supported.
- * @param X-Developer-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 projectID - The ID of the CDP Project. Required for end users authenticated using custom auth (i.e. a non-CDP JWT provider).
- */
-export const sendEvmAssetWithEndUserAccount =
-  /*@__PURE__*/ API.make(() => ({
-    inputSchema: SendEvmAssetWithEndUserAccountInput,
-    outputSchema: SendEvmAssetWithEndUserAccountOutput,
-  }));

package/src/operations/sendEvmTransaction.ts

@@ -1,90 +0,0 @@
-import * as Schema from "effect/Schema";
-import { API } from "../client.ts";
-import * as T from "../traits.ts";
-
-// Input Schema
-export interface SendEvmTransactionInput {
-  address: string;
-  network:
-    | "base"
-    | "base-sepolia"
-    | "ethereum"
-    | "ethereum-sepolia"
-    | "avalanche"
-    | "polygon"
-    | "optimism"
-    | "arbitrum"
-    | "arbitrum-sepolia"
-    | "world"
-    | "world-sepolia";
-  transaction: string;
-}
-export const SendEvmTransactionInput =
-  /*@__PURE__*/ Schema.Struct({
-    address: Schema.String.pipe(T.PathParam()),
-    network: Schema.Literals([
-      "base",
-      "base-sepolia",
-      "ethereum",
-      "ethereum-sepolia",
-      "avalanche",
-      "polygon",
-      "optimism",
-      "arbitrum",
-      "arbitrum-sepolia",
-      "world",
-      "world-sepolia",
-    ]),
-    transaction: Schema.String,
-  }).pipe(
-    T.Http({
-      method: "POST",
-      path: "/v2/evm/accounts/{address}/send/transaction",
-    }),
-  ) as unknown as Schema.Codec<SendEvmTransactionInput>;
-
-// Output Schema
-export interface SendEvmTransactionOutput {
-  transactionHash: string;
-}
-export const SendEvmTransactionOutput =
-  /*@__PURE__*/ Schema.Struct({
-    transactionHash: Schema.String,
-  }) as unknown as Schema.Codec<SendEvmTransactionOutput>;
-
-// The operation
-/**
- * Send transaction
- *
- * Signs a transaction with the given EVM account and sends it to the indicated supported network. This API handles nonce management and gas estimation, leaving the developer to provide only the minimal set of fields necessary to send the transaction. The transaction should be serialized as a hex string using [RLP](https://ethereum.org/en/developers/docs/data-structures-and-encoding/rlp/).
- * The transaction must be an [EIP-1559 dynamic fee transaction](https://github.com/ethereum/EIPs/blob/master/EIPS/eip-1559.md).
- * **Transaction fields and API behavior**
- * - `to` *(Required)*: The address of the contract or account to send the transaction to.
- * - `chainId` *(Ignored)*: The value of the `chainId` field in the transaction is ignored.
- * The transaction will be sent to the network indicated by the `network` field in the request body.
- * - `nonce` *(Optional)*: The nonce to use for the transaction. If not provided, the API will assign
- * a nonce to the transaction based on the current state of the account.
- * - `maxPriorityFeePerGas` *(Optional)*: The maximum priority fee per gas to use for the transaction.
- * If not provided, the API will estimate a value based on current network conditions.
- * - `maxFeePerGas` *(Optional)*: The maximum fee per gas to use for the transaction.
- * If not provided, the API will estimate a value based on current network conditions.
- * - `gasLimit` *(Optional)*: The gas limit to use for the transaction. If not provided, the API will estimate a value
- * based on the `to` and `data` fields of the transaction.
- * - `value` *(Optional)*: The amount of ETH, in wei, to send with the transaction.
- * - `data` *(Optional)*: The data to send with the transaction; only used for contract calls.
- * - `accessList` *(Optional)*: The access list to use for the transaction.
- *
- * @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 address - The 0x-prefixed address of the Ethereum account.
- */
-export const sendEvmTransaction = /*@__PURE__*/ API.make(() => ({
-  inputSchema: SendEvmTransactionInput,
-  outputSchema: SendEvmTransactionOutput,
-}));

package/src/operations/sendEvmTransactionWithEndUserAccount.ts

@@ -1,102 +0,0 @@
-import * as Schema from "effect/Schema";
-import { API } from "../client.ts";
-import * as T from "../traits.ts";
-
-// Input Schema
-export interface SendEvmTransactionWithEndUserAccountInput {
-  userId: string;
-  projectID?: string;
-  address: string;
-  network:
-    | "base"
-    | "base-sepolia"
-    | "ethereum"
-    | "ethereum-sepolia"
-    | "avalanche"
-    | "polygon"
-    | "optimism"
-    | "arbitrum"
-    | "arbitrum-sepolia"
-    | "world"
-    | "world-sepolia";
-  walletSecretId?: string;
-  transaction: string;
-}
-export const SendEvmTransactionWithEndUserAccountInput =
-  /*@__PURE__*/ Schema.Struct({
-    userId: Schema.String.pipe(T.PathParam()),
-    projectID: Schema.optional(Schema.String),
-    address: Schema.String,
-    network: Schema.Literals([
-      "base",
-      "base-sepolia",
-      "ethereum",
-      "ethereum-sepolia",
-      "avalanche",
-      "polygon",
-      "optimism",
-      "arbitrum",
-      "arbitrum-sepolia",
-      "world",
-      "world-sepolia",
-    ]),
-    walletSecretId: Schema.optional(Schema.String),
-    transaction: Schema.String,
-  }).pipe(
-    T.Http({
-      method: "POST",
-      path: "/v2/embedded-wallet-api/end-users/{userId}/evm/send/transaction",
-    }),
-  ) as unknown as Schema.Codec<SendEvmTransactionWithEndUserAccountInput>;
-
-// Output Schema
-export interface SendEvmTransactionWithEndUserAccountOutput {
-  transactionHash: string;
-}
-export const SendEvmTransactionWithEndUserAccountOutput =
-  /*@__PURE__*/ Schema.Struct({
-    transactionHash: Schema.String,
-  }) as unknown as Schema.Codec<SendEvmTransactionWithEndUserAccountOutput>;
-
-// The operation
-/**
- * Send transaction via end user EVM account
- *
- * Signs a transaction with the given end user EVM account and sends it to the indicated supported network. This API handles nonce management and gas estimation, leaving the developer to provide only the minimal set of fields necessary to send the transaction. The transaction should be serialized as a hex string using [RLP](https://ethereum.org/en/developers/docs/data-structures-and-encoding/rlp/).
- * The transaction must be an [EIP-1559 dynamic fee transaction](https://github.com/ethereum/EIPs/blob/master/EIPS/eip-1559.md).
- * **Transaction fields and API behavior**
- * - `to` *(Required)*: The address of the contract or account to send the transaction to.
- * - `chainId` *(Ignored)*: The value of the `chainId` field in the transaction is ignored.
- * The transaction will be sent to the network indicated by the `network` field in the request body.
- * - `nonce` *(Optional)*: The nonce to use for the transaction. If not provided, the API will assign
- * a nonce to the transaction based on the current state of the account.
- * - `maxPriorityFeePerGas` *(Optional)*: The maximum priority fee per gas to use for the transaction.
- * If not provided, the API will estimate a value based on current network conditions.
- * - `maxFeePerGas` *(Optional)*: The maximum fee per gas to use for the transaction.
- * If not provided, the API will estimate a value based on current network conditions.
- * - `gasLimit` *(Optional)*: The gas limit to use for the transaction. If not provided, the API will estimate a value
- * based on the `to` and `data` fields of the transaction.
- * - `value` *(Optional)*: The amount of ETH, in wei, to send with the transaction.
- * - `data` *(Optional)*: The data to send with the transaction; only used for contract calls.
- * - `accessList` *(Optional)*: The access list to use for the transaction.
- *
- * @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 userId - The ID of the end user.
- * @param X-Developer-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 projectID - The ID of the CDP Project. Required for end users authenticated using custom auth (i.e. a non-CDP JWT provider).
- */
-export const sendEvmTransactionWithEndUserAccount =
-  /*@__PURE__*/ API.make(() => ({
-    inputSchema: SendEvmTransactionWithEndUserAccountInput,
-    outputSchema: SendEvmTransactionWithEndUserAccountOutput,
-  }));

package/src/operations/sendSolanaAssetWithEndUserAccount.ts

@@ -1,75 +0,0 @@
-import * as Schema from "effect/Schema";
-import { API } from "../client.ts";
-import * as T from "../traits.ts";
-
-// Input Schema
-export interface SendSolanaAssetWithEndUserAccountInput {
-  userId: string;
-  address: string;
-  asset: "usdc";
-  projectID?: string;
-  to: string;
-  amount: string;
-  network: "solana" | "solana-devnet";
-  createRecipientAta?: boolean;
-  walletSecretId?: string;
-  useCdpSponsor?: boolean;
-}
-export const SendSolanaAssetWithEndUserAccountInput =
-  /*@__PURE__*/ Schema.Struct({
-    userId: Schema.String.pipe(T.PathParam()),
-    address: Schema.String.pipe(T.PathParam()),
-    asset: Schema.Literals(["usdc"]).pipe(T.PathParam()),
-    projectID: Schema.optional(Schema.String),
-    to: Schema.String,
-    amount: Schema.String,
-    network: Schema.Literals(["solana", "solana-devnet"]),
-    createRecipientAta: Schema.optional(Schema.Boolean),
-    walletSecretId: Schema.optional(Schema.String),
-    useCdpSponsor: Schema.optional(Schema.Boolean),
-  }).pipe(
-    T.Http({
-      method: "POST",
-      path: "/v2/embedded-wallet-api/end-users/{userId}/solana/{address}/send/{asset}",
-    }),
-  ) as unknown as Schema.Codec<SendSolanaAssetWithEndUserAccountInput>;
-
-// Output Schema
-export interface SendSolanaAssetWithEndUserAccountOutput {
-  transactionSignature: string;
-}
-export const SendSolanaAssetWithEndUserAccountOutput =
-  /*@__PURE__*/ Schema.Struct({
-    transactionSignature: Schema.String,
-  }) as unknown as Schema.Codec<SendSolanaAssetWithEndUserAccountOutput>;
-
-// The operation
-/**
- * Send USDC on Solana
- *
- * Sends USDC from an end user's Solana account to a recipient address on the Solana network. This endpoint simplifies USDC transfers by automatically handling mint resolution, Associated Token Account (ATA) creation, decimal conversion, and transaction encoding.
- * The `amount` field accepts human-readable amounts as decimal strings (e.g., "1.5", "25.50").
- * Use the optional `createRecipientAta` parameter to control whether the sender pays for creating the recipient's Associated Token Account if it doesn't exist.
- *
- * @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 X-Developer-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 userId - The ID of the end user.
- * @param address - The base58 encoded address of the Solana account to send USDC from.
- * @param asset - The asset to send. Currently only "usdc" is supported.
- * @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 sendSolanaAssetWithEndUserAccount =
-  /*@__PURE__*/ API.make(() => ({
-    inputSchema: SendSolanaAssetWithEndUserAccountInput,
-    outputSchema: SendSolanaAssetWithEndUserAccountOutput,
-  }));

package/src/operations/sendSolanaTransaction.ts

@@ -1,59 +0,0 @@
-import * as Schema from "effect/Schema";
-import { API } from "../client.ts";
-import * as T from "../traits.ts";
-
-// Input Schema
-export interface SendSolanaTransactionInput {
-  network: "solana" | "solana-devnet";
-  transaction: string;
-  useCdpSponsor?: boolean;
-}
-export const SendSolanaTransactionInput =
-  /*@__PURE__*/ Schema.Struct({
-    network: Schema.Literals(["solana", "solana-devnet"]),
-    transaction: Schema.String,
-    useCdpSponsor: Schema.optional(Schema.Boolean),
-  }).pipe(
-    T.Http({ method: "POST", path: "/v2/solana/accounts/send/transaction" }),
-  ) as unknown as Schema.Codec<SendSolanaTransactionInput>;
-
-// Output Schema
-export interface SendSolanaTransactionOutput {
-  transactionSignature: string;
-}
-export const SendSolanaTransactionOutput =
-  /*@__PURE__*/ Schema.Struct({
-    transactionSignature: Schema.String,
-  }) as unknown as Schema.Codec<SendSolanaTransactionOutput>;
-
-// The operation
-/**
- * Send Solana transaction
- *
- * Signs and sends a single Solana transaction using multiple Solana accounts. The transaction may contain contain several instructions, each of which may require signatures from different account keys.
- * The transaction should be serialized into a byte array and base64 encoded. The API handles recent blockhash management and fee estimation, leaving the developer to provide only the minimal set of fields necessary to send the transaction.
- * **Transaction types**
- * The following transaction types are supported:
- * * [Legacy transactions](https://solana.com/developers/guides/advanced/versions#current-transaction-versions)
- * * [Versioned transactions](https://solana.com/developers/guides/advanced/versions)
- * **Instruction Batching**
- * To batch multiple operations, include multiple instructions within a single transaction. All instructions within a transaction are executed atomically - if any instruction fails, the entire transaction fails and is rolled back.
- * **Network Support**
- * The following Solana networks are supported:
- * * `solana` - Solana Mainnet
- * * `solana-devnet` - Solana Devnet
- * The developer is responsible for ensuring that the unsigned transaction is valid, as the API will not validate the transaction.
- *
- * @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.
-
- */
-export const sendSolanaTransaction = /*@__PURE__*/ API.make(() => ({
-  inputSchema: SendSolanaTransactionInput,
-  outputSchema: SendSolanaTransactionOutput,
-}));

package/src/operations/sendSolanaTransactionWithEndUserAccount.ts

@@ -1,78 +0,0 @@
-import * as Schema from "effect/Schema";
-import { API } from "../client.ts";
-import * as T from "../traits.ts";
-
-// Input Schema
-export interface SendSolanaTransactionWithEndUserAccountInput {
-  userId: string;
-  projectID?: string;
-  address: string;
-  network: "solana" | "solana-devnet";
-  walletSecretId?: string;
-  transaction: string;
-  useCdpSponsor?: boolean;
-}
-export const SendSolanaTransactionWithEndUserAccountInput =
-  /*@__PURE__*/ Schema.Struct({
-    userId: Schema.String.pipe(T.PathParam()),
-    projectID: Schema.optional(Schema.String),
-    address: Schema.String,
-    network: Schema.Literals(["solana", "solana-devnet"]),
-    walletSecretId: Schema.optional(Schema.String),
-    transaction: Schema.String,
-    useCdpSponsor: Schema.optional(Schema.Boolean),
-  }).pipe(
-    T.Http({
-      method: "POST",
-      path: "/v2/embedded-wallet-api/end-users/{userId}/solana/send/transaction",
-    }),
-  ) as unknown as Schema.Codec<SendSolanaTransactionWithEndUserAccountInput>;
-
-// Output Schema
-export interface SendSolanaTransactionWithEndUserAccountOutput {
-  transactionSignature: string;
-}
-export const SendSolanaTransactionWithEndUserAccountOutput =
-  /*@__PURE__*/ Schema.Struct({
-    transactionSignature: Schema.String,
-  }) as unknown as Schema.Codec<SendSolanaTransactionWithEndUserAccountOutput>;
-
-// The operation
-/**
- * Send transaction via end user Solana account
- *
- * Signs a transaction with the given end user Solana account and sends it to the indicated supported network.
- * The API handles recent blockhash management and fee estimation, leaving the developer to provide only the minimal set of fields necessary to send the transaction.
- * The unsigned transaction should be serialized into a byte array and then encoded as base64.
- * **Transaction types**
- * The following transaction types are supported:
- * * [Legacy transactions](https://solana.com/developers/guides/advanced/versions#current-transaction-versions)
- * * [Versioned transactions](https://solana.com/developers/guides/advanced/versions)
- * **Instruction Batching**
- * To batch multiple operations, include multiple instructions within a single transaction. All instructions within a transaction are executed atomically - if any instruction fails, the entire transaction fails and is rolled back.
- * **Network Support**
- * The following Solana networks are supported:
- * * `solana` - Solana Mainnet
- * * `solana-devnet` - Solana Devnet
- * The developer is responsible for ensuring that the unsigned transaction is valid, as the API will not validate the transaction.
- *
- * @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 X-Developer-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 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 sendSolanaTransactionWithEndUserAccount =
-  /*@__PURE__*/ API.make(() => ({
-    inputSchema: SendSolanaTransactionWithEndUserAccountInput,
-    outputSchema: SendSolanaTransactionWithEndUserAccountOutput,
-  }));

package/src/operations/sendUserOperation.ts

@@ -1,125 +0,0 @@
-import * as Schema from "effect/Schema";
-import { API } from "../client.ts";
-import * as T from "../traits.ts";
-
-// Input Schema
-export interface SendUserOperationInput {
-  address: string;
-  userOpHash: string;
-  signature: string;
-}
-export const SendUserOperationInput = /*@__PURE__*/ Schema.Struct({
-  address: Schema.String.pipe(T.PathParam()),
-  userOpHash: Schema.String.pipe(T.PathParam()),
-  signature: Schema.String,
-}).pipe(
-  T.Http({
-    method: "POST",
-    path: "/v2/evm/smart-accounts/{address}/user-operations/{userOpHash}/send",
-  }),
-) as unknown as Schema.Codec<SendUserOperationInput>;
-
-// Output Schema
-export interface SendUserOperationOutput {
-  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 SendUserOperationOutput =
-  /*@__PURE__*/ Schema.Struct({
-    network: Schema.Literals([
-      "base-sepolia",
-      "base",
-      "arbitrum",
-      "optimism",
-      "zora",
-      "polygon",
-      "bnb",
-      "avalanche",
-      "ethereum",
-      "ethereum-sepolia",
-    ]),
-    userOpHash: Schema.String,
-    calls: Schema.Array(
-      Schema.Struct({
-        to: Schema.String,
-        value: Schema.String,
-        data: Schema.String,
-        overrideGasLimit: Schema.optional(Schema.String),
-      }),
-    ),
-    status: Schema.Literals([
-      "pending",
-      "signed",
-      "broadcast",
-      "complete",
-      "dropped",
-      "failed",
-    ]),
-    transactionHash: Schema.optional(Schema.String),
-    receipts: Schema.optional(
-      Schema.Array(
-        Schema.Struct({
-          revert: Schema.optional(
-            Schema.Struct({
-              data: Schema.String,
-              message: Schema.String,
-            }),
-          ),
-          transactionHash: Schema.optional(Schema.String),
-          blockHash: Schema.optional(Schema.String),
-          blockNumber: Schema.optional(Schema.Number),
-          gasUsed: Schema.optional(Schema.String),
-        }),
-      ),
-    ),
-    expiresAt: Schema.optional(Schema.String),
-  }) as unknown as Schema.Codec<SendUserOperationOutput>;
-
-// The operation
-/**
- * Send user operation
- *
- * Sends a user operation with a signature.
- * The payload to sign must be the `userOpHash` field of the user operation. This hash should be signed directly (not using `personal_sign` or EIP-191 message hashing).
- * The signature must be 65 bytes in length, consisting of: - 32 bytes for the `r` value - 32 bytes for the `s` value - 1 byte for the `v` value (must be 27 or 28)
- * If using the CDP Paymaster, the user operation must be signed and sent within 2 minutes of being prepared.
- *
- * @param address - The address of the Smart Account to send the user operation from.
- * @param userOpHash - The hash of the user operation to send.
- */
-export const sendUserOperation = /*@__PURE__*/ API.make(() => ({
-  inputSchema: SendUserOperationInput,
-  outputSchema: SendUserOperationOutput,
-}));