Wallet API v2: Quickstart

import { CdpClient } from "@coinbase/cdp-sdk";
import dotenv from "dotenv";

dotenv.config();

// Initialize the CDP client, which automatically loads
// the API Key and Wallet Secret from the environment
// variables.
const cdp = new CdpClient();

import { CdpClient } from "@coinbase/cdp-sdk";
import { http, createPublicClient, parseEther } from "viem";
import { baseSepolia } from "viem/chains";
import dotenv from "dotenv";

dotenv.config();

const cdp = new CdpClient();

const publicClient = createPublicClient({
  chain: baseSepolia,
  transport: http(),
});

// Step 1: Create a new EVM account.
const account = await cdp.evm.createAccount();
console.log("Successfully created EVM account:", account.address);

// Step 2: Request ETH from the faucet.
const { transactionHash: faucetTransactionHash } = await cdp.evm.requestFaucet({
  address: account.address,
  network: "base-sepolia",
  token: "eth",
});

const faucetTxReceipt = await publicClient.waitForTransactionReceipt({
  hash: faucetTransactionHash,
});
console.log("Successfully requested ETH from faucet:", faucetTxReceipt.transactionHash);

// Step 3: Use the v2 Wallet API to send a transaction.
const transactionResult = await cdp.evm.sendTransaction({
  address: account.address,
  transaction: {
    to: "0x0000000000000000000000000000000000000000",
    value: parseEther("0.000001"),
  },
  network: "base-sepolia",
});

// Step 4: Wait for the transaction to be confirmed
const txReceipt = await publicClient.waitForTransactionReceipt({
  hash: transactionResult.transactionHash,
});

console.log(
  `Transaction sent! Link: https://sepolia.basescan.org/tx/${transactionResult.transactionHash}`
);

import asyncio

from cdp import CdpClient
from cdp.evm_transaction_types import TransactionRequestEIP1559

from dotenv import load_dotenv
from web3 import Web3

load_dotenv()

w3 = Web3(Web3.HTTPProvider("https://sepolia.base.org"))


async def main():
    async with CdpClient() as cdp:
        account = await cdp.evm.create_account()
        print(f"Created account: {account.address}")

        faucet_hash = await cdp.evm.request_faucet(
            address=account.address, network="base-sepolia", token="eth"
        )

        w3.eth.wait_for_transaction_receipt(faucet_hash)
        print(f"Received funds from faucet for address: {account.address}")

        tx_hash = await cdp.evm.send_transaction(
            address=account.address,
            transaction=TransactionRequestEIP1559(
                to="0x0000000000000000000000000000000000000000",
                value=w3.to_wei(0.000001, "ether"),
            ),
            network="base-sepolia",
        )


        print(f"Transaction sent! Link: https://sepolia.basescan.org/tx/{tx_hash}")


asyncio.run(main())

import {
  Connection,
  PublicKey,
  SystemProgram,
  Transaction,
} from "@solana/web3.js";
import { CdpClient } from "@coinbase/cdp-sdk";
import dotenv from "dotenv";

dotenv.config();

const cdp = new CdpClient();

const connection = new Connection("https://api.devnet.solana.com");

async function createAccount() {
  const account = await cdp.solana.createAccount();
  console.log(`Created account: ${account.address}`);
  return account;
}

async function requestFaucet(address: string) {
  await cdp.solana.requestFaucet({
    address,
    token: "sol",
  });
}

async function waitForBalance(address: string) {
  let balance = 0;
  let attempts = 0;
  const maxAttempts = 30;

  while (balance === 0 && attempts < maxAttempts) {
    balance = await connection.getBalance(new PublicKey(address));
    if (balance === 0) {
      console.log("Waiting for funds...");
      await new Promise(resolve => setTimeout(resolve, 1000));
      attempts++;
    } else {
      console.log("Account funded with", balance / 1e9, "SOL");
    }
  }

  if (balance === 0) {
    throw new Error("Account not funded after multiple attempts");
  }
}

async function sendTransaction(address: string) {
  // Amount of lamports to send (default: 1000 = 0.000001 SOL)
  const lamportsToSend = 1000;
  const fromAddress = new PublicKey(address)
  const toAddress = new PublicKey("EeVPcnRE1mhcY85wAh3uPJG1uFiTNya9dCJjNUPABXzo");

  const { blockhash } = await connection.getLatestBlockhash();

  const transaction = new Transaction();
  transaction.add(
    SystemProgram.transfer({
      fromPubkey: fromAddress,
      toPubkey: toAddress,
      lamports: lamportsToSend,
   })
  );

  transaction.recentBlockhash = blockhash;
  transaction.feePayer = fromAddress;

  const serializedTx = Buffer.from(
    transaction.serialize({ requireAllSignatures: false })
  ).toString("base64");

  const { signature: txSignature } = await cdp.solana.signTransaction({
    address,
    transaction: serializedTx,
  });
  const decodedSignedTx = Buffer.from(txSignature, "base64");

  console.log("Sending transaction...");
  const txSendSignature = await connection.sendRawTransaction(decodedSignedTx);

  const latestBlockhash = await connection.getLatestBlockhash();

  console.log("Waiting for transaction to be confirmed...");
  const confirmation = await connection.confirmTransaction({
    signature: txSendSignature,
    blockhash: latestBlockhash.blockhash,
    lastValidBlockHeight: latestBlockhash.lastValidBlockHeight,
  });

  if (confirmation.value.err) {
    throw new Error(`Transaction failed: ${confirmation.value.err.toString()}`);
  }

  console.log(`Sent SOL: https://explorer.solana.com/tx/${txSendSignature}?cluster=devnet`);
}

async function main() {
  const account = await createAccount();
  await requestFaucet(account.address);
  await waitForBalance(account.address);
  await sendTransaction(account.address);
}

main().catch(console.error)

import time
import base64
import asyncio
from cdp import CdpClient
from dotenv import load_dotenv
from solana.rpc.api import Client as SolanaClient
from solana.rpc.types import TxOpts
from solders.pubkey import Pubkey as PublicKey
from solders.system_program import TransferParams, transfer
from solders.message import Message

load_dotenv()

cdp = CdpClient()

connection = SolanaClient("https://api.devnet.solana.com")

async def create_sol_account():
    account = await cdp.solana.create_account()
    print(f"Created account: {account.address}")
    return account


async def request_faucet(address: str):
    await cdp.solana.request_faucet(
        address,
        token="sol"
    )


async def wait_for_balance(address: str):
    balance = 0
    max_attempts = 30
    attempts = 0

    while balance == 0 and attempts < max_attempts:
        balance_resp = connection.get_balance(PublicKey.from_string(address))
        balance = balance_resp.value
        if balance == 0:
            print("Waiting for funds...")
            time.sleep(1)
            attempts += 1
        else:
            print(f"Account funded with {balance / 1e9} SOL ({balance} lamports)")

    if balance == 0:
        raise ValueError("Account not funded after multiple attempts")


async def send_transaction(address: str):
    # Amount of lamports to send (default: 1000 = 0.000001 SOL)
    lamports_to_send = 1000;
    from_address = PublicKey.from_string(address)
    to_address = PublicKey.from_string("EeVPcnRE1mhcY85wAh3uPJG1uFiTNya9dCJjNUPABXzo")

    blockhash_resp = connection.get_latest_blockhash()
    blockhash = blockhash_resp.value.blockhash

    transfer_params = TransferParams(
        from_pubkey=from_address,
        to_pubkey=to_address,
        lamports=lamports_to_send,
    )
    transfer_instr = transfer(transfer_params)

    message = Message.new_with_blockhash(
        [transfer_instr],
        from_address,
        blockhash,
    )

    # Create a transaction envelope with signature space
    sig_count = bytes([1])  # 1 byte for signature count (1)
    empty_sig = bytes([0] * 64)  # 64 bytes of zeros for the empty signature
    message_bytes = bytes(message)  # Get the serialized message bytes

    # Concatenate to form the transaction bytes
    tx_bytes = sig_count + empty_sig + message_bytes

    # Encode to base64 used by CDP API
    serialized_tx = base64.b64encode(tx_bytes).decode("utf-8")

    signed_tx_response = await cdp.solana.sign_transaction(
        address,
        transaction=serialized_tx,
    )

    # Decode the signed transaction from base64
    decoded_signed_tx = base64.b64decode(signed_tx_response.signed_transaction)

    print("Sending transaction...")
    tx_resp = connection.send_raw_transaction(
        decoded_signed_tx,
        opts=TxOpts(skip_preflight=False, preflight_commitment="processed"),
    )
    signature = tx_resp.value

    print("Waiting for transaction to be confirmed...")
    confirmation = connection.confirm_transaction(signature, commitment="processed")

    if hasattr(confirmation, "err") and confirmation.err:
        raise ValueError(f"Transaction failed: {confirmation.err}")

    print(f"Sent SOL: https://explorer.solana.com/tx/{signature}?cluster=devnet")


async def main():
    account = await create_sol_account()
    await request_faucet(account.address)
    await wait_for_balance(account.address)
    await send_transaction(account.address)

    await cdp.close()

asyncio.run(main())