cdp-docs-cli 1.0.0

package/src/templates/docs/transfer.md

@@ -0,0 +1,366 @@
+# Managing Accounts
+
+## Creating Accounts
+
+You can assign a name to an account to make it easier to access. Account names can consist of alphanumeric characters and hyphens, and must be between 2 and 36 characters long. Account names must be unique within a single CDP project for each account type (e.g., all Solana accounts).
+
+You can assign an account name at the time of account creation, and retrieve it later using the name. The `getOrCreateAccount` method will create an account if it doesn't exist, and return the existing account if it does.
+
+### EVM Accounts
+
+You can create EVM accounts with or without names. Here are examples of both approaches:
+
+<CodeGroup>
+  ```ts TypeScript lines wrap 
+  import { CdpClient } from "@coinbase/cdp-sdk";
+  import "dotenv/config";
+
+  const cdp = new CdpClient();
+
+  const account = await cdp.evm.createAccount();
+  console.log(`Created account. Address: ${account.address}.`);
+
+  const namedAccount = await cdp.evm.getOrCreateAccount({
+    name: "MyAccount"
+  });
+  console.log(`Created account with name ${account.name}.`);
+  ```
+
+  ```python Python lines wrap 
+  import asyncio
+  from cdp import CdpClient
+  import dotenv
+
+  dotenv.load_dotenv()
+
+  async def main(): 
+      async with CdpClient() as cdp:
+          account = await cdp.evm.create_account()
+          print(f"Created account. Address: {account.address}.")
+
+          named_account = await cdp.evm.get_or_create_account(name="MyAccount")
+          print(f"Created account with name {named_account.name}.")
+
+  asyncio.run(main())
+  ```
+</CodeGroup>
+
+### Smart Accounts
+
+You can also create and manage smart accounts that are owned by an EVM account. Each owner account can only have one smart account associated with it. The `getOrCreateSmartAccount` method will create a smart account if it doesn't exist for the owner, and return the existing smart account if it does.
+
+<CodeGroup>
+  ```ts TypeScript lines wrap
+  import { CdpClient } from "@coinbase/cdp-sdk";
+  import "dotenv/config";
+
+  const cdp = new CdpClient();
+
+  // Create a couple of owners, one for each smart account we will create.
+  const firstOwner = await cdp.evm.getOrCreateAccount({
+    name: "ExampleOwner1"
+  });
+  const secondOwner = await cdp.evm.getOrCreateAccount({
+    name: "ExampleOwner2"
+  });
+
+  const account = await cdp.evm.createSmartAccount({ 
+    owner: firstOwner,
+  });
+  console.log("Created Smart Account. Address:", account.address);
+
+  const namedSmartAccount = await cdp.evm.getOrCreateSmartAccount({ 
+    name: "MySmartAccount", 
+    owner: secondOwner
+  });
+  console.log("Created Smart Account:", sameAccount.address);
+  ```
+
+  ```python Python lines wrap
+  import asyncio
+  from cdp import CdpClient
+  import dotenv
+
+  dotenv.load_dotenv()
+
+  async def main():
+      async with CdpClient() as cdp:
+          # Create a couple of owners, one for each smart account we will create.
+          first_owner = await cdp.evm.get_or_create_account(name="ExampleOwner1")
+          second_owner = await cdp.evm.get_or_create_account(name="ExampleOwner2")
+
+          account = await cdp.evm.create_smart_account(
+              owner=first_owner
+          )
+          print("Created Smart Account. Address:", account.address)
+
+          named_account = await cdp.evm.get_or_create_smart_account(
+              name="MySmartAccount",
+              owner=second_owner
+          )
+          print("Created Smart Account:", named_account.address)
+
+  asyncio.run(main())
+  ```
+</CodeGroup>
+
+### Solana Accounts
+
+You can create Solana accounts with or without names. Here are examples of both approaches:
+
+<CodeGroup>
+  ```ts TypeScript lines wrap
+  import { CdpClient } from "@coinbase/cdp-sdk";
+  import "dotenv/config";
+
+  const cdp = new CdpClient();
+
+  const account = await cdp.solana.createAccount();
+  console.log(`Created account. Address: ${account.address}.`);
+
+  const namedAccount = await cdp.solana.getOrCreateAccount({
+    name: "MyAccount"
+  });
+  console.log(`Created account with name ${namedAccount.name}.`);
+  ```
+
+  ```python Python lines wrap
+  import asyncio
+  from cdp import CdpClient
+  import dotenv
+
+  dotenv.load_dotenv()
+
+  async def main():
+      async with CdpClient() as cdp:
+          account = await cdp.solana.create_account()
+          print(f"Created account. Address: {account.address}.")
+
+          named_account = await cdp.solana.get_or_create_account(name="MyAccount")
+          print(f"Created account with name {named_account.name}.")
+
+  asyncio.run(main())
+  ```
+</CodeGroup>
+
+## Managing Existing Accounts
+
+Once you've created accounts, you can retrieve, list, and update them as needed.
+
+### Getting Accounts by Address or Name
+
+You can retrieve a specific account by its address or name using the `getAccount` method.
+
+<CodeGroup>
+  ```ts TypeScript lines wrap
+  import { CdpClient } from "@coinbase/cdp-sdk";
+  import "dotenv/config";
+
+  const cdp = new CdpClient();
+
+  // Returns the account with the given address, if it exists.
+  const account = await cdp.evm.getAccount({
+    address: "0x1234567890123456789012345678901234567890"
+  });
+
+  // Returns the account with the given name, if it exists.
+  const namedAccount = await cdp.evm.getAccount({
+    name: "MyAccount"
+  });
+  ```
+
+  ```python Python lines wrap
+  import asyncio
+  from cdp import CdpClient
+  import dotenv
+
+  async def main():
+      async with CdpClient() as cdp:
+          # Returns the account with the given address, if it exists.
+          account = await cdp.evm.get_account(
+              address="0x1234567890123456789012345678901234567890"
+          )
+
+          # Returns the account with the given name, if it exists.
+          named_account = await cdp.evm.get_account(
+              name="MyAccount"
+          )
+  ```
+</CodeGroup>
+
+### Listing All Accounts
+
+You can list all accounts of a specific type in a single CDP project by calling the `listAccounts` method:
+
+<CodeGroup>
+  ```ts TypeScript lines wrap [expandable]
+  import { CdpClient } from "@coinbase/cdp-sdk";
+  import "dotenv/config";
+
+  const cdp = new CdpClient();
+  let response = await cdp.evm.listAccounts();
+
+  // Paginate through all accounts.
+  while (true) {
+    for (const account of response.accounts) {
+      console.log('EVM account:', account.address);
+    }
+    
+    if (!response.nextPageToken) break;
+    
+    response = await cdp.evm.listAccounts({
+      pageToken: response.nextPageToken
+    });
+  }
+  ```
+
+  ```python Python lines wrap [expandable]
+  import asyncio
+  from cdp import CdpClient
+  import dotenv
+
+  dotenv.load_dotenv()
+
+  async def main(): 
+      async with CdpClient() as cdp:
+          response = await cdp.evm.list_accounts()
+          
+          while True:
+              for account in response.accounts:
+                  print('EVM account:', account.address)
+                  
+              if not response.next_page_token:
+                  break
+                  
+              response = await cdp.evm.list_accounts(
+                  page_token=response.next_page_token
+              )
+
+  asyncio.run(main())
+  ```
+</CodeGroup>
+
+### Updating Accounts
+
+After creating an account, you can modify various properties including the account name and attach policies to govern account behavior.
+
+#### Changing Account Names
+
+You can change the name of an existing account using the `updateAccount` method:
+
+<CodeGroup>
+  ```ts TypeScript lines wrap 
+  import { CdpClient } from "@coinbase/cdp-sdk";
+  import "dotenv/config";
+
+  const cdp = new CdpClient();
+
+  // Get an existing account
+  const account = await cdp.evm.getOrCreateAccount({
+    name: "original-name"
+  });
+  console.log(`Original account name: ${account.name}`);
+
+  // Update the account name
+  const updatedAccount = await cdp.evm.updateAccount({
+    address: account.address,
+    update: {
+      name: "new-name",
+    },
+  });
+  console.log(`Updated account name: ${updatedAccount.name}`);
+  ```
+
+  ```python Python lines wrap 
+  import asyncio
+  from cdp import CdpClient
+  import dotenv
+
+  dotenv.load_dotenv()
+
+  async def main(): 
+      async with CdpClient() as cdp:
+          # Get an existing account
+          account = await cdp.evm.get_or_create_account(name="original-name")
+          print(f"Original account name: {account.name}")
+
+          # Update the account name
+          updated_account = await cdp.evm.update_account(
+              address=account.address,
+              update={
+                  "name": "new-name",
+              },
+          )
+          print(f"Updated account name: {updated_account.name}")
+
+  asyncio.run(main())
+  ```
+</CodeGroup>
+
+#### Attaching Policies
+
+You can attach [policies](/wallet-api/v2/using-the-wallet-api/policies) to accounts to govern their behavior, such as restricting transactions to specific addresses or limiting transaction values. Policies can be attached during account creation or added later using the `updateAccount` method:
+
+<CodeGroup>
+  ```ts TypeScript lines wrap 
+  import { CdpClient } from "@coinbase/cdp-sdk";
+  import "dotenv/config";
+
+  const cdp = new CdpClient();
+
+  // Get an existing account
+  const account = await cdp.evm.getOrCreateAccount({
+    name: "policy-account"
+  });
+
+  const policyId = "your-policy-id"; // Replace with your actual policy ID
+
+  // Attach a policy to the account
+  const updatedAccount = await cdp.evm.updateAccount({
+    address: account.address,
+    update: {
+      accountPolicy: policyId,
+    },
+  });
+  console.log(`Updated account ${updatedAccount.address} with policy: ${updatedAccount.policies}`);
+  ```
+
+  ```python Python lines wrap 
+  import asyncio
+  from cdp import CdpClient
+  import dotenv
+
+  dotenv.load_dotenv()
+
+  async def main(): 
+      async with CdpClient() as cdp:
+          # Get an existing account
+          account = await cdp.evm.get_or_create_account(name="policy-account")
+
+          policy_id = "your-policy-id"  # Replace with your actual policy ID
+
+          # Attach a policy to the account
+          updated_account = await cdp.evm.update_account(
+              address=account.address,
+              update={
+                  "account_policy": policy_id,
+              },
+          )
+          print(f"Updated account {updated_account.address} with policy: {updated_account.policies}")
+
+  asyncio.run(main())
+  ```
+</CodeGroup>
+
+<Note>
+  To learn more about creating and managing policies, see the [Policies](/wallet-api/v2/using-the-wallet-api/policies) documentation.
+</Note>
+
+### Account Manager UI
+
+You can also manage account in the [CDP Portal Account Manager UI](https://portal.cdp.coinbase.com/products/wallet-api/accounts). From here you can
+view your accounts by chain and type, and you can click into an account to view more information like balances and policies.
+
+<Frame>
+  <img src="https://mintlify.s3.us-west-1.amazonaws.com/coinbase-prod/wallet-api/images/account-manager-ui.png" alt="Account Manager UI" />
+</Frame>

package/src/templates/docs/wallet-accounts.md

@@ -0,0 +1,203 @@
+
+# Accounts
+
+## Overview
+
+**Accounts** refer to an address on a blockchain that has the ability to sign transactions on behalf of the address, allowing you to not only send and receive funds, but also interact with smart contracts. Cryptographically, an account corresponds to a **private/public key pair**.
+
+<Info>
+  **Accounts** are a term consistent across the crypto ecosystem: [Ethereum](https://ethereum.org/en/glossary/#section-a), [Solana](https://solana.com/docs/core/accounts), and [viem](https://viem.sh/docs/faq#why-use-the-terms-wallet--account-instead-of-signer) use this term to refer to the same concept.
+</Info>
+
+The v2 Wallet APIs support the following account types:
+
+* **EVM Compatible Accounts**:
+  * **EOAs**: [Externally Owned Accounts](https://ethereum.org/en/developers/docs/accounts/) on any EVM-compatible blockchain that have the ability to sign transactions on behalf of an account's address (i.e., when using a Smart Account).
+  * **Smart Account**: A smart contract-based account that can provide advanced functionality such as gas sponsorships and spend permissions.
+* **Solana Accounts**: An account on the Solana blockchain.
+
+<Tip>
+  More code samples are available in our [Typescript](https://github.com/coinbase/cdp-sdk/blob/main/examples/typescript/README.md)
+  and [Python](https://github.com/coinbase/cdp-sdk/tree/main/python/cdp/examples) SDK repositories.
+</Tip>
+
+## EVM accounts
+
+When using the v2 Wallet API, ensure you understand the differences between our two offered account types, Externally Owned Accounts (EOAs) and Smart Accounts so that you select the proper type for your application.
+
+The v2 Wallet API supports EOAs on **all EVM-compatible networks** and Smart Accounts on **Base Sepolia and Base Mainnet**.
+
+### EOA vs Smart Accounts
+
+While both account types enable blockchain interactions, they differ significantly in their architecture, capabilities, and constraints:
+
+| Feature                            | EOA                                                                                                                                                                                    | Smart Account                                                                                                                                                                                              |
+| ---------------------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| **Control**                        | Private key generated and secured in CDP's TEE                                                                                                                                         | Controlled by smart contract code with an owner account (can be a CDP-managed EOA or bring your own)                                                                                                       |
+| **Creation**                       | Generated new or imported from existing private key                                                                                                                                    | Created with CREATE2 opcode, deployed on first operation                                                                                                                                                   |
+| **Transaction type**               | Direct, signed blockchain transactions                                                                                                                                                 | Bundled transactions (user operations)                                                                                                                                                                     |
+| **Gas payment**                    | <Icon icon="x" color="#ef4444" /> Must pay gas fees directly                                                                                                                           | <Icon icon="check" color="#10b981" /> Gas sponsorship available via paymaster (subsidized on Base Sepolia)                                                                                                 |
+| **Batch operations**               | <Icon icon="x" color="#ef4444" /> Single operation at a time                                                                                                                           | <Icon icon="check" color="#10b981" /> Multiple calls in a single user operation                                                                                                                            |
+| **Owner requirements**             | <Icon icon="x" color="#ef4444" /> None required                                                                                                                                        | <Icon icon="check" color="#10b981" /> Requires an owner account (CDP EOA or external)                                                                                                                      |
+| **CDP limitations**                | None                                                                                                                                                                                   | One smart account per owner, one owner per smart account                                                                                                                                                   |
+| **Network support**                | <Icon icon="check" color="#10b981" /> All EVM networks supported by CDP                                                                                                                | <Icon icon="triangle-exclamation" color="#f59e0b" /> Base Sepolia and Base Mainnet only                                                                                                                    |
+| **Concurrent operations**          | <Icon icon="check" color="#10b981" /> Can have multiple pending transactions                                                                                                           | <Icon icon="check" color="#10b981" /> Support for concurrent userOperations                                                                                                                                |
+| **viem compatibility**             | <Icon icon="check" color="#10b981" /> Works seamlessly with viem for all onchain actions                                                                                               | <Icon icon="check" color="#10b981" /> Smart account owners work seamlessly with viem for all onchain actions                                                                                               |
+| **web3/eth-account compatibility** | <Icon icon="check" color="#10b981" /> Works seamlessly with web3.py and [eth-account](https://web3py.readthedocs.io/en/stable/web3.eth.account.html) libraries for all onchain actions | <Icon icon="check" color="#10b981" /> Smart account owners work seamlessly with web3.py and [eth-account](https://web3py.readthedocs.io/en/stable/web3.eth.account.html) libraries for all onchain actions |
+| **Faucet support**                 | <Icon icon="check" color="#10b981" /> Base, Ethereum, Solana                                                                                                                           | <Icon icon="check" color="#10b981" /> Base, Ethereum, Solana                                                                                                                                               |
+
+<Note>
+  Need support for additional networks? Reach out to us on the [Coinbase Developer Platform Discord](https://discord.com/invite/cdp) in the **#cdp-sdk** channel.
+</Note>
+
+### Use cases
+
+**Use EOAs when:**
+
+* You need support across all EVM networks
+* You require simple wallet functionality
+* You don't need gas sponsorship features
+
+**Use Smart Accounts when:**
+
+* You're building on Base Sepolia or Base Mainnet
+* You need to batch multiple operations in one transaction
+* You want to sponsor gas fees for users
+* You need EIP-4337 account abstraction features
+
+### Implementation
+
+EOAs are controlled directly by a private key.
+
+#### EOAs
+
+EOAs can be created new or imported from existing private keys. The following example shows both methods:
+
+```typescript
+// Create a new EOA
+const newAccount = await cdp.evm.createAccount();
+
+// Import an existing EOA from private key
+const importedAccount = await cdp.evm.importAccount({
+  privateKey: "0x0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef",
+  name: "imported-account"
+});
+```
+
+Here's how to create an EOA and send a simple transaction:
+
+<CodeGroup>
+  ```typescript TypeScript
+  // Create a new EOA
+  const account = await cdp.evm.createAccount();
+
+  // Send a transaction
+  const { transactionHash } = await cdp.evm.sendTransaction({
+    address: account.address,
+    transaction: {
+      to: "0x...",
+      value: parseEther("0.1"),
+    },
+    network: "base-sepolia",
+  });
+  ```
+
+  ```python Python
+  from cdp.evm_transaction_types import TransactionRequestEIP1559
+  from web3 import Web3
+
+  # Create a new EOA
+  account = await cdp.evm.create_account()
+
+  # Send a transaction
+  tx_hash = await cdp.evm.send_transaction(
+      address=account.address,
+      transaction=TransactionRequestEIP1559(
+          to="0x...",
+          value=Web3.to_wei(0.1, "ether"),
+      ),
+      network="base-sepolia",
+  )
+  ```
+</CodeGroup>
+
+For a complete example of creating and using EOAs, see the [quickstart guide](/wallet-api/v2/introduction/quickstart#evm).
+
+<Note>
+  Unlike Solana, EVM signing is handled automatically by the CDP SDK. When you call `sendTransaction()` for EOAs or `sendUserOperation()` for Smart Accounts, CDP manages the entire signing and submission process - you don't need to manually serialize, sign, or submit transactions.
+</Note>
+
+#### Smart Accounts
+
+<Info>
+  Smart Accounts are currently only available on [Base Sepolia](https://basescan.org/network/sepolia) and [Base Mainnet](https://basescan.org/network/mainnet).
+</Info>
+
+Smart Accounts operate through deployed smart contracts, enabling advanced features through [EIP-4337 Account Abstraction](https://eips.ethereum.org/EIPS/eip-4337).
+
+When creating a Smart Account, an EOA must be provided as the owner (either a CDP-managed EOA or an external EOA).
+
+A Smart Account is not deployed until its first user operation:
+
+```typescript
+const smartAccount = await cdp.evm.createSmartAccount({
+  owner: evmAccount,
+});
+// Contract address is deterministic but not yet deployed
+
+// Contract is deployed with the first user operation
+const sendResult = await cdp.evm.sendUserOperation({
+  smartAccount,
+  network: "base-sepolia",
+  calls: [/* ... */],
+});
+```
+
+<Note>
+  Smart Accounts use the [CREATE2](https://eips.ethereum.org/EIPS/eip-1014) opcode for deterministic addresses, allowing the contract address to be known before deployment.
+</Note>
+
+For detailed implementation examples including batch operations and gas sponsorship, see the [Smart Accounts guide](/wallet-api/v2/evm-features/smart-accounts).
+
+## Solana accounts
+
+Solana accounts represent addresses on the Solana blockchain that can hold SOL and other tokens.
+
+### Implementation
+
+Creating and using Solana accounts with the CDP Wallet API is straightforward. This example demonstrates creating an account, funding it via faucet, and signing a message:
+
+<CodeGroup>
+  ```typescript TypeScript
+  const account = await cdp.solana.createAccount();
+
+  await cdp.solana.signMessage({
+    address: account.address,
+    message: "Hello Solana!"
+  });
+  ```
+
+  ```python Python
+  account = await cdp.solana.create_account()
+
+  await cdp.solana.sign_message(
+    address=account.address,
+    message="Hello Solana!"
+  )
+  ```
+</CodeGroup>
+
+### Transaction signing
+
+Beyond basic account operations, you'll often need to sign and send **transactions**. While message signing, demonstrated above, is used to verify account ownership (e.g., for authentication or off-chain verification), transaction signing is used to authorize actual on-chain actions, such as transferring SOL or interacting with a program.
+
+The CDP Wallet API integrates seamlessly with the Solana Web3.js library for transaction handling. For complete examples of creating Solana accounts and sending transactions, see:
+
+* [Quickstart guide](/wallet-api/v2/introduction/quickstart#solana): Basic Solana account creation and transactions using CDP with Solana's Web3 library
+* [Batching Instructions](/wallet-api/v2/solana-features/batching-instructions): Execute multiple Solana instructions in a single transaction
+* [Sponsor Transactions](/wallet-api/v2/solana-features/sponsor-transactions): Learn about fee sponsorship on Solana
+
+## What to read next
+
+* [**v2 Security**](/wallet-api/v2/introduction/security): Learn about the security features of v2 Wallet API.
+* [**API Reference**](/api-reference/v2/introduction): Explore the complete API reference for v2 Wallet API.