Client

import { createClient, KaizenClient } from "@kaizen-core/sdk";
 
const client = createClient({
  rpcUrl: "http://localhost:8546", // Required: JSON-RPC endpoint
  wsUrl: "ws://localhost:8546/ws", // Optional: WebSocket endpoint
  chainId: 1, // Optional: Chain ID (default: 1)
});

// Connect as owner (sender == signer)
client.connectSigner(
  "0xac0974bec39a17e36ba4a6b4d238ff944bacb478cbed5efcae784d7bf4f2ff80"
);
 
// Check connection
if (client.hasSigner) {
  console.log(`Connected as: ${client.signerAddress}`);
  console.log(`Account: ${client.accountAddress}`); // Same as signerAddress
}

// Connect as API wallet acting on behalf of owner
client.connectAsApiWallet(
  "0x...", // API wallet private key
  "0xOwnerAddress..." // Owner address
);
 
// Check addresses
console.log(`Signer: ${client.signerAddress}`);   // API wallet address
console.log(`Account: ${client.accountAddress}`); // Owner address
console.log(`Is API Wallet: ${client.isApiWallet}`); // true
 
// All "getMy..." methods now return owner's data
const balance = await client.getMyBalance(); // Owner's balance
const theses = await client.getMyTheses();   // Owner's theses
 
// ⚠️ API wallets cannot transfer or withdraw
// await client.transfer(...);  // Will fail!
// await client.withdraw(...);  // Will fail!
 
// ✅ API wallets can perform trading operations
await client.submitRfq(...);  // OK
await client.settleRfq(...);  // OK

client.disconnectSigner();

// Get any account
const account = await client.getAccount("0x...");
console.log({
  address: account.address,
  balance: account.balance,
  apiWallets: account.apiWallets,
});
 
// Get connected signer's account
const myAccount = await client.getMyAccount();

import { formatUSDC } from "@kaizen-core/sdk";
 
const balance = await client.getBalance("0x...");
console.log(`Balance: ${formatUSDC(balance.balance)} USDC`);
 
// Or get your balance
const myBalance = await client.getMyBalance();

const thesis = await client.getThesis(1n);
if (thesis) {
  console.log({
    id: thesis.id,
    user: thesis.user,
    solver: thesis.solver,
    status: thesis.status,
    betAmount: thesis.betAmount,
    payout: thesis.payout,
  });
}

// Get all theses for a user
const theses = await client.getThesesByUser(
  "0x...",
  100, // limit
  0 // offset
);
 
// Get my theses (requires connected signer)
const myTheses = await client.getMyTheses();

const solverTheses = await client.getThesesBySolver("0x...");

const BTC_ADDRESS = "0x0000000000000000000000000000000000000001";
const USDC_ADDRESS = "0x0000000000000000000000000000000000000002";
 
const price = await client.getOraclePrice(BTC_ADDRESS, USDC_ADDRESS);
console.log({
  price: price.price,
  timestamp: new Date(price.timestamp),
});

const history = await client.getOraclePriceHistory(
  BTC_ADDRESS,
  USDC_ADDRESS,
  Date.now() - 3600000, // from: 1 hour ago
  Date.now(), // to: now
  100 // limit
);
 
for (const point of history.prices) {
  console.log(`${new Date(point.timestamp)}: ${point.price}`);
}

const block = await client.getBlock(100n);
if (block) {
  console.log({
    height: block.height,
    timestamp: block.timestamp,
    stateRoot: block.stateRoot,
    txCount: block.txCount,
  });
}

const height = await client.getBlockHeight();
console.log(`Current height: ${height}`);

const stateRoot = await client.getStateRoot();
console.log(`State root: ${stateRoot}`);

import { transfer, parseUSDC } from "@kaizen-core/sdk";
 
// Create payload and send in one call
const receipt = await client.sendTransaction(
  transfer("0x...", parseUSDC("100.00")),
  {
    waitForConfirmation: true, // Wait for confirmation
    confirmationTimeout: 30000, // Timeout in ms
  }
);
 
console.log(`Transaction ${receipt.hash}: ${receipt.status}`);

// Step 1: Sign transaction (timestamp is used for replay protection)
const signedTx = await client.signTransaction(
  transfer("0x...", parseUSDC("100.00")),
  { timestamp: BigInt(Date.now()) } // Optional: auto-set if not provided
);
 
// Step 2: Send signed transaction
const receipt = await client.sendSignedTransaction(signedTx, {
  waitForConfirmation: true,
});

const simulation = await client.simulateTransaction(
  transfer("0x...", parseUSDC("100.00"))
);
 
if (simulation.success) {
  console.log(`Gas used: ${simulation.gasUsed}`);
} else {
  console.log(`Would fail: ${simulation.error}`);
}

const receipt = await client.getTransactionStatus("0x...");
if (receipt) {
  console.log(`Status: ${receipt.status}`);
  // "pending" | "confirmed" | "failed"
}

try {
  const receipt = await client.waitForConfirmation(
    "0x...", // transaction hash
    30000 // timeout in ms
  );
  console.log("Transaction confirmed!");
} catch (error) {
  console.log("Transaction failed or timed out");
}

// Simple transfer
const receipt = await client.transfer(
  "0xRecipient...",
  parseUSDC("100.00"),
  { waitForConfirmation: true }
);

// Withdraw to external chain
const receipt = await client.withdraw(
  parseUSDC("500.00"),
  "0xExternalAddress...",
  84532, // Base Sepolia chain ID
  { waitForConfirmation: true }
);

// Authorize an API wallet for 24 hours
const receipt = await client.nominateApiWallet(
  "0xApiWallet...",
  Date.now() + 86400000, // 24 hours, 0 = no expiry
  { waitForConfirmation: true }
);

// Remove API wallet authorization
const receipt = await client.revokeApiWallet(
  "0xApiWallet...",
  { waitForConfirmation: true }
);

// Get quote from solver
const quote = await client.requestQuote(solverUrl, { ... });
 
// Submit - quote signing is handled automatically
const receipt = await client.submitRfq(quote, {
  waitForConfirmation: true
});

// Settle a thesis (usually done by Settler service)
const receipt = await client.settleRfq(
  1n, // thesisId
  { waitForConfirmation: true }
);

const quote = await client.requestQuote(
  "http://localhost:4000", // Solver API URL
  {
    user: client.signerAddress!,
    thesisType: "box",
    base: BTC_ADDRESS,
    quote: USDC_ADDRESS,
    lowerPrice: parsePrice("94000.00"),
    upperPrice: parsePrice("96000.00"),
    betAmount: parseUSDC("100.00"),
    startTime: Date.now() + 5000,
    endTime: Date.now() + 65000,
    deadline: Date.now() + 30000,
  }
);
 
console.log(`Quote payout: ${formatUSDC(quote.payout)}`);

// Get quote from solver
const quote = await client.requestQuote("http://localhost:4000", { ... });
 
// Sign the quote hash (user authorizing the thesis)
const userSignature = await client.signQuote(quote);
 
// Execute via solver
const response = await fetch("http://localhost:4000/execute", {
  method: "POST",
  headers: { "Content-Type": "application/json" },
  body: JSON.stringify({
    quote: {
      user: quote.user,
      orderType: quote.orderType,
      oraclePair: quote.oraclePair,
      priceRange: {
        lower: quote.priceRange.lower.toString(),
        upper: quote.priceRange.upper.toString(),
      },
      betAmount: quote.betAmount.toString(),
      payout: quote.payout.toString(),
      startTime: quote.startTime,
      endTime: quote.endTime,
      deadline: quote.deadline,
      signature: quote.signature,
    },
    userSignature,
  }),
});
 
const result = await response.json();
console.log(`Tx Hash: ${result.result.txHash}`);

import { RpcError } from "@kaizen-core/sdk";
 
try {
  await client.sendTransaction(transfer("0x...", parseUSDC("100.00")));
} catch (error) {
  if (error instanceof RpcError) {
    console.log(`RPC Error ${error.code}: ${error.message}`);
    console.log(`Data: ${error.data}`);
  } else {
    throw error;
  }
}

import { createClient, parseUSDC, formatUSDC } from "@kaizen-core/sdk";
 
async function main() {
  // Setup
  const client = createClient({ rpcUrl: "http://localhost:8546" });
  client.connectSigner("0x...");
 
  // Check balance
  const balance = await client.getMyBalance();
  console.log(`Balance: ${formatUSDC(balance.balance)} USDC`);
 
  // Transfer funds (high-level API)
  await client.transfer("0xRecipient...", parseUSDC("50.00"), {
    waitForConfirmation: true,
  });
 
  // Nominate API wallet for trading
  // API wallets can do everything EXCEPT withdraw and transfer
  await client.nominateApiWallet(
    "0xApiWallet...",
    Date.now() + 86400000, // 24 hours, 0 = no expiry
    { waitForConfirmation: true }
  );
 
  // Withdraw to external address
  await client.withdraw(
    parseUSDC("25.00"),
    "0xExternalAddress...",
    84532, // Base Sepolia
    { waitForConfirmation: true }
  );
}
 
main();