import { AxonClient } from '@axonfi/sdk';

new AxonClient(config: AxonClientConfig)

import { AxonClient, decryptKeystore } from '@axonfi/sdk';
import { readFileSync } from 'fs';
 
const keystore = readFileSync(process.env.AXON_BOT_KEYSTORE_PATH!, 'utf-8');
const botPrivateKey = await decryptKeystore(keystore, process.env.AXON_BOT_PASSPHRASE!);
 
const axon = new AxonClient({
  vaultAddress: '0x1234...abcd',
  chainId: 8453,
  botPrivateKey,
});

const axon = new AxonClient({
  vaultAddress: '0x1234...abcd',
  chainId: 8453,
  botPrivateKey: process.env.AXON_BOT_PRIVATE_KEY as `0x${string}`,
});

get botAddress(): Address

console.log(axon.botAddress);
// "0xf39Fd6e51aad88F6F4ce6aB8827279cffFb92266"

async pay(input: PayInput): Promise<PaymentResult>

interface PaymentResult {
  requestId: string;
  status: PaymentStatus;
  txHash?: Hex;
  pollUrl?: string;
  estimatedResolutionMs?: number;
  reason?: string;
}

const result = await axon.pay({
  to: '0xRecipient',
  token: 'USDC',
  amount: 5,
  memo: 'API call payment',
});
 
// result.status === "approved"
// result.txHash === "0x..."

// result.status === "approved" (consensus reached)
// or
// result.status === "pending_review" (no consensus)
// result.pollUrl === "/v1/payments/req_abc123"

// result.status === "pending_review"
// result.estimatedResolutionMs === undefined (depends on human)

import { AxonClient } from '@axonfi/sdk';
 
const result = await axon.pay({
  to: '0xServiceProvider',
  token: 'USDC',
  amount: 25,
  memo: 'Monthly subscription payment',
  invoiceId: 'inv-2026-001',
  metadata: { plan: 'pro', period: '2026-02' },
});
 
if (result.status === 'approved') {
  console.log('Confirmed:', result.txHash);
} else if (result.status === 'pending_review') {
  const final = await axon.poll(result.requestId);
  console.log('Resolved:', final.status);
}

async poll(requestId: string): Promise<PaymentResult>

const status = await axon.poll('req_abc123');
 
if (status.status === 'approved') {
  console.log('Transaction hash:', status.txHash);
} else if (status.status === 'rejected') {
  console.log('Rejected:', status.reason);
}

async getBalance(token: Address): Promise<bigint>

import { USDC } from '@axonfi/sdk';
 
const balance = await axon.getBalance(USDC[8453]);
console.log('USDC balance:', balance); // e.g. 5000000n (5 USDC)

async getBalances(tokens: Address[]): Promise<Record<Address, bigint>>

const balances = await axon.getBalances([USDC[8453], WETH_ADDRESS]);
console.log('USDC:', balances[USDC[8453]]);

async isActive(): Promise<boolean>

const active = await axon.isActive();
console.log('Bot is active:', active);

async isPaused(): Promise<boolean>

async getVaultInfo(): Promise<VaultInfo>

const info = await axon.getVaultInfo();
console.log('Owner:', info.owner);
console.log('Paused:', info.paused);

async canPayTo(destination: Address): Promise<DestinationCheckResult>

const check = await axon.canPayTo('0xRecipient');
if (!check.allowed) {
  console.log('Blocked:', check.reason);
}

async isProtocolApproved(protocol: Address): Promise<boolean>

async swap(input: SwapInput): Promise<PaymentResult>

const result = await axon.swap({
  toToken: 'WETH',
  minToAmount: 0.001,
  memo: 'Rebalance USDC to WETH',
});

async getRebalanceTokens(): Promise<RebalanceTokensResult>

const { source, tokens, rebalanceTokenCount } = await axon.getRebalanceTokens();
// source: "default" (relayer defaults) or "on_chain" (owner-set)
// tokens: ["0xUSDC...", "0xWETH...", "0xUSDT..."]

async isRebalanceTokenAllowed(token: Address): Promise<{ allowed: boolean; source: 'default' | 'on_chain' }>

const { allowed, source } = await axon.isRebalanceTokenAllowed(WETH);
if (!allowed) console.log('Cannot rebalance to WETH');

async signPayment(intent: PaymentIntent): Promise<Hex>

interface PaymentIntent {
  bot: Address;
  to: Address;
  token: Address;
  amount: bigint;
  deadline: bigint;
  ref: Hex; // bytes32
}

import { encodeRef } from '@axonfi/sdk';
 
const intent: PaymentIntent = {
  bot: axon.botAddress,
  to: '0xRecipient',
  token: USDC[8453],
  amount: parseUnits('10', 6),
  deadline: BigInt(Math.floor(Date.now() / 1000) + 300),
  ref: encodeRef('my-reference'),
};
 
const signature = await axon.signPayment(intent);
// signature: "0x..." (65-byte EIP-712 signature)

import { encryptKeystore } from '@axonfi/sdk';
 
const keystore = await encryptKeystore('0xYourPrivateKey', 'my-strong-passphrase');
fs.writeFileSync('axon-bot-0xABCD1234.json', JSON.stringify(keystore, null, 2));

import { decryptKeystore } from '@axonfi/sdk';
 
const privateKey = await decryptKeystore(keystoreJson, process.env.BOT_PASSPHRASE!);

import type {
  AxonClientConfig,
  PayInput,
  SwapInput,
  PaymentResult,
  PaymentIntent,
  SwapIntent,
  PaymentStatus,
  BotConfig,
  SpendingLimit,
  OperatorCeilings,
  RebalanceTokensResult,
  KeystoreV3,
  TokenInput,
  AmountInput,
} from '@axonfi/sdk';

type TokenInput = Address | Token | KnownTokenSymbol;

type AmountInput = bigint | number | string;

type PaymentStatus = 'approved' | 'pending_review' | 'rejected';

interface OperatorCeilings {
  maxPerTxAmount: bigint;
  maxBotDailyLimit: bigint;
  maxOperatorBots: bigint;
  vaultDailyAggregate: bigint;
  minAiTriggerFloor: bigint;
}

import { parseAmount } from '@axonfi/sdk';
 
parseAmount(5.2, 'USDC')         // 5_200_000n
parseAmount('5.2', Token.USDC)   // 5_200_000n
parseAmount(0.001, 'WETH')       // 1_000_000_000_000_000n
parseAmount(5_000_000n, 'USDC')  // 5_000_000n (passthrough)

import { resolveTokenDecimals } from '@axonfi/sdk';
 
resolveTokenDecimals('USDC')                                          // 6
resolveTokenDecimals(Token.WETH)                                      // 18
resolveTokenDecimals('0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913')   // 6 (reverse lookup)

import { USDC, WINDOW, SUPPORTED_CHAIN_IDS, DEFAULT_DEADLINE_SECONDS } from '@axonfi/sdk';

import { AxonVaultAbi, AxonVaultFactoryAbi, AxonRegistryAbi } from '@axonfi/sdk';