API Reference

new LxLyClient()

await client.init({
  network: 'testnet',
  providers: {
    0: { provider: ethereumProvider, configuration: { bridgeAddress: '0x...' } },
    1: { provider: polygonProvider, configuration: { bridgeAddress: '0x...' } }
  }
});

const token = client.erc20('0x3fd0A53F4Bf853985a95F4Eb3F9C9FDE1F8e2b53', 0);
const ethToken = client.erc20('0x0000000000000000000000000000000000000000', 0);

interface IBaseClientConfig {
  network: string;              // 'testnet' or 'mainnet'
  providers: IProviders;        // Provider configurations
  log?: boolean;                // Enable logging
  requestConcurrency?: number;  // Max concurrent requests
}

interface IProviders {
  [networkId: number]: IProviderConfig;
}

interface IProviderConfig {
  provider: any;                    // Web3 provider instance
  configuration?: {
    bridgeAddress?: string;         // Bridge contract address
    wrapperAddress?: string;        // Wrapper contract address
    bridgeExtensionAddress?: string; // Bridge extension address
    isEIP1559Supported?: boolean;   // EIP-1559 support
  };
  defaultConfig?: {
    from?: string;                  // Default sender address
  };
}

interface ITransactionOption {
  from?: string;                    // Sender address
  gasLimit?: number | string;       // Gas limit
  gasPrice?: number | string;       // Gas price
  maxFeePerGas?: number | string;   // EIP-1559 max fee
  maxPriorityFeePerGas?: number | string; // EIP-1559 priority fee
  value?: number | string;          // ETH value to send
  returnTransaction?: boolean;      // Return tx object instead of sending
  bridgeIndex?: number;             // Bridge index for multi-bridge txs
}

interface ITransactionWriteResult {
  getTransactionHash(): Promise<string>;     // Get transaction hash
  getReceipt(): Promise<ITransactionReceipt>; // Get transaction receipt
}

interface IBridgeEventInfo {
  originNetwork: number;        // Source network ID
  originTokenAddress: string;   // Source token address
  destinationNetwork: number;   // Destination network ID
  destinationAddress: string;   // Recipient address
  amount: TYPE_AMOUNT;          // Bridge amount
  metadata: string;             // Additional metadata
  depositCount: number;         // Deposit count (local index)
}

interface IClaimPayload {
  smtProof: string[];           // Merkle proof for local exit root
  smtProofRollup?: string[];    // Merkle proof for rollup exit root
  globalIndex: string;          // Global transaction index
  mainnetExitRoot: string;      // Mainnet exit root
  rollupExitRoot: string;       // Rollup exit root
  originNetwork: number;        // Source network ID
  originTokenAddress: string;   // Source token address
  destinationNetwork: number;   // Destination network ID
  destinationAddress: string;   // Recipient address
  amount: TYPE_AMOUNT;          // Amount to claim
  metadata: string;             // Transaction metadata
}

import { Web3ClientPlugin } from '@maticnetwork/maticjs-web3';
use(Web3ClientPlugin);

setProofApi('https://api-gateway.polygon.technology/api/v3/proof/testnet/');

const ADDRESS_ZERO = '0x0000000000000000000000000000000000000000';
const MAX_AMOUNT = '0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff';

enum Permit {
  DAI = "DAI",
  EIP_2612 = "EIP_2612", 
  UNISWAP = "UNISWAP"
}

enum ERROR_TYPE {
  AllowedOnEthereum = "allowed_on_ethereum",
  ProofAPINotSet = "proof_api_not_set",
  EIP1559NotSupported = "eip-1559_not_supported",
  BridgeAdapterNotFound = "bridge_adapter_address_not_passed"
}

// Handle insufficient allowance
try {
  await token.bridgeAsset(amount, userAddress, destinationNetwork);
} catch (error) {
  if (error.message.includes('allowance')) {
    console.log('Insufficient allowance, approving...');
    await token.approve(amount);
    // Retry bridge operation
    await token.bridgeAsset(amount, userAddress, destinationNetwork);
  }
}

// Handle network issues
async function robustNetworkCall(operation) {
  const maxRetries = 3;
  let lastError;
  
  for (let i = 0; i < maxRetries; i++) {
    try {
      return await operation();
    } catch (error) {
      lastError = error;
      if (error.message.includes('network')) {
        console.log(`Network error, retrying... (${i + 1}/${maxRetries})`);
        await new Promise(resolve => setTimeout(resolve, 2000 * (i + 1)));
      } else {
        throw error; // Non-network error, don't retry
      }
    }
  }
  
  throw lastError;
}

// Old initialization (v2.2.x)
const client = new LxLyClient();
await client.init(config);

// New initialization (v2.3.x) - same API
const client = new LxLyClient();
await client.init(config);

// Bridge operations remain the same
const result = await token.bridgeAsset(amount, userAddress, destinationNetwork);

// 1. Reuse client instances
const globalClient = await initializeClient();

// 2. Cache token instances
const tokenCache = new Map();
function getToken(address, networkId) {
  const key = `${address}-${networkId}`;
  if (!tokenCache.has(key)) {
    tokenCache.set(key, globalClient.erc20(address, networkId));
  }
  return tokenCache.get(key);
}

// 3. Batch read operations
const [balance, allowance, totalSupply] = await Promise.all([
  token.getBalance(userAddress),
  token.getAllowance(userAddress),
  contract.read('totalSupply')
]);

// 4. Use appropriate gas limits
const gasLimits = {
  approve: 80000,
  bridgeAsset: 300000,
  claimAsset: 400000,
  bridgeMessage: 350000,
  claimMessage: 450000
};