cdp-docs-cli 1.0.0

package/src/templates/docs/fund.md

@@ -0,0 +1,122 @@
+# Fund Accounts
+
+## Overview
+
+With the CDP SDK, you can fund your account from fiat currency (eg. USD) in a bank account with a single API call. This method is currently limited to US-based individuals using US debit card (without 3DS verification) payment methods configured in a Coinbase account.
+We will add support for businesses and for additional payment methods soon. This method currently supports funding accounts with USDC and ETH on the Base and Ethereum networks. Want more? [Get in touch](https://calendar.app.google/X6VRM3qwcSbUDQ1f8) for early access!
+
+<Tip>
+  Start by [creating a Coinbase account](https://login.coinbase.com/pick-your-account) if you don't already have one, and add payment method(s).
+</Tip>
+
+## Account Funding API (Beta)
+
+To use the Account Funding API, you need a Coinbase account with a US debit card (non-3DS) payment method added. If you have multiple debit cards set up, this method will use the first non-3DS, active, verified card you added.
+
+The Account Funding API supports both EOA accounts and Smart Accounts.
+
+### Limits
+
+Account funding limits are the same as your [Coinbase account limits](https://help.coinbase.com/en/coinbase/trading-and-funding/buying-selling-or-converting-crypto/limits-and-account-levels).
+
+### Get a quote
+
+Use the `quoteFund` method to generate quotes for converting between fiat currency and crypto tokens with all associated fees. The `quoteFund` method returns a quote object, which expires in 10 minutes, with estimated network and exchange fees associated with your account funding operation. Save on fees with [Coinbase One](https://www.coinbase.com/one).
+
+<CodeGroup>
+  ```ts TypeScript lines wrap 
+      const account = await cdp.evm.getOrCreateAccount({ name: "account" });
+
+      const quote = await account.quoteFund({
+        network: "base",
+        token: "eth",
+        amount: 500000000000000n, // 0.0005 eth
+      });
+
+      // Parameters of the quote you can inspect to see if you want to execute it.
+      console.log("Fiat amount: ", quote.fiatAmount)
+      console.log("Fiat currency: ", quote.fiatCurrency)
+      for (const fee of quote.fees) {
+        console.log("Fee type: ", fee.type) // network_fee or exchange_fee
+        console.log("Fee amount: ", fee.amount)
+        console.log("Fee currency: ", fee.currency)
+      }
+  ```
+
+  ```python Python lines wrap 
+      account = await cdp.evm.get_or_create_account(name="account")
+
+      quote = await account.quote_fund(
+          network="base",
+          token="eth",
+          amount=500000000000000, # 0.0005 eth
+      )
+      # Parameters of the quote you can inspect to see if you want to execute it.
+      print("Fiat amount: ", quote.fiat_amount)
+      print("Fiat currency: ", quote.fiat_currency)
+      for fee in quote.fees:
+          print("Fee type: ", fee.type)  # network_fee or exchange_fee
+          print("Fee amount: ", fee.amount)
+          print("Fee currency: ", fee.currency)
+  ```
+</CodeGroup>
+
+### Execute a quote
+
+If you have already generated a quote, you can simply execute it to initiate account funding:
+
+<CodeGroup>
+  ```ts TypeScript lines wrap
+      // Execute the previously quoted account funding operation
+      const fundOperationResult = await quote.execute();
+
+      // Wait for the funding operation to settle
+      const completedTransfer = await account.waitForFundOperationReceipt({
+          transferId: fundOperationResult.id
+      });
+  ```
+
+  ```python Python lines wrap
+      # Execute the previously quoted account funding operation
+      fund_operation_result = await quote.execute()
+
+      # Wait for the funding operation to settle
+      completed_transfer = await account.wait_for_fund_operation_receipt(
+          transfer_id=fund_operation_result.id,
+      )  
+  ```
+</CodeGroup>
+
+### Executing directly without a quote
+
+**If you want to directly execute an account funding operation without first getting a quote**, you may directly call the fund method specifying the amount and crypto asset.
+
+<CodeGroup>
+  ```ts TypeScript lines wrap
+      // Initiate the funding operation
+      const fundOperation = await account.fund({
+        network: "base",
+        token: "eth",
+        amount: 500000000000000n, // 0.0005 eth
+      });
+
+      // Wait for the funding operation to settle
+      const completedTransfer = await account.waitForFundOperationReceipt({
+        transferId: fundOperation.id,
+      });
+  ```
+
+  ```python Python lines wrap
+      # Initiate the funding operation
+      fund_operation = await account.fund(
+          network="base",
+          token="eth",
+          amount=500000000000000, # 0.0005 eth
+      )
+
+      # Wait for the funding operation to settle
+      completed_transfer = await account.wait_for_fund_operation_receipt(
+          transfer_id=fund_operation.id,
+      )
+  ```
+</CodeGroup>

package/src/templates/docs/importing.md

@@ -0,0 +1,273 @@
+# Importing Accounts
+
+## Overview
+
+The CDP Wallet API offers a secure method for creating EVM and Solana Accounts from imported private keys.
+
+The import flow is end-to-end encrypted between the CDP SDK and the [TEE](/wallet-api/v2/introduction/security#tee-architecture), ensuring that keys are never exposed outside of the secure enclave during the request.
+Encrypted by the SDK in a way that only the TEE can decrypt the keys, this process enables seamless and secure import of your keys into v2 accounts.
+
+This feature can be used to import wallets from external wallet providers and the [v1 Wallet API](/wallet-api/v1/introduction/welcome).
+
+## EVM Accounts: Import from external wallet providers
+
+You can import private keys from other wallet providers by exporting them as raw, hex-encoded 32-byte strings.
+
+To complete the import, use `importAccount` in TypeScript or `import_account` in the Python CDP SDK.
+Only private key import is supported. To import an HD Wallet, derive individual private keys from the seed and import them one by one.
+
+<CodeGroup>
+  ```ts TypeScript lines wrap
+      import { CdpClient } from "@coinbase/cdp-sdk";
+      import dotenv from "dotenv";
+
+      dotenv.config();
+
+      const cdp = new CdpClient();
+      const account = await cdp.evm.importAccount({
+          privateKey: "0x0123456789abcdef...",
+          name: "ExternalWalletImportedAccount",
+      });
+      console.log("Imported account: ", account.address);
+  ```
+
+  ```python Python lines wrap
+      import asyncio
+      from cdp import CdpClient
+      from dotenv import load_dotenv
+
+      load_dotenv()
+
+      async def main():
+          async with CdpClient() as cdp:
+              account = await cdp.evm.import_account(
+                  private_key="0x0123456789abcdef...",
+                  name="ExternalWalletImportedAccount",
+              )
+              print("Imported account: ", account.address)
+
+      asyncio.run(main())
+  ```
+</CodeGroup>
+
+## Solana Accounts: Import from external wallet providers
+
+Here's an example of how to import a Solana account with a base58-encoded private key from a wallet provider like Phantom.
+
+<CodeGroup>
+  ```ts TypeScript lines wrap
+      import { CdpClient } from "@coinbase/cdp-sdk";
+      import dotenv from "dotenv";
+
+      dotenv.config();
+
+      const cdp = new CdpClient();
+      const account = await cdp.solana.importAccount({
+          privateKey: "4YFq9y5f5hi77Bq8kDCE6VgqoAq...",
+          name: "ExternalWalletImportedAccount",
+      });
+      console.log("Imported account: ", account.address);
+  ```
+
+  ```python Python lines wrap
+      import asyncio
+      from cdp import CdpClient
+      from dotenv import load_dotenv
+
+      load_dotenv()
+
+      async def main():
+          async with CdpClient() as cdp:
+              account = await cdp.solana.import_account(
+                  private_key="4YFq9y5f5hi77Bq8kDCE6VgqoAq...",
+                  name="ExternalWalletImportedAccount",
+              )
+              print("Imported account: ", account.address)
+
+      asyncio.run(main())
+  ```
+</CodeGroup>
+
+You can also import a Solana account using the raw 32-byte private key array.
+
+<CodeGroup>
+  ```ts TypeScript lines wrap
+      import { CdpClient } from "@coinbase/cdp-sdk";
+      import dotenv from "dotenv";
+
+      dotenv.config();
+
+      const keypair = Keypair.generate();
+      const privateKeyBytes32 = keypair.secretKey.subarray(0, 32);
+
+      const account = await cdp.solana.importAccount({
+          privateKey: privateKeyBytes32,
+          name: "BytesAccount32",
+      });
+      console.log("Imported account: ", account.address);
+  ```
+
+  ```python Python lines wrap
+      import asyncio
+      from cdp import CdpClient
+      from dotenv import load_dotenv
+
+      load_dotenv()
+
+      async def main():
+          async with CdpClient() as cdp:
+              keypair = Keypair.generate()
+              private_key_bytes32 = keypair.secret_key[:32]
+
+              account = await cdp.solana.import_account(
+                  private_key=private_key_bytes32,
+                  name="BytesAccount32",
+              )
+              print("Imported account: ", account.address)
+
+      asyncio.run(main())
+  ```
+</CodeGroup>
+
+## Import [developer-managed v1 Wallets](/wallet-api/v1/concepts/wallets/#developer-managed-wallets)
+
+A key difference between v1 wallets and v2 accounts is that v1 wallets are HD Wallets, while v2 accounts are single-address accounts.
+Import each address from your v1 wallet as an individual v2 account, following the steps below.
+
+First, set up a new project and install dependencies
+
+```ts TypeScript lines wrap
+    mkdir import-example && cd import-example
+    npm init -y && npm pkg set type="module"
+    npm install @coinbase/coinbase-sdk @coinbase/cdp-sdk dotenv
+```
+
+The below script does the following to import from v1 wallets to v2:
+
+1. Export private key of v1 address using v1 SDK
+2. Import private keys as a v2 account using v2 SDK
+
+   ```ts TypeScript lines wrap [expandable]
+       // Step 1: Export private keys of v1 address.
+       import { Coinbase, Wallet } from "@coinbase/coinbase-sdk";
+       import { CdpClient } from "@coinbase/cdp-sdk";
+       import dotenv from "dotenv";
+
+       dotenv.config();
+
+       // Change this to the path of your API key file downloaded from CDP portal.
+       Coinbase.configureFromJson({ filePath: "~/Downloads/cdp_api_key.json" });
+
+       // Add the ID of the wallet and its seed to import.
+       const wallet_id = ''
+       const seed = ''
+
+       // Fetch the wallet and set the seed.
+       let wallet = await Wallet.fetch(wallet_id);
+       // You can also load the seed using loadSeedFromFile call.
+       await wallet.setSeed(seed);
+
+       console.log(`Wallet successfully fetched: `, wallet.toString());
+
+       // Export private key of the default address.
+       let address = await wallet.getDefaultAddress();
+       let privateKey = address.export();
+
+       // Step 2: Import exported private key as a v2 account.
+       const cdp = new CdpClient();
+       const account = await cdp.evm.importAccount({
+         privateKey: privateKey,
+         name: "ImportedAccount",
+       });
+
+       console.log("Imported account: ", account.address);
+   ```
+
+## Import [Coinbase-managed v1 Wallets](/wallet-api/v1/concepts/wallets/#coinbase-managed-wallets)
+
+Coinbase-Managed v1 wallets use Multi-Party Computation to split the private key shares between Coinbase and the developer.
+
+These wallets do not support private key export today.
+Therefore, to migrate these wallets, you must create a new v2 account and transfer funds onchain from your existing v1 addresses.
+The v1 SDK's [gasless sends](/wallet-api/v1/concepts/transfers#gasless-transfers) feature can be used for a zero-cost migration.
+
+Create new v2 accounts for each address in your v1 wallet and transfer funds to them using the steps below:
+
+1. Fetch the v1 wallet using v1 SDK
+2. Create new v2 account using v2 SDK
+3. Send funds from v1 address to the new v2 account using v1 SDK
+
+   ```typescript index.js lines wrap [expandable]
+   import { Coinbase, Wallet } from "@coinbase/coinbase-sdk";
+   import { CdpClient } from "@coinbase/cdp-sdk";
+   import dotenv from "dotenv";
+
+   dotenv.config();
+
+   // Step 1: Fetch the v1 wallet.
+   // Change this to the path of your API key file downloaded from CDP portal.
+   Coinbase.configureFromJson({ filePath: "~/Downloads/cdp_api_key.json" });
+   Coinbase.useServerSigner = true;
+
+   // Add the ID of the v1 wallet.
+   const wallet_id = ''
+   let v1_wallet = await Wallet.fetch(wallet_id);
+
+   console.log(`Wallet successfully fetched: `, v1_wallet.toString());
+
+   // Step 2: Create a new v2 account.
+   const cdp = new CdpClient();
+
+   let v2_account = await cdp.evm.createAccount({
+       name: "NewAccount",
+   });
+
+   console.log(`Created account: ${v2_account} successfully`);
+
+   let balance = await v1_wallet.getBalance(Coinbase.assets.Usdc);
+   let transfer;
+
+   // Step 3: Send funds from v1 address to v2 account using gasless sends feature.
+   try {
+        transfer = await v1_wallet.createTransfer({
+           amount: balance,
+           assetId: Coinbase.assets.Usdc,
+           destination: v2_account.address,
+           gasless: true,
+       });
+   } catch (e) {
+         console.error(`Error transferring funds: ${e}`)
+   }
+
+   // Wait for the transfer to land on-chain.
+   try {
+      transfer = await transfer.wait();
+   } catch (err) {
+       if (err instanceof TimeoutError) {
+           console.log("Waiting for transfer timed out");
+       } else {
+           console.error("Error while waiting for transfer to complete: ", error);
+       }
+   }
+
+   // Check if transfer successfully completed on-chain.
+   if (transfer.getStatus() === 'complete') {
+       console.log('Transfer completed on-chain: ', transfer.toString());
+   } else {
+       console.error('Transfer failed on-chain: ', transfer.toString());
+   }
+   ```
+
+## Video: Watch and learn
+
+**Watch this video for a walkthrough of importing keys:**
+
+<Frame>
+  <iframe width="560" height="315" src="https://www.youtube.com/embed/sRQ7SA0pSdw" title="Importing Keys Walkthrough" frameborder="0" allow="accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture" allowfullscreen />
+</Frame>
+
+## What to read next
+
+* [**v2 Wallet Security**](/wallet-api/v2/introduction/security): Learn more about the security features of the CDP v2 Wallet API.
+* [**Policies**](/wallet-api/v2/using-the-wallet-api/policies): Learn more about governing behavior of v2 accounts.
+* [**Exporting Accounts**](/wallet-api/v2/using-the-wallet-api/export-accounts): Learn more about exporting EVM and Solana accounts.