Currency Utilities

/**
 * Convert winston to AR
 * @param winstonString - Amount in winston as string
 * @param options - Formatting options
 * @returns AR amount as string
 */
winstonToAr(winstonString: string, options?): string;

import Arweave from "arweave";

const arweave = Arweave.init();

// Convert balance from winston to AR
const balanceWinston = "1000000000000"; // 1 AR in winston
const balanceAr = arweave.ar.winstonToAr(balanceWinston);
console.log(`Balance: ${balanceAr} AR`); // "1.000000000000"

// Large amount
const largeWinston = "5500000000000000"; // 5500 AR
const largeAr = arweave.ar.winstonToAr(largeWinston);
console.log(`Large amount: ${largeAr} AR`); // "5500.000000000000"

/**
 * Convert AR to winston
 * @param arString - Amount in AR as string
 * @param options - Formatting options
 * @returns Winston amount as string
 */
arToWinston(arString: string, options?): string;

// Convert user input to winston for transactions
const userAmount = "0.5"; // User wants to send 0.5 AR
const winstonAmount = arweave.ar.arToWinston(userAmount);
console.log(`Winston equivalent: ${winstonAmount}`); // "500000000000"

// Create transaction with winston amount
const transaction = await arweave.createTransaction({
  target: "target-address",
  quantity: winstonAmount
}, key);

/**
 * Compare two winston amounts
 * @param winstonStringA - First amount in winston
 * @param winstonStringB - Second amount in winston  
 * @returns -1 if A < B, 0 if A = B, 1 if A > B
 */
compare(winstonStringA: string, winstonStringB: string): number;

const amount1 = "1000000000000"; // 1 AR
const amount2 = "2000000000000"; // 2 AR

const result = arweave.ar.compare(amount1, amount2);
if (result < 0) {
  console.log("Amount 1 is less than Amount 2");
} else if (result > 0) {
  console.log("Amount 1 is greater than Amount 2");
} else {
  console.log("Amounts are equal");
}

/**
 * Check if two winston amounts are equal
 * @param winstonStringA - First amount in winston
 * @param winstonStringB - Second amount in winston
 * @returns True if amounts are equal
 */
isEqual(winstonStringA: string, winstonStringB: string): boolean;

const balance = await arweave.wallets.getBalance(address);
const requiredAmount = arweave.ar.arToWinston("1.0");

if (arweave.ar.isEqual(balance, requiredAmount)) {
  console.log("Exact amount available");
}

/**
 * Check if first amount is less than second
 * @param winstonStringA - First amount in winston
 * @param winstonStringB - Second amount in winston
 * @returns True if A < B
 */
isLessThan(winstonStringA: string, winstonStringB: string): boolean;

const balance = await arweave.wallets.getBalance(address);
const transactionCost = await arweave.transactions.getPrice(dataSize);

if (arweave.ar.isLessThan(balance, transactionCost)) {
  console.log("Insufficient balance for transaction");
}

/**
 * Check if first amount is greater than second
 * @param winstonStringA - First amount in winston
 * @param winstonStringB - Second amount in winston
 * @returns True if A > B
 */
isGreaterThan(winstonStringA: string, winstonStringB: string): boolean;

const balance = await arweave.wallets.getBalance(address);
const minimumRequired = arweave.ar.arToWinston("10.0");

if (arweave.ar.isGreaterThan(balance, minimumRequired)) {
  console.log("Balance exceeds minimum requirement");
}

/**
 * Add two winston amounts
 * @param winstonStringA - First amount in winston
 * @param winstonStringB - Second amount in winston
 * @returns Sum in winston as string
 */
add(winstonStringA: string, winstonStringB: string): string;

const balance1 = "1000000000000"; // 1 AR
const balance2 = "2500000000000"; // 2.5 AR

const totalBalance = arweave.ar.add(balance1, balance2);
const totalAr = arweave.ar.winstonToAr(totalBalance);
console.log(`Total balance: ${totalAr} AR`); // "3.500000000000"

/**
 * Subtract second amount from first
 * @param winstonStringA - Amount to subtract from
 * @param winstonStringB - Amount to subtract
 * @returns Difference in winston as string
 */
sub(winstonStringA: string, winstonStringB: string): string;

const currentBalance = await arweave.wallets.getBalance(address);
const transactionCost = await arweave.transactions.getPrice(dataSize);

const remainingBalance = arweave.ar.sub(currentBalance, transactionCost);
const remainingAr = arweave.ar.winstonToAr(remainingBalance);
console.log(`Remaining after transaction: ${remainingAr} AR`);

async function canAffordTransaction(address: string, dataSize: number): Promise<boolean> {
  const balance = await arweave.wallets.getBalance(address);
  const cost = await arweave.transactions.getPrice(dataSize);
  
  return arweave.ar.isGreaterThan(balance, cost);
}

// Usage
const address = "wallet-address";
const data = "Hello, Arweave!";
const dataSize = new TextEncoder().encode(data).length;

if (await canAffordTransaction(address, dataSize)) {
  console.log("Transaction can be afforded");
} else {
  console.log("Insufficient balance");
}

async function calculatePortfolioValue(addresses: string[]): Promise<string> {
  let totalWinston = "0";
  
  for (const address of addresses) {
    const balance = await arweave.wallets.getBalance(address);
    totalWinston = arweave.ar.add(totalWinston, balance);
  }
  
  return arweave.ar.winstonToAr(totalWinston);
}

// Usage
const walletAddresses = ["addr1", "addr2", "addr3"];
const totalAr = await calculatePortfolioValue(walletAddresses);
console.log(`Portfolio value: ${totalAr} AR`);

async function calculateTotalCostWithBuffer(dataSize: number, bufferPercent: number = 10): Promise<string> {
  const baseCost = await arweave.transactions.getPrice(dataSize);
  const buffer = arweave.ar.arToWinston((parseFloat(arweave.ar.winstonToAr(baseCost)) * bufferPercent / 100).toString());
  const totalCost = arweave.ar.add(baseCost, buffer);
  
  return totalCost;
}

// Usage - add 10% buffer to transaction cost
const dataSize = 1024;
const costWithBuffer = await calculateTotalCostWithBuffer(dataSize, 10);
console.log(`Cost with 10% buffer: ${arweave.ar.winstonToAr(costWithBuffer)} AR`);

/** Number of decimal places in AR currency */
const AR_PRECISION: number = 12;

/** Winston to AR conversion factor (1 AR = 10^12 winston) */
const WINSTON_MULTIPLIER: number = 1000000000000;