import { createWallet, setSpendPolicy, agentExecute, NATIVE_TOKEN } from 'agentwallet-sdk';
import { createWalletClient, http } from 'viem';
import { privateKeyToAccount } from 'viem/accounts';
import { base } from 'viem/chains';

const account = privateKeyToAccount('0x...');
const walletClient = createWalletClient({ account, chain: base, transport: http() });

const wallet = createWallet({
  accountAddress: '0xYourAgentWallet',
  chain: 'base',  // or 'arbitrum', 'polygon', 'optimism', etc.
  walletClient,
});

// Set a $25/tx, $500/day spend policy for ETH
await setSpendPolicy(wallet, {
  token: NATIVE_TOKEN,
  perTxLimit: 25000000000000000n,  // 0.025 ETH
  periodLimit: 500000000000000000n, // 0.5 ETH
  periodLength: 86400,
});

// Agent executes — auto-approved if within limits, queued if over
const result = await agentExecute(wallet, {
  to: '0xRecipient',
  value: 10000000000000000n, // 0.01 ETH
});
console.log(result.executed ? 'Sent!' : 'Queued for approval');

import { getGlobalRegistry, BASE_REGISTRY, ETHEREUM_REGISTRY } from 'agentwallet-sdk';

// Global registry — all chains loaded
const registry = getGlobalRegistry();

// Look up a token by symbol + chain
const usdc = registry.getToken('USDC', 8453); // Base chain ID
console.log(usdc?.address); // 0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913

// List all tokens on a chain
const baseTokens = registry.listTokens(8453);
console.log(baseTokens.map(t => t.symbol));
// ['USDC', 'USDT', 'DAI', 'WETH', 'WBTC', 'LINK', 'UNI', 'AAVE', 'LDO', ...]

// Add a custom token
registry.addToken({
  symbol: 'MYTOKEN',
  name: 'My Custom Token',
  chainId: 8453,
  address: '0xYourTokenAddress',
  decimals: 18,
});

// Native gas token (ETH, POL, AVAX, S) — isNative: true, no ERC-20 transfer needed
const eth = registry.getToken('ETH', 1);
console.log(eth?.isNative); // true

// Per-chain convenience exports (global registry, filtered by chain)
import { BASE_REGISTRY, ARBITRUM_REGISTRY, ETHEREUM_REGISTRY } from 'agentwallet-sdk';
const arbUsdc = ARBITRUM_REGISTRY.getToken('USDC', 42161);

import { createWallet, sendToken, sendNative, getTokenBalance, getNativeBalance, getBalances } from 'agentwallet-sdk';

const wallet = createWallet({ accountAddress: '0x...', chain: 'base', walletClient });

// Send 100 USDC (human-readable amount — no manual decimal math)
const txHash = await sendToken(wallet, {
  symbol: 'USDC',
  to: '0xRecipient',
  amount: '100',       // 100 USDC → internally converted to 100_000_000 (6 decimals)
});

// Send 0.5 ETH (native gas)
const nativeTxHash = await sendNative(wallet, '0xRecipient', '0.5');

// Check a single token balance (returns human-readable string)
const usdcBalance = await getTokenBalance(wallet, 'USDC');
console.log(usdcBalance); // "250.00"

// Check native balance
const ethBalance = await getNativeBalance(wallet);
console.log(ethBalance); // "1.234567890123456789"

// Check all registered token balances at once
const balances = await getBalances(wallet);
// [{ symbol: 'USDC', balance: '250.00', raw: 250000000n }, { symbol: 'WETH', ... }, ...]

import { toRaw, toHuman, formatBalance } from 'agentwallet-sdk';

// Human → raw (for contract calls)
const raw = toRaw('100.50', 6);   // → 100_500_000n (USDC 6 decimals)
const rawEth = toRaw('1.5', 18);  // → 1_500_000_000_000_000_000n

// Raw → human-readable string
const human = toHuman(100_500_000n, 6);  // → "100.5"
const humanEth = toHuman(1_500_000_000_000_000_000n, 18); // → "1.5"

// Format with rounding and symbol
const display = formatBalance(100_500_000n, 6, 'USDC', 2); // → "100.50 USDC"
const ethDisplay = formatBalance(1_500_000_000_000_000_000n, 18, 'ETH', 4); // → "1.5000 ETH"

import { SolanaWallet } from 'agentwallet-sdk/tokens/solana';

const solWallet = new SolanaWallet({
  privateKeyBase58: process.env.SOLANA_PRIVATE_KEY!,
  rpcUrl: 'https://api.mainnet-beta.solana.com', // optional, defaults to mainnet
});

// Get native SOL balance
const { sol, lamports } = await solWallet.getSolBalance();
console.log(`Balance: ${sol} SOL`);

// Send SOL
const sig = await solWallet.sendSol('RecipientBase58Address', 0.1); // 0.1 SOL
console.log('Tx:', sig);

// Get SPL token balance (e.g., USDC on Solana)
const usdcMint = 'EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v'; // Solana USDC
const { amount, decimals } = await solWallet.getSplTokenBalance(usdcMint);
console.log(`USDC: ${Number(amount) / 10 ** decimals}`);

// Send SPL token
const splSig = await solWallet.sendSplToken(
  usdcMint,
  'RecipientBase58Address',
  5_000_000n, // 5 USDC (6 decimals)
);
console.log('SPL tx:', splSig);

// List all SPL token accounts
const accounts = await solWallet.listSplTokenAccounts();
// [{ mint: '...', amount: 5000000n, decimals: 6 }, ...]

import { createWallet, createX402Client } from 'agentwallet-sdk';
import { createWalletClient, http } from 'viem';
import { privateKeyToAccount } from 'viem/accounts';
import { arbitrum } from 'viem/chains';

const account = privateKeyToAccount(process.env.AGENT_PRIVATE_KEY as `0x${string}`);
const walletClient = createWalletClient({ account, chain: arbitrum, transport: http() });

// Wallet on Arbitrum — pays with Arbitrum USDC
const wallet = createWallet({
  accountAddress: '0xYourAgentWallet',
  chain: 'arbitrum',
  walletClient,
});

const x402 = createX402Client(wallet, {
  // Accept payment requests on any supported mainnet chain
  supportedNetworks: ['arbitrum:42161', 'base:8453', 'optimism:10', 'polygon:137'],
  globalDailyLimit: 10_000_000n, // 10 USDC/day cap
  globalPerRequestMax: 1_000_000n, // 1 USDC max per request
});

// Automatically pays 402 responses with the chain's native USDC
const response = await x402.fetch('https://api.example.com/premium-data');
const data = await response.json();

import { createWallet } from 'agentwallet-sdk';
import { attachSwap } from 'agentwallet-sdk/swap';
import { BASE_TOKENS, ARBITRUM_TOKENS } from 'agentwallet-sdk';

// Swap on Base
const baseWallet = createWallet({ accountAddress: '0x...', chain: 'base', walletClient });
const baseSwap = attachSwap(baseWallet, { chain: 'base' });

const result = await baseSwap.swap(BASE_TOKENS.WETH, BASE_TOKENS.USDC, 1_000_000_000_000_000n, {
  slippageBps: 50, // 0.5% slippage
});
console.log('Swap tx:', result.txHash);

// Swap on Arbitrum
const arbWallet = createWallet({ accountAddress: '0x...', chain: 'arbitrum', walletClient });
const arbSwap = attachSwap(arbWallet, { chain: 'arbitrum' });

const arbResult = await arbSwap.swap(ARBITRUM_TOKENS.USDC, ARBITRUM_TOKENS.WETH, 5_000_000n, {
  slippageBps: 30,
});
console.log('Arbitrum swap tx:', arbResult.txHash);

import { createBridge } from 'agentwallet-sdk';
import { createWalletClient, http } from 'viem';
import { base } from 'viem/chains';

const walletClient = createWalletClient({
  account: privateKeyToAccount(process.env.AGENT_PRIVATE_KEY as `0x${string}`),
  chain: base,
  transport: http(),
});

const bridge = createBridge(walletClient, 'base');

// Bridge 100 USDC from Base to Arbitrum (~12 seconds with FAST finality)
const result = await bridge.bridge(100_000_000n, 'arbitrum', {
  minFinalityThreshold: 0, // FAST attestation
});
console.log('Burn tx:', result.burnTxHash);
console.log('Mint tx:', result.mintTxHash);
console.log(`Completed in ${result.elapsedMs}ms`);

import { bridgeEVMToSolana } from 'agentwallet-sdk';
import { createWalletClient, http } from 'viem';
import { base } from 'viem/chains';

const walletClient = createWalletClient({
  account: privateKeyToAccount(process.env.AGENT_PRIVATE_KEY as `0x${string}`),
  chain: base,
  transport: http(),
});

// Bridge 50 USDC from Base to Solana
const result = await bridgeEVMToSolana(walletClient, 50_000_000n, {
  fromChain: 'base',
  solanaRecipient: 'YourSolanaWalletAddressInBase58',
  minFinalityThreshold: 0, // FAST (~12s)
});

console.log('EVM burn tx:', result.burnTxHash);
console.log('Attestation ready — submit to Solana TokenMessengerMinterV2');
console.log('Message bytes:', result.messageBytes);
console.log('Attestation:', result.attestation);
// Submit result.messageBytes + result.attestation to the Solana CCTP V2 program:
// CCTPV2Sm4AdWt5296sk4P66VBZ7bEhcARwFaaS9YPbeC (MessageTransmitterV2)

import { receiveFromSolanaOnEVM } from 'agentwallet-sdk';

// After initiating a burn on Solana, receive on EVM:
const result = await receiveFromSolanaOnEVM(walletClient, {
  messageBytes: '0x...', // from Solana burn transaction
  messageHash: '0x...',  // keccak256 of messageBytes
  sourceDomain: 5,       // Solana CCTP domain
}, {
  toChain: 'arbitrum',
  evmRecipient: '0xYourEVMAddress',
});

console.log('Mint tx:', result.mintTxHash);
console.log('Received:', result.amount, 'USDC base units on', result.toChain);

import { ERC8004Client } from 'agentwallet-sdk';

const identity = new ERC8004Client({ chain: 'base' });

// Register agent
const { txHash, agentId } = await identity.registerAgent(walletClient, {
  name: 'MyAgent',
  description: 'Autonomous trading agent',
});

// Look up any agent
const agent = await identity.lookupAgentIdentity(agentId!);
console.log(agent.owner, agent.agentURI);

import { ReputationClient } from 'agentwallet-sdk';

const reputation = new ReputationClient({ chain: 'base' });

// Leave feedback for an agent
await reputation.giveFeedback(walletClient, {
  agentId: 42n,
  score: 95n,
  category: 1,
  comment: 'Fast execution, accurate results',
  taskRef: 'task-abc-123',
  verifierRef: '',
  clientRef: '',
  contentHash: '0x0000000000000000000000000000000000000000000000000000000000000000',
});

// Read aggregated reputation
const rep = await reputation.getAgentReputation(42n);
console.log(`Score: ${rep.totalScore} from ${rep.count} reviews`);

import { ValidationClient } from 'agentwallet-sdk';
import { keccak256, toBytes } from 'viem';

const validation = new ValidationClient({
  chain: 'base',
  validationAddress: '0xYourValidationRegistry', // address required until official deployment
});

// Request validation from a validator
const requestHash = keccak256(toBytes('my-validation-request-v1'));
await validation.requestValidation(walletClient, {
  validator: '0xValidatorContract',
  agentId: 42n,
  requestURI: 'https://example.com/validation-spec.json',
  requestHash,
});

// Check validation status
const status = await validation.getValidationStatus(requestHash);
console.log(status.responded ? `Result: ${status.response}` : 'Pending');

// Get summary for an agent
const summary = await validation.getSummary(42n);
console.log(`${summary.passCount} passed, ${summary.failCount} failed`);

import { MutualStakeEscrow } from 'agentwallet-sdk';

const escrow = new MutualStakeEscrow({
  chain: 'base',
  walletClient,
});

// Create escrow — both agent and client stake
const { escrowId, txHash } = await escrow.create({
  counterparty: '0xOtherAgent',
  token: '0xUSDC',
  stakeAmount: 100000000n, // 100 USDC
  taskHash: '0x...',
  deadline: BigInt(Math.floor(Date.now() / 1000) + 86400),
});

// Counterparty funds their side
await escrow.fund(escrowId);

// After task completion, fulfill
await escrow.fulfill(escrowId, proofHash);

// Verify and release stakes
await escrow.verify(escrowId);

import { createWallet, agentExecute } from 'agentwallet-sdk';

const wallet = createWallet({
  accountAddress: '0xYourAgent',
  chain: 'etherlink',  // new: Tezos L2 support
  walletClient,
});

// x402 payment flow is identical across chains
const response = await fetch('https://api.vendor.com/data');
if (response.status === 402) {
  const details = await response.json();
  const proof = await wallet.createX402Proof(details);
  const paid = await fetch('https://api.vendor.com/data', {
    headers: { 'X-Payment': proof }
  });
}

import { CctpBridgeClient } from 'agentwallet-sdk';

const bridge = new CctpBridgeClient({
  sourceChain: 'base',
  walletClient,
});

// Bridge USDC from Base to Arbitrum
const { txHash } = await bridge.bridge({
  destinationChain: 'arbitrum',
  recipient: '0xff86829393C6C26A4EC122bE0Cc3E466Ef876AdD',
  amount: 500000n, // 0.50 USDC
});

import { EmailResolver } from 'agentwallet-sdk';

const resolver = new EmailResolver();

// Resolve an agent email to its wallet address
const wallet = await resolver.resolveEmail('myagent@agentmail.to');
console.log(wallet.address); // 0x...

// Send a payment request embedded in an email
await resolver.sendWithPayment({
  to: 'vendor@agentmail.to',
  subject: 'Payment for API access',
  amount: 5_000_000n, // 5 USDC
  token: 'USDC',
  chain: 'base',
});