@distilled.cloud/coinbase 0.0.0 → 0.2.5-alpha2

package/src/operations/getEvmSmartAccount.ts

@@ -0,0 +1,35 @@
+import * as Schema from "effect/Schema";
+import { API } from "../client";
+import * as T from "../traits";
+
+// Input Schema
+export const GetEvmSmartAccountInput =
+  /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
+    address: Schema.String.pipe(T.PathParam()),
+  }).pipe(T.Http({ method: "GET", path: "/v2/evm/smart-accounts/{address}" }));
+export type GetEvmSmartAccountInput = typeof GetEvmSmartAccountInput.Type;
+
+// Output Schema
+export const GetEvmSmartAccountOutput =
+  /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
+    address: Schema.String,
+    owners: Schema.Array(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 GetEvmSmartAccountOutput = typeof GetEvmSmartAccountOutput.Type;
+
+// The operation
+/**
+ * Get a Smart Account by address
+ *
+ * Gets a Smart Account by its address.
+ *
+ * @param address - The 0x-prefixed address of the Smart Account.
+ */
+export const getEvmSmartAccount = /*@__PURE__*/ /*#__PURE__*/ API.make(() => ({
+  inputSchema: GetEvmSmartAccountInput,
+  outputSchema: GetEvmSmartAccountOutput,
+}));

package/src/operations/getEvmSmartAccountByName.ts

@@ -0,0 +1,41 @@
+import * as Schema from "effect/Schema";
+import { API } from "../client";
+import * as T from "../traits";
+
+// Input Schema
+export const GetEvmSmartAccountByNameInput =
+  /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
+    name: Schema.String.pipe(T.PathParam()),
+  }).pipe(
+    T.Http({ method: "GET", path: "/v2/evm/smart-accounts/by-name/{name}" }),
+  );
+export type GetEvmSmartAccountByNameInput =
+  typeof GetEvmSmartAccountByNameInput.Type;
+
+// Output Schema
+export const GetEvmSmartAccountByNameOutput =
+  /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
+    address: Schema.String,
+    owners: Schema.Array(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 GetEvmSmartAccountByNameOutput =
+  typeof GetEvmSmartAccountByNameOutput.Type;
+
+// The operation
+/**
+ * Get a Smart Account by name
+ *
+ * Gets a Smart Account by its name.
+ *
+ * @param name - The name of the Smart Account.
+ */
+export const getEvmSmartAccountByName = /*@__PURE__*/ /*#__PURE__*/ API.make(
+  () => ({
+    inputSchema: GetEvmSmartAccountByNameInput,
+    outputSchema: GetEvmSmartAccountByNameOutput,
+  }),
+);

package/src/operations/getEvmSwapPrice.ts

@@ -0,0 +1,31 @@
+import * as Schema from "effect/Schema";
+import { API } from "../client";
+import * as T from "../traits";
+
+// Input Schema
+export const GetEvmSwapPriceInput = /*@__PURE__*/ /*#__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" }));
+export type GetEvmSwapPriceInput = typeof GetEvmSwapPriceInput.Type;
+
+// Output Schema
+export const GetEvmSwapPriceOutput = /*@__PURE__*/ /*#__PURE__*/ Schema.Unknown;
+export type GetEvmSwapPriceOutput = typeof GetEvmSwapPriceOutput.Type;
+
+// The operation
+/**
+ * Get a price estimate for a swap
+ *
+ * Get a price estimate for a swap between two tokens on an EVM network.
+ */
+export const getEvmSwapPrice = /*@__PURE__*/ /*#__PURE__*/ API.make(() => ({
+  inputSchema: GetEvmSwapPriceInput,
+  outputSchema: GetEvmSwapPriceOutput,
+}));

package/src/operations/getOnrampOrderById.ts

@@ -0,0 +1,62 @@
+import * as Schema from "effect/Schema";
+import { API } from "../client";
+import * as T from "../traits";
+
+// Input Schema
+export const GetOnrampOrderByIdInput =
+  /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
+    orderId: Schema.String.pipe(T.PathParam()),
+  }).pipe(T.Http({ method: "GET", path: "/v2/onramp/orders/{orderId}" }));
+export type GetOnrampOrderByIdInput = typeof GetOnrampOrderByIdInput.Type;
+
+// Output Schema
+export const GetOnrampOrderByIdOutput =
+  /*@__PURE__*/ /*#__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.Struct({}),
+      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),
+    }),
+  });
+export type GetOnrampOrderByIdOutput = typeof GetOnrampOrderByIdOutput.Type;
+
+// 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__*/ /*#__PURE__*/ API.make(() => ({
+  inputSchema: GetOnrampOrderByIdInput,
+  outputSchema: GetOnrampOrderByIdOutput,
+}));

package/src/operations/getOnrampUserLimits.ts

@@ -0,0 +1,44 @@
+import * as Schema from "effect/Schema";
+import { API } from "../client";
+import * as T from "../traits";
+
+// Input Schema
+export const GetOnrampUserLimitsInput =
+  /*@__PURE__*/ /*#__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" }));
+export type GetOnrampUserLimitsInput = typeof GetOnrampUserLimitsInput.Type;
+
+// Output Schema
+export const GetOnrampUserLimitsOutput =
+  /*@__PURE__*/ /*#__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,
+      }),
+    ),
+  });
+export type GetOnrampUserLimitsOutput = typeof GetOnrampUserLimitsOutput.Type;
+
+// 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__*/ /*#__PURE__*/ API.make(() => ({
+  inputSchema: GetOnrampUserLimitsInput,
+  outputSchema: GetOnrampUserLimitsOutput,
+}));

package/src/operations/getPolicyById.ts

@@ -0,0 +1,35 @@
+import * as Schema from "effect/Schema";
+import { API } from "../client";
+import * as T from "../traits";
+
+// Input Schema
+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;
+
+// Output Schema
+export const GetPolicyByIdOutput = /*@__PURE__*/ /*#__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,
+});
+export type GetPolicyByIdOutput = typeof GetPolicyByIdOutput.Type;
+
+// The operation
+/**
+ * Get a policy by ID
+ *
+ * Get a policy by its ID.
+ *
+ * @param policyId - The ID of the policy to get.
+ */
+export const getPolicyById = /*@__PURE__*/ /*#__PURE__*/ API.make(() => ({
+  inputSchema: GetPolicyByIdInput,
+  outputSchema: GetPolicyByIdOutput,
+}));

package/src/operations/getSQLGrammar.ts

@@ -0,0 +1,26 @@
+import * as Schema from "effect/Schema";
+import { API } from "../client";
+import * as T from "../traits";
+
+// Input Schema
+export const GetSQLGrammarInput = /*@__PURE__*/ /*#__PURE__*/ Schema.Struct(
+  {},
+).pipe(T.Http({ method: "GET", path: "/v2/data/query/grammar" }));
+export type GetSQLGrammarInput = typeof GetSQLGrammarInput.Type;
+
+// Output Schema
+export const GetSQLGrammarOutput = /*@__PURE__*/ /*#__PURE__*/ Schema.String;
+export type GetSQLGrammarOutput = typeof GetSQLGrammarOutput.Type;
+
+// 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 via an ANTLR4 grammar which is evaluated by server before executing the query. This ensures the safety and soundness of the SQL API.
+ * 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 as well.
+ */
+export const getSQLGrammar = /*@__PURE__*/ /*#__PURE__*/ API.make(() => ({
+  inputSchema: GetSQLGrammarInput,
+  outputSchema: GetSQLGrammarOutput,
+}));

package/src/operations/getSolanaAccount.ts

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

package/src/operations/getSolanaAccountByName.ts

@@ -0,0 +1,40 @@
+import * as Schema from "effect/Schema";
+import { API } from "../client";
+import * as T from "../traits";
+
+// Input Schema
+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;
+
+// Output Schema
+export const GetSolanaAccountByNameOutput =
+  /*@__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 GetSolanaAccountByNameOutput =
+  typeof GetSolanaAccountByNameOutput.Type;
+
+// The operation
+/**
+ * Get a Solana account by name
+ *
+ * Gets a Solana account by its name.
+ *
+ * @param name - The name of the Solana account.
+ */
+export const getSolanaAccountByName = /*@__PURE__*/ /*#__PURE__*/ API.make(
+  () => ({
+    inputSchema: GetSolanaAccountByNameInput,
+    outputSchema: GetSolanaAccountByNameOutput,
+  }),
+);

package/src/operations/getUserOperation.ts

@@ -0,0 +1,82 @@
+import * as Schema from "effect/Schema";
+import { API } from "../client";
+import * as T from "../traits";
+
+// Input Schema
+export const GetUserOperationInput = /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
+  address: Schema.String.pipe(T.PathParam()),
+  userOpHash: Schema.String.pipe(T.PathParam()),
+}).pipe(
+  T.Http({
+    method: "GET",
+    path: "/v2/evm/smart-accounts/{address}/user-operations/{userOpHash}",
+  }),
+);
+export type GetUserOperationInput = typeof GetUserOperationInput.Type;
+
+// Output Schema
+export const GetUserOperationOutput = /*@__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 GetUserOperationOutput = typeof GetUserOperationOutput.Type;
+
+// The operation
+/**
+ * Get a user operation
+ *
+ * Gets a user operation by its hash.
+ *
+ * @param address - The address of the Smart Account the user operation belongs to.
+ * @param userOpHash - The hash of the user operation to fetch.
+ */
+export const getUserOperation = /*@__PURE__*/ /*#__PURE__*/ API.make(() => ({
+  inputSchema: GetUserOperationInput,
+  outputSchema: GetUserOperationOutput,
+}));

package/src/operations/getWebhookSubscription.ts

@@ -0,0 +1,60 @@
+import * as Schema from "effect/Schema";
+import { API } from "../client";
+import * as T from "../traits";
+
+// Input Schema
+export const GetWebhookSubscriptionInput =
+  /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
+    subscriptionId: Schema.String.pipe(T.PathParam()),
+  }).pipe(
+    T.Http({
+      method: "GET",
+      path: "/v2/data/webhooks/subscriptions/{subscriptionId}",
+    }),
+  );
+export type GetWebhookSubscriptionInput =
+  typeof GetWebhookSubscriptionInput.Type;
+
+// Output Schema
+export const GetWebhookSubscriptionOutput =
+  /*@__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 GetWebhookSubscriptionOutput =
+  typeof GetWebhookSubscriptionOutput.Type;
+
+// The operation
+/**
+ * Get webhook subscription details
+ *
+ * Retrieve detailed information about a specific webhook subscription including
+ * configuration, status, creation timestamp, and webhook signature secret.
+ * ### Response Includes
+ * - Subscription configuration and filters
+ * - Target URL and custom headers
+ * - Webhook signature secret for verification
+ * - Creation timestamp and status
+ *
+ * @param subscriptionId - Unique identifier for the webhook subscription.
+ */
+export const getWebhookSubscription = /*@__PURE__*/ /*#__PURE__*/ API.make(
+  () => ({
+    inputSchema: GetWebhookSubscriptionInput,
+    outputSchema: GetWebhookSubscriptionOutput,
+  }),
+);

package/src/operations/importEndUser.ts

@@ -0,0 +1,78 @@
+import * as Schema from "effect/Schema";
+import { API } from "../client";
+import * as T from "../traits";
+
+// Input Schema
+export const ImportEndUserInput = /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
+  userId: Schema.String,
+  authenticationMethods: Schema.Array(Schema.Unknown),
+  encryptedPrivateKey: Schema.String,
+  keyType: Schema.Literals(["evm", "solana"]),
+}).pipe(T.Http({ method: "POST", path: "/v2/end-users/import" }));
+export type ImportEndUserInput = typeof ImportEndUserInput.Type;
+
+// Output Schema
+export const ImportEndUserOutput = /*@__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 ImportEndUserOutput = typeof ImportEndUserOutput.Type;
+
+// The operation
+/**
+ * Import a private key for an end user
+ *
+ * Imports an existing private key for an end user into the developer's CDP Project. The private key must be encrypted using the CDP SDK's encryption scheme before being sent to this endpoint. This API should be called from the [CDP SDK](https://github.com/coinbase/cdp-sdk) to ensure that the associated private key is properly encrypted.
+ * This endpoint allows developers to import existing keys for their end users, supporting both EVM and Solana key types. The end user must have at least one authentication method configured.
+ *
+ * @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 importEndUser = /*@__PURE__*/ /*#__PURE__*/ API.make(() => ({
+  inputSchema: ImportEndUserInput,
+  outputSchema: ImportEndUserOutput,
+}));

package/src/operations/importEvmAccount.ts

@@ -0,0 +1,43 @@
+import * as Schema from "effect/Schema";
+import { API } from "../client";
+import * as T from "../traits";
+
+// Input Schema
+export const ImportEvmAccountInput = /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
+  encryptedPrivateKey: Schema.String,
+  name: Schema.optional(Schema.String),
+  accountPolicy: Schema.optional(Schema.String),
+}).pipe(T.Http({ method: "POST", path: "/v2/evm/accounts/import" }));
+export type ImportEvmAccountInput = typeof ImportEvmAccountInput.Type;
+
+// Output Schema
+export const ImportEvmAccountOutput = /*@__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 ImportEvmAccountOutput = typeof ImportEvmAccountOutput.Type;
+
+// The operation
+/**
+ * Import an EVM account
+ *
+ * Import an existing EVM account into the developer's CDP Project. This API should be called from the [CDP SDK](https://github.com/coinbase/cdp-sdk) to ensure that the associated private key is properly encrypted.
+ *
+ * @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 importEvmAccount = /*@__PURE__*/ /*#__PURE__*/ API.make(() => ({
+  inputSchema: ImportEvmAccountInput,
+  outputSchema: ImportEvmAccountOutput,
+}));

package/src/operations/importSolanaAccount.ts

@@ -0,0 +1,42 @@
+import * as Schema from "effect/Schema";
+import { API } from "../client";
+import * as T from "../traits";
+
+// Input Schema
+export const ImportSolanaAccountInput =
+  /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
+    encryptedPrivateKey: Schema.String,
+    name: Schema.optional(Schema.String),
+  }).pipe(T.Http({ method: "POST", path: "/v2/solana/accounts/import" }));
+export type ImportSolanaAccountInput = typeof ImportSolanaAccountInput.Type;
+
+// Output Schema
+export const ImportSolanaAccountOutput =
+  /*@__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 ImportSolanaAccountOutput = typeof ImportSolanaAccountOutput.Type;
+
+// The operation
+/**
+ * Import a Solana account
+ *
+ * Import an existing Solana account into the developer's CDP Project. This API should be called from the [CDP SDK](https://github.com/coinbase/cdp-sdk) to ensure that the associated private key is properly encrypted.
+ *
+ * @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 importSolanaAccount = /*@__PURE__*/ /*#__PURE__*/ API.make(() => ({
+  inputSchema: ImportSolanaAccountInput,
+  outputSchema: ImportSolanaAccountOutput,
+}));