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 { 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',
});