@distilled.cloud/coinbase 0.0.0 → 0.2.5-alpha2

package/src/operations/createSpendPermission.ts

@@ -0,0 +1,110 @@
+import * as Schema from "effect/Schema";
+import { API } from "../client";
+import * as T from "../traits";
+
+// Input Schema
+export const CreateSpendPermissionInput =
+  /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
+    address: Schema.String.pipe(T.PathParam()),
+    network: Schema.Literals([
+      "base",
+      "base-sepolia",
+      "ethereum",
+      "ethereum-sepolia",
+      "optimism",
+      "arbitrum",
+      "avalanche",
+      "polygon",
+    ]),
+    spender: Schema.String,
+    token: Schema.String,
+    allowance: Schema.String,
+    period: Schema.String,
+    start: Schema.String,
+    end: Schema.String,
+    salt: Schema.optional(Schema.String),
+    extraData: Schema.optional(Schema.String),
+    paymasterUrl: Schema.optional(Schema.Struct({})),
+  }).pipe(
+    T.Http({
+      method: "POST",
+      path: "/v2/evm/smart-accounts/{address}/spend-permissions",
+    }),
+  );
+export type CreateSpendPermissionInput = typeof CreateSpendPermissionInput.Type;
+
+// Output Schema
+export const CreateSpendPermissionOutput =
+  /*@__PURE__*/ /*#__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),
+        }),
+      ),
+    ),
+  });
+export type CreateSpendPermissionOutput =
+  typeof CreateSpendPermissionOutput.Type;
+
+// The operation
+/**
+ * Create a spend permission
+ *
+ * Creates a spend permission for the given smart account address.
+ *
+ * @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 address of the Smart Account to create the spend permission for.
+ */
+export const createSpendPermission = /*@__PURE__*/ /*#__PURE__*/ API.make(
+  () => ({
+    inputSchema: CreateSpendPermissionInput,
+    outputSchema: CreateSpendPermissionOutput,
+  }),
+);

package/src/operations/createWebhookSubscription.ts

@@ -0,0 +1,92 @@
+import * as Schema from "effect/Schema";
+import { API } from "../client";
+import * as T from "../traits";
+
+// Input Schema
+export const CreateWebhookSubscriptionInput =
+  /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
+    description: Schema.optional(Schema.Struct({})),
+    eventTypes: Schema.Array(Schema.String),
+    isEnabled: Schema.Boolean,
+    target: Schema.Struct({
+      url: Schema.Struct({}),
+      headers: Schema.optional(Schema.Record(Schema.String, Schema.String)),
+    }),
+    metadata: Schema.optional(Schema.Record(Schema.String, Schema.String)),
+    labels: Schema.optional(Schema.Record(Schema.String, Schema.String)),
+  }).pipe(T.Http({ method: "POST", path: "/v2/data/webhooks/subscriptions" }));
+export type CreateWebhookSubscriptionInput =
+  typeof CreateWebhookSubscriptionInput.Type;
+
+// Output Schema
+export const CreateWebhookSubscriptionOutput =
+  /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
+    createdAt: Schema.String,
+    description: Schema.optional(Schema.Struct({})),
+    eventTypes: Schema.Array(Schema.String),
+    isEnabled: Schema.Boolean,
+    metadata: Schema.optional(
+      Schema.Struct({
+        secret: Schema.optional(Schema.String),
+      }),
+    ),
+    secret: Schema.String,
+    subscriptionId: Schema.String,
+    target: Schema.Struct({
+      url: Schema.Struct({}),
+      headers: Schema.optional(Schema.Record(Schema.String, Schema.String)),
+    }),
+    labels: Schema.optional(Schema.Record(Schema.String, Schema.String)),
+  });
+export type CreateWebhookSubscriptionOutput =
+  typeof CreateWebhookSubscriptionOutput.Type;
+
+// The operation
+/**
+ * Create webhook subscription
+ *
+ * Subscribe to real-time events across CDP products using flexible filtering.
+ * ### Event Types
+ * **Onchain Events** - Monitor Base mainnet with microsecond precision:
+ * - `onchain.activity.detected` - Smart contract events, transfers, swaps, NFT activity
+ * - **Requires** `labels` for filtering (e.g., `contract_address`, `event_name`)
+ * **Onramp/Offramp Events** - Transaction lifecycle notifications:
+ * - `onramp.transaction.created`, `onramp.transaction.updated`
+ * - `onramp.transaction.success`, `onramp.transaction.failed`
+ * - `offramp.transaction.created`, `offramp.transaction.updated`
+ * - `offramp.transaction.success`, `offramp.transaction.failed`
+ * - **No labels required** - maximum simplicity for transaction monitoring
+ * **Payments Transfers Events** - Transfer lifecycle notifications:
+ * - `payments.transfers.quoted`
+ * - `payments.transfers.processing`
+ * - `payments.transfers.completed`
+ * - `payments.transfers.failed`
+ * - **No labels required** - enable the transfers webhook to monitor status transitions
+ * **Wallet Events** - Wallet activity notifications:
+ * - `wallet.activity.detected`
+ * ### Webhook Signature Verification
+ * All webhooks include cryptographic signatures for security.
+ * The signature secret is returned in `secret` field when creating a subscription.
+ * **Note:** Webhooks are in beta and this interface is subject to change.
+ * See the [verification guide](https://docs.cdp.coinbase.com/onramp-&-offramp/webhooks#webhook-signature-verification) for implementation details.
+ * ### Onchain Label Filtering
+ * For `onchain.activity.detected` events, use `labels` for precise filtering with AND logic (max 20 labels per webhook).
+ * **Allowed labels** (all in snake_case format):
+ * - `network` (required) - Blockchain network
+ * - `contract_address` - Smart contract address
+ * - `event_name` - Event name (e.g., "Transfer", "Burn")
+ * - `event_signature` - Event signature hash
+ * - `transaction_from` - Transaction sender address
+ * - `transaction_to` - Transaction recipient address
+ * - `params.*` - Any event parameter (e.g., `params.from`, `params.to`, `params.sender`, `params.tokenId`)
+ * **Examples**:
+ * - **Liquidity Pool Monitor**: `{"network": "base-mainnet", "contract_address": "0xcd1f9777571493aeacb7eae45cd30a226d3e612d", "event_name": "Burn"}`
+ * - **Price Oracle Tracker**: `{"network": "base-mainnet", "contract_address": "0xbac4a9428ea707c51f171ed9890c3c2fa810305d", "event_name": "PriceUpdated"}`
+ * - **DeFi Protocol Activity**: `{"network": "base-mainnet", "contract_address": "0x45c6e6a47a711b14d8357d5243f46704904578e3", "event_name": "Deposit"}`
+ */
+export const createWebhookSubscription = /*@__PURE__*/ /*#__PURE__*/ API.make(
+  () => ({
+    inputSchema: CreateWebhookSubscriptionInput,
+    outputSchema: CreateWebhookSubscriptionOutput,
+  }),
+);

package/src/operations/deletePolicy.ts

@@ -0,0 +1,32 @@
+import * as Schema from "effect/Schema";
+import { API } from "../client";
+import * as T from "../traits";
+
+// Input Schema
+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;
+
+// Output Schema
+export const DeletePolicyOutput = /*@__PURE__*/ /*#__PURE__*/ Schema.Void;
+export type DeletePolicyOutput = typeof DeletePolicyOutput.Type;
+
+// The operation
+/**
+ * Delete a policy
+ *
+ * Delete a policy by its ID. This will have the effect of removing the policy from all accounts that are currently using it.
+ *
+ * @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 policyId - The ID of the policy to delete.
+ */
+export const deletePolicy = /*@__PURE__*/ /*#__PURE__*/ API.make(() => ({
+  inputSchema: DeletePolicyInput,
+  outputSchema: DeletePolicyOutput,
+}));

package/src/operations/deleteWebhookSubscription.ts

@@ -0,0 +1,42 @@
+import * as Schema from "effect/Schema";
+import { API } from "../client";
+import * as T from "../traits";
+
+// Input Schema
+export const DeleteWebhookSubscriptionInput =
+  /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
+    subscriptionId: Schema.String.pipe(T.PathParam()),
+  }).pipe(
+    T.Http({
+      method: "DELETE",
+      path: "/v2/data/webhooks/subscriptions/{subscriptionId}",
+    }),
+  );
+export type DeleteWebhookSubscriptionInput =
+  typeof DeleteWebhookSubscriptionInput.Type;
+
+// Output Schema
+export const DeleteWebhookSubscriptionOutput =
+  /*@__PURE__*/ /*#__PURE__*/ Schema.Void;
+export type DeleteWebhookSubscriptionOutput =
+  typeof DeleteWebhookSubscriptionOutput.Type;
+
+// The operation
+/**
+ * Delete webhook subscription
+ *
+ * Permanently delete a webhook subscription and stop all event deliveries.
+ * This action cannot be undone.
+ * ### Important Notes
+ * - All webhook deliveries will cease immediately
+ * - Subscription cannot be recovered after deletion
+ * - Consider disabling instead of deleting for temporary pauses
+ *
+ * @param subscriptionId - Unique identifier for the webhook subscription.
+ */
+export const deleteWebhookSubscription = /*@__PURE__*/ /*#__PURE__*/ API.make(
+  () => ({
+    inputSchema: DeleteWebhookSubscriptionInput,
+    outputSchema: DeleteWebhookSubscriptionOutput,
+  }),
+);

package/src/operations/exportEvmAccount.ts

@@ -0,0 +1,39 @@
+import * as Schema from "effect/Schema";
+import { API } from "../client";
+import * as T from "../traits";
+
+// Input Schema
+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;
+
+// Output Schema
+export const ExportEvmAccountOutput = /*@__PURE__*/ /*#__PURE__*/ Schema.Struct(
+  {
+    encryptedPrivateKey: Schema.String,
+  },
+);
+export type ExportEvmAccountOutput = typeof ExportEvmAccountOutput.Type;
+
+// The operation
+/**
+ * Export an 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.
+ *
+ * @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 EVM account. The address does not need to be checksummed.
+ */
+export const exportEvmAccount = /*@__PURE__*/ /*#__PURE__*/ API.make(() => ({
+  inputSchema: ExportEvmAccountInput,
+  outputSchema: ExportEvmAccountOutput,
+}));

package/src/operations/exportEvmAccountByName.ts

@@ -0,0 +1,45 @@
+import * as Schema from "effect/Schema";
+import { API } from "../client";
+import * as T from "../traits";
+
+// Input Schema
+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;
+
+// Output Schema
+export const ExportEvmAccountByNameOutput =
+  /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
+    encryptedPrivateKey: Schema.String,
+  });
+export type ExportEvmAccountByNameOutput =
+  typeof ExportEvmAccountByNameOutput.Type;
+
+// The operation
+/**
+ * Export an 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.
+ *
+ * @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 EVM account.
+ */
+export const exportEvmAccountByName = /*@__PURE__*/ /*#__PURE__*/ API.make(
+  () => ({
+    inputSchema: ExportEvmAccountByNameInput,
+    outputSchema: ExportEvmAccountByNameOutput,
+  }),
+);

package/src/operations/exportSolanaAccount.ts

@@ -0,0 +1,41 @@
+import * as Schema from "effect/Schema";
+import { API } from "../client";
+import * as T from "../traits";
+
+// Input Schema
+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;
+
+// Output Schema
+export const ExportSolanaAccountOutput =
+  /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
+    encryptedPrivateKey: Schema.String,
+  });
+export type ExportSolanaAccountOutput = typeof ExportSolanaAccountOutput.Type;
+
+// The operation
+/**
+ * Export an 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.
+ *
+ * @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 base58 encoded address of the Solana account.
+ */
+export const exportSolanaAccount = /*@__PURE__*/ /*#__PURE__*/ API.make(() => ({
+  inputSchema: ExportSolanaAccountInput,
+  outputSchema: ExportSolanaAccountOutput,
+}));

package/src/operations/exportSolanaAccountByName.ts

@@ -0,0 +1,48 @@
+import * as Schema from "effect/Schema";
+import { API } from "../client";
+import * as T from "../traits";
+
+// Input Schema
+export const ExportSolanaAccountByNameInput =
+  /*@__PURE__*/ /*#__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}",
+    }),
+  );
+export type ExportSolanaAccountByNameInput =
+  typeof ExportSolanaAccountByNameInput.Type;
+
+// Output Schema
+export const ExportSolanaAccountByNameOutput =
+  /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
+    encryptedPrivateKey: Schema.String,
+  });
+export type ExportSolanaAccountByNameOutput =
+  typeof ExportSolanaAccountByNameOutput.Type;
+
+// The operation
+/**
+ * Export a 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__*/ /*#__PURE__*/ API.make(
+  () => ({
+    inputSchema: ExportSolanaAccountByNameInput,
+    outputSchema: ExportSolanaAccountByNameOutput,
+  }),
+);

package/src/operations/getEndUser.ts

@@ -0,0 +1,68 @@
+import * as Schema from "effect/Schema";
+import { API } from "../client";
+import * as T from "../traits";
+
+// Input Schema
+export const GetEndUserInput = /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
+  userId: Schema.String.pipe(T.PathParam()),
+}).pipe(T.Http({ method: "GET", path: "/v2/end-users/{userId}" }));
+export type GetEndUserInput = typeof GetEndUserInput.Type;
+
+// Output Schema
+export const GetEndUserOutput = /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
+  userId: Schema.String,
+  authenticationMethods: Schema.Array(Schema.Unknown),
+  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,
+});
+export type GetEndUserOutput = typeof GetEndUserOutput.Type;
+
+// The operation
+/**
+ * Get an 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__*/ /*#__PURE__*/ API.make(() => ({
+  inputSchema: GetEndUserInput,
+  outputSchema: GetEndUserOutput,
+}));

package/src/operations/getEvmAccount.ts

@@ -0,0 +1,32 @@
+import * as Schema from "effect/Schema";
+import { API } from "../client";
+import * as T from "../traits";
+
+// Input Schema
+export const GetEvmAccountInput = /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
+  address: Schema.String.pipe(T.PathParam()),
+}).pipe(T.Http({ method: "GET", path: "/v2/evm/accounts/{address}" }));
+export type GetEvmAccountInput = typeof GetEvmAccountInput.Type;
+
+// Output Schema
+export const GetEvmAccountOutput = /*@__PURE__*/ /*#__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),
+});
+export type GetEvmAccountOutput = typeof GetEvmAccountOutput.Type;
+
+// The operation
+/**
+ * Get an 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__*/ /*#__PURE__*/ API.make(() => ({
+  inputSchema: GetEvmAccountInput,
+  outputSchema: GetEvmAccountOutput,
+}));

package/src/operations/getEvmAccountByName.ts

@@ -0,0 +1,34 @@
+import * as Schema from "effect/Schema";
+import { API } from "../client";
+import * as T from "../traits";
+
+// Input Schema
+export const GetEvmAccountByNameInput =
+  /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
+    name: Schema.String.pipe(T.PathParam()),
+  }).pipe(T.Http({ method: "GET", path: "/v2/evm/accounts/by-name/{name}" }));
+export type GetEvmAccountByNameInput = typeof GetEvmAccountByNameInput.Type;
+
+// Output Schema
+export const GetEvmAccountByNameOutput =
+  /*@__PURE__*/ /*#__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),
+  });
+export type GetEvmAccountByNameOutput = typeof GetEvmAccountByNameOutput.Type;
+
+// The operation
+/**
+ * Get an EVM account by name
+ *
+ * Gets an EVM account by its name.
+ *
+ * @param name - The name of the EVM account.
+ */
+export const getEvmAccountByName = /*@__PURE__*/ /*#__PURE__*/ API.make(() => ({
+  inputSchema: GetEvmAccountByNameInput,
+  outputSchema: GetEvmAccountByNameOutput,
+}));

package/src/operations/getEvmEip7702DelegationOperationById.ts

@@ -0,0 +1,56 @@
+import * as Schema from "effect/Schema";
+import { API } from "../client";
+import * as T from "../traits";
+
+// Input Schema
+export const GetEvmEip7702DelegationOperationByIdInput =
+  /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
+    delegationOperationId: Schema.String.pipe(T.PathParam()),
+  }).pipe(
+    T.Http({
+      method: "GET",
+      path: "/v2/evm/eip7702/delegation-operations/{delegationOperationId}",
+    }),
+  );
+export type GetEvmEip7702DelegationOperationByIdInput =
+  typeof GetEvmEip7702DelegationOperationByIdInput.Type;
+
+// Output Schema
+export const GetEvmEip7702DelegationOperationByIdOutput =
+  /*@__PURE__*/ /*#__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),
+  });
+export type GetEvmEip7702DelegationOperationByIdOutput =
+  typeof GetEvmEip7702DelegationOperationByIdOutput.Type;
+
+// The operation
+/**
+ * Get EIP-7702 delegation operation for an operationID
+ *
+ * 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__*/ /*#__PURE__*/ API.make(() => ({
+    inputSchema: GetEvmEip7702DelegationOperationByIdInput,
+    outputSchema: GetEvmEip7702DelegationOperationByIdOutput,
+  }));