Withdraw Tokens

import { MonacoSDK } from '@0xmonaco/core';
import { createWalletClient, custom, parseUnits } from 'viem';
import { seiTestnet } from 'viem/chains';

// Request account access
const [account] = await window.ethereum.request({ 
  method: 'eth_requestAccounts' 
});

// Connect to user's wallet
const walletClient = createWalletClient({
  account,
  chain: seiTestnet,
  transport: custom(window.ethereum)
});

// Setup SDK
const sdk = new MonacoSDK({
  walletClient,
  network: 'staging',
  seiRpcUrl: 'https://evm-rpc-testnet.sei-apis.com', // public testnet RPC — use a private provider in production
});

// Authenticate first
await sdk.login('your-client-id');

// Get trading pair to find asset IDs
// Asset IDs come from trading pairs, not balances
const tradingPair = await sdk.market.getTradingPairBySymbol('BTC/USDC');

// Get the asset ID for vault operations
const assetId = tradingPair.quoteAssetId;  // USDC asset ID
const amount = parseUnits('50', 6);

// Optional: Check vault balance first
const balance = await sdk.profile.getUserBalanceByAssetId(assetId);
console.log(`Available: ${balance.availableBalance}`);

// Withdraw tokens (uses asset ID)
const withdrawResult = await sdk.vault.withdraw(assetId, amount);
console.log('Withdrawal transaction:', withdrawResult.hash);

// Log in to authorize an ed25519 session key that signs each request (no tokens)
const authState = await sdk.login('your-client-id');
console.log('Authenticated as:', authState.user.address);

// Get trading pair to access asset IDs
const tradingPair = await sdk.market.getTradingPairBySymbol('BTC/USDC');

// For withdrawing USDC (the quote token):
const assetId = tradingPair.quoteAssetId;
const decimals = 6; // USDC decimals

// For withdrawing BTC (the base token):
// const assetId = tradingPair.baseAssetId;
// const decimals = 8; // BTC decimals

// Check current vault balance
const balance = await sdk.profile.getUserBalanceByAssetId(assetId);
console.log(`Available balance: ${balance.availableBalance} ${balance.symbol}`);

// Check if you have enough to withdraw
const withdrawAmount = parseUnits('25', decimals);
if (BigInt(balance.availableBalanceRaw) < withdrawAmount) {
  console.error('Insufficient vault balance');
  return;
}

const withdrawAmount = parseUnits('25', decimals);

// Execute withdrawal (uses asset ID)
const withdrawResult = await sdk.vault.withdraw(assetId, withdrawAmount);
console.log('Withdrawal confirmed:', withdrawResult.status);
console.log('Transaction hash:', withdrawResult.hash);

// Check updated vault balance
const newVaultBalance = await sdk.profile.getUserBalanceByAssetId(assetId);
console.log(`New vault balance: ${newVaultBalance.availableBalance} ${newVaultBalance.symbol}`);

import { MonacoSDK } from '@0xmonaco/core';
import { createWalletClient, custom, parseUnits, formatUnits } from 'viem';
import { seiTestnet } from 'viem/chains';

async function withdrawTokens(tradingPairSymbol: string, symbol: string, withdrawAmount: string) {
  // Request account access
  const [account] = await window.ethereum.request({ 
    method: 'eth_requestAccounts' 
  });

  // Initialize SDK
  const walletClient = createWalletClient({
    account,
    chain: seiTestnet,
    transport: custom(window.ethereum)
  });

  const sdk = new MonacoSDK({
    walletClient,
    network: 'staging',
    seiRpcUrl: 'https://evm-rpc-testnet.sei-apis.com',
  });

  try {
    // 1. Authenticate
    console.log('Authenticating...');
    await sdk.login('your-client-id');

    // 2. Get asset information from trading pair
    console.log('Fetching trading pair...');
    const tradingPair = await sdk.market.getTradingPairBySymbol(tradingPairSymbol);

    // Determine which side of the pair we're withdrawing
    // For 'BTC/USDC': base = BTC, quote = USDC
    const isBase = symbol === tradingPair.baseToken;
    const assetId = isBase 
      ? tradingPair.baseAssetId 
      : tradingPair.quoteAssetId;
    const decimals = isBase ? 8 : 6; // Adjust based on token
    const amount = parseUnits(withdrawAmount, decimals);

    // 3. Check vault balance
    console.log('Checking vault balance...');
    const balance = await sdk.profile.getUserBalanceByAssetId(assetId);
    console.log(`Current vault balance: ${balance.availableBalance} ${balance.symbol}`);

    // Verify sufficient balance
    if (BigInt(balance.availableBalanceRaw) < amount) {
      throw new Error('Insufficient vault balance for withdrawal');
    }

    // 4. Execute withdrawal
    console.log('Withdrawing tokens...');
    const withdrawResult = await sdk.vault.withdraw(assetId, amount);
    console.log('Withdrawal confirmed:', withdrawResult.hash);

    // 5. Check updated balance
    const newBalance = await sdk.profile.getUserBalanceByAssetId(assetId);
    console.log(`New vault balance: ${newBalance.availableBalance} ${newBalance.symbol}`);

  } catch (error) {
    console.error('Withdrawal failed:', error.message);
  }
}

// Usage - withdraw 25 USDC using the BTC/USDC trading pair
withdrawTokens('BTC/USDC', 'USDC', '25');

// Get asset information from trading pair
const tradingPair = await sdk.market.getTradingPairBySymbol('BTC/USDC');
const assetId = tradingPair.quoteAssetId;  // USDC

// Get current balance
const balance = await sdk.profile.getUserBalanceByAssetId(assetId);
console.log(`Total balance: ${balance.totalBalance} ${balance.symbol}`);

// Withdraw 50% of balance
const halfAmount = BigInt(balance.availableBalanceRaw) / 2n;
const withdrawResult = await sdk.vault.withdraw(assetId, halfAmount);

console.log(`Withdrawing ${formatUnits(halfAmount, balance.decimals)} ${balance.symbol}`);

// Get asset information from trading pair
const tradingPair = await sdk.market.getTradingPairBySymbol('BTC/USDC');
const assetId = tradingPair.quoteAssetId;  // USDC

// Get full balance
const balance = await sdk.profile.getUserBalanceByAssetId(assetId);

const availableAmount = BigInt(balance.availableBalanceRaw);

if (availableAmount > 0n) {
  // Withdraw entire balance
  const withdrawResult = await sdk.vault.withdraw(assetId, availableAmount);
  console.log(`Withdrawing all ${balance.availableBalance} ${balance.symbol}`);
  console.log('Complete withdrawal successful');
} else {
  console.log('No tokens to withdraw');
}

import { ContractError, APIError } from '@0xmonaco/core';

try {
  await sdk.vault.withdraw(assetId, amount);
} catch (error) {
  if (error instanceof ContractError) {
    if (error.message.includes('insufficient balance')) {
      console.error('Not enough tokens in vault');
    } else if (error.message.includes('ASSET_NOT_FOUND')) {
      console.error('Invalid asset ID - use trading pairs to get valid asset IDs');
    } else {
      console.error('Contract error:', error.message);
    }
  } else if (error instanceof APIError) {
    console.error('API error:', error.message);
  }
}

interface WithdrawResult {
  /** Index allocated by the matching engine — store this for retries */
  withdrawalIndex: number;
  /** Transaction hash */
  hash: string;
  /** Transaction status */
  status: "pending" | "confirmed" | "failed";
  /** Nonce used for this operation */
  nonce: bigint;
  /** Transaction receipt (only available when autoWait is enabled) */
  receipt?: TransactionReceipt;
}

// Example usage
const result = await sdk.vault.withdraw(assetId, amount);
console.log('Withdrawal index:', result.withdrawalIndex);
console.log('Hash:', result.hash);
console.log('Status:', result.status);
// Receipt is available when autoWait is true (default)
console.log('Receipt:', result.receipt);

await sdk.vault.retryWithdrawal(result.withdrawalIndex);

// Authenticated: debits the balance and returns the signed calldata (no broadcast)
const withdrawal = await sdk.withdrawals.initiateWithdrawal({
  assetId,
  amount: amount.toString(),  // raw smallest-unit amount as a string
  destination: '0xYourWalletAddress',
});

console.log('Withdrawal index:', withdrawal.withdrawalIndex);
console.log('Vault address:', withdrawal.vaultAddress);

// Submit the calldata yourself
const hash = await walletClient.sendTransaction({
  to: withdrawal.vaultAddress,
  data: withdrawal.calldata,
});

// Public re-fetch of the signed calldata for a previously-initiated index
const again = await sdk.withdrawals.getWithdrawal(withdrawal.withdrawalIndex);

async function validateWithdrawal(assetId: string, amount: bigint) {
  const balance = await sdk.profile.getUserBalanceByAssetId(assetId);
  
  if (BigInt(balance.availableBalanceRaw) < amount) {
    throw new Error(`Insufficient balance. Available: ${balance.availableBalance}, Requested: ${formatUnits(amount, balance.decimals)}`);
  }
  
  return true;
}

// Use before withdrawal
await validateWithdrawal(assetId, withdrawAmount);
const result = await sdk.vault.withdraw(assetId, withdrawAmount);

// Get valid asset IDs from trading pairs
// Returns ListTradingPairsResponse: { tradingPairs: TradingPair[], page, pageSize, total, totalPages }
const response = await sdk.market.getPaginatedTradingPairs();
const tradingPairs = response.tradingPairs;

console.log('Available assets:', tradingPairs.map(tp => ({
  symbol: tp.symbol,
  baseAssetId: tp.baseAssetId,
  quoteAssetId: tp.quoteAssetId,
  baseContract: tp.baseTokenContract,
  quoteContract: tp.quoteTokenContract
})));

// Check vault balance before withdrawal
const balance = await sdk.profile.getUserBalanceByAssetId(assetId);
if (BigInt(balance.availableBalanceRaw) < withdrawAmount) {
  console.error(`Insufficient balance. Available: ${balance.availableBalance}`);
  return;
}

// The SDK auto-waits for confirmation by default
// You can disable auto-wait if needed:
const result = await sdk.vault.withdraw(assetId, amount, false);
// Then manually wait later
const receipt = await sdk.waitForTransaction(result.hash);

// If withdrawal signature fails, ensure you're authenticated
try {
  await sdk.vault.withdraw(assetId, amount);
} catch (error) {
  if (error.message.includes('signature') || error.message.includes('unauthorized')) {
    console.log('Re-authenticating...');
    await sdk.login('your-client-id');
    // Retry withdrawal
    await sdk.vault.withdraw(assetId, amount);
  }
}