import { Vultisig, Chain } from '@vultisig/sdk'

// Initialize SDK (storage is auto-configured for your platform)
const sdk = new Vultisig()
await sdk.initialize()

// Create a fast vault (server-assisted 2-of-2)
const vaultId = await sdk.createFastVault({
  name: "My Wallet",
  email: "user@example.com",
  password: "secure-password",
});

// Verify with email code
const vault = await sdk.verifyVault(vaultId, "1234");

// Derive addresses
const btcAddress = await vault.address(Chain.Bitcoin);
const ethAddress = await vault.address(Chain.Ethereum);

// Send tokens (human-readable amounts)
const result = await vault.send({ chain: Chain.Ethereum, to: "0x...", amount: "0.1" });

// Sign messages (EIP-191 for EVM, SHA-256 for others)
const { signature } = await vault.signMessage("Login to MyDapp");

// Swap tokens
await vault.swap({ fromChain: Chain.Ethereum, fromSymbol: "ETH", toChain: Chain.Bitcoin, toSymbol: "BTC", amount: "0.5" });

// Portfolio overview
const portfolio = await vault.portfolio("usd");

// Create a secure vault (2-of-3 threshold)
const { vault } = await sdk.createSecureVault({
  name: "Team Wallet",
  devices: 3,
  onQRCodeReady: (qrPayload) => {
    // Display QR code for other devices to scan
    displayQRCode(qrPayload);
  },
  onDeviceJoined: (deviceId, total, required) => {
    console.log(`Device joined: ${total}/${required}`);
  }
});

// Sign transactions (requires device coordination)
await vault.sign(payload, {
  onQRCodeReady: (qr) => displayQRCode(qr),
  onDeviceJoined: (id, total, required) => {
    console.log(`Signing: ${total}/${required} devices ready`);
  }
});

type Balance = {
  amount: string           // Raw amount in base units (as string)
  formattedAmount: string  // Human-readable (e.g., "1.5")
  decimals: number         // Token decimal places
  symbol: string           // Token symbol (e.g., "ETH", "BTC")
  chainId: string          // Chain identifier
  tokenId?: string         // Token contract address (if not native coin)
  value?: number           // Price per unit in fiat (populated by portfolio)
  fiatValue?: number       // Total fiat value (populated by portfolio)
  fiatCurrency?: string    // Fiat currency code (e.g., "USD")
}

await vault.portfolio("usd")

type Portfolio = {
  balances: Balance[]   // Balances with fiat values populated
  totalValue: string    // Total portfolio value (human-readable, e.g., "1234.56")
  currency: string      // Fiat currency used (e.g., "usd")
}

// Execute
const result = await vault.send({ chain: Chain.Ethereum, to: "0x...", amount: "0.1" })
// result.txHash -> "0xabc..."

// Dry run (estimate fees without signing)
const preview = await vault.send({ chain: Chain.Ethereum, to: "0x...", amount: "0.1", dryRun: true })
// preview.fee -> "0.00042"
// preview.total -> "0.10042"

type SendResult =
  | { dryRun: false; txHash: string; chain: Chain }
  | { dryRun: true; fee: string; total: string; keysignPayload: KeysignPayload }

// Dry run (get quote)
const quote = await vault.swap({
  fromChain: Chain.Ethereum, fromSymbol: "ETH",
  toChain: Chain.Ethereum, toSymbol: "USDC",
  amount: "0.5", dryRun: true
})
// quote.quote.provider -> "1inch"
// quote.quote.estimatedOutput -> bigint (base units)
// quote.quote.fees -> fee breakdown

// Execute
const result = await vault.swap({
  fromChain: Chain.Ethereum, fromSymbol: "ETH",
  toChain: Chain.Bitcoin, toSymbol: "BTC",
  amount: "0.5"
})
// result.txHash -> "0xabc..."

type CompoundSwapResult =
  | { dryRun: false; txHash: string; chain: Chain; quote: SwapQuoteResult }
  | { dryRun: true; quote: SwapQuoteResult }

type SwapQuoteResult = {
  quote: SwapQuote               // Raw quote from provider
  estimatedOutput: bigint        // Output amount in base units
  estimatedOutputFiat?: number   // Output in fiat
  provider: string               // "thorchain", "1inch", "kyber", "li.fi", "maya"
  expiresAt: number              // Quote expiry (ms)
  requiresApproval: boolean      // ERC-20 approval needed?
  approvalInfo?: SwapApprovalInfo // Approval details (when required)
  fees: SwapFees                 // Fee breakdown (base units)
  feesFiat?: SwapFeesFiat        // Fee breakdown in fiat
  warnings: string[]             // Provider warnings
  fromCoin: ResolvedCoinInfo     // Source coin details
  toCoin: ResolvedCoinInfo       // Destination coin details
  balance: bigint                // Source balance (base units)
  maxSwapable: bigint            // Max swappable (base units)
}

const { signature, chain, algorithm } = await vault.signMessage("Hello World")

type MessageSignature = {
  signature: string        // Hex-encoded (e.g., "0x..." for EVM)
  chain: Chain             // Chain used for signing
  algorithm: 'ECDSA' | 'EdDSA'
}

// List all vaults
const vaults: VaultBase[] = await sdk.listVaults()

// Find by name (listVaults + filter)
const vault = vaults.find(v => v.name === 'MyVault')

// By ID
const vault: VaultBase | null = await sdk.getVaultById("vault-id")

// Active vault
const vault: VaultBase | null = await sdk.getActiveVault()