@silentswap/sdk 0.0.21 → 0.0.22

package/dist/assets.d.ts

@@ -0,0 +1,55 @@
+import type { Caip19, Caip2 } from './types/core.js';
+export interface AssetInfo {
+    caip19: Caip19;
+    coingeckoId: string;
+    name: string;
+    symbol: string;
+    decimals: number;
+    gradient: [string, string];
+    style?: string;
+    ext?: string;
+    precision?: number;
+}
+export interface ChainInfo {
+    coingeckoPlatformId?: string;
+    coingeckoId?: string;
+    shortName?: string;
+    native?: {
+        slip44: number;
+        decimals: number;
+        symbol: string;
+    };
+    caip2: Caip2;
+    nativeCoinId?: string;
+    name: string;
+}
+export interface AssetsData {
+    chains: Record<Caip2, ChainInfo>;
+    assets: Record<Caip19, AssetInfo>;
+}
+export declare function loadAssetsData(): AssetsData;
+export declare function getAllAssets(): Record<Caip19, AssetInfo>;
+export declare function getAllChains(): Record<Caip2, ChainInfo>;
+export declare function getAllAssetsArray(): AssetInfo[];
+export declare const COMMON_ASSETS: AssetInfo[];
+export declare const CHAIN_NAMES: Record<string, string>;
+/**
+ * Get asset by CAIP-19 identifier from the full dataset
+ */
+export declare function getAssetByCaip19(caip19: Caip19): AssetInfo | undefined;
+/**
+ * Get chain info by CAIP-2 identifier
+ */
+export declare function getChainByCaip2(caip2: Caip2): ChainInfo | undefined;
+/**
+ * Get all assets filtered by chain ID (for ingress/egress)
+ */
+export declare function getAssetsByChain(chainId: string, ingress?: boolean): AssetInfo[];
+/**
+ * Get chain name from chain ID
+ */
+export declare function getChainName(chainId: string): string;
+/**
+ * Search assets by symbol, name, or CAIP-19
+ */
+export declare function searchAssets(query: string): AssetInfo[];

package/dist/assets.js

@@ -0,0 +1,101 @@
+import filteredData from './data/filtered.json' with { type: 'json' };
+// Load assets data from filtered.json
+export function loadAssetsData() {
+    return filteredData;
+}
+// Get all assets from the filtered data
+export function getAllAssets() {
+    return filteredData.assets;
+}
+// Get all chains from the filtered data
+export function getAllChains() {
+    return filteredData.chains;
+}
+// Get all assets as an array for easy iteration
+export function getAllAssetsArray() {
+    const assets = filteredData.assets;
+    return Object.values(assets).map(asset => ({
+        ...asset,
+        gradient: asset.gradient.length >= 2
+            ? [asset.gradient[0], asset.gradient[1]]
+            : ['000000', '000000'],
+        caip19: asset.caip19,
+    }));
+}
+// Common tokens list - frequently used assets for quick access
+// This is a subset extracted from filtered.json for convenience
+export const COMMON_ASSETS = getAllAssetsArray().filter(asset => {
+    // Filter to commonly used tokens
+    const commonCaip19s = [
+        'eip155:43114/erc20:0xB97EF9Ef8734C71904D8002F8b6Bc66Dd9c48a6E', // USDC Avalanche
+        'eip155:1/erc20:0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48', // USDC Ethereum
+        'eip155:1/erc20:0xdAC17F958D2ee523a2206206994597C13D831ec7', // USDT Ethereum
+        'eip155:43114/erc20:0x9702230A8Ea53601f5cD2dc00fDBc13d4dF4A8c7', // USDT Avalanche
+        'eip155:1/slip44:60', // ETH
+        'eip155:43114/slip44:9005', // AVAX
+        'eip155:10/erc20:0x7F5c764cBc14f9669B88837ca1490cCa17c31607', // USDC Optimism
+        'eip155:56/erc20:0x8AC76a51cc950d9822D68b83fE1Ad97B32Cd580d', // USDC BSC
+        'eip155:137/erc20:0x3c499c542cEF5E3811e1192ce70d8cC03d5c3359', // USDC Polygon
+        'eip155:8453/erc20:0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913', // USDC Base
+        'eip155:42161/erc20:0xaf88d065e77c8cC2239327C5EDb3A432268e5831', // USDC Arbitrum
+    ];
+    return commonCaip19s.includes(asset.caip19);
+});
+// Build chain names map from filtered data
+export const CHAIN_NAMES = Object.fromEntries(Object.entries(filteredData.chains).map(([caip2, chain]) => {
+    const match = caip2.match(/^eip155:(\d+)$/);
+    if (match) {
+        return [match[1], chain.name];
+    }
+    return [];
+}).filter((entry) => entry.length > 0));
+/**
+ * Get asset by CAIP-19 identifier from the full dataset
+ */
+export function getAssetByCaip19(caip19) {
+    const assets = filteredData.assets;
+    const asset = assets[caip19];
+    if (!asset)
+        return undefined;
+    return {
+        ...asset,
+        gradient: asset.gradient.length >= 2
+            ? [asset.gradient[0], asset.gradient[1]]
+            : ['000000', '000000'],
+        caip19: asset.caip19,
+    };
+}
+/**
+ * Get chain info by CAIP-2 identifier
+ */
+export function getChainByCaip2(caip2) {
+    const chains = filteredData.chains;
+    return chains[caip2];
+}
+/**
+ * Get all assets filtered by chain ID (for ingress/egress)
+ */
+export function getAssetsByChain(chainId, ingress = true) {
+    return getAllAssetsArray().filter(asset => {
+        const match = asset.caip19.match(/^eip155:(\d+)\//);
+        if (!match)
+            return false;
+        return match[1] === chainId;
+    });
+}
+/**
+ * Get chain name from chain ID
+ */
+export function getChainName(chainId) {
+    const chainInfo = getChainByCaip2(`eip155:${chainId}`);
+    return chainInfo?.name || CHAIN_NAMES[chainId] || `Chain ${chainId}`;
+}
+/**
+ * Search assets by symbol, name, or CAIP-19
+ */
+export function searchAssets(query) {
+    const lowerQuery = query.toLowerCase();
+    return getAllAssetsArray().filter(asset => asset.symbol.toLowerCase().includes(lowerQuery) ||
+        asset.name.toLowerCase().includes(lowerQuery) ||
+        asset.caip19.toLowerCase().includes(lowerQuery));
+}

package/dist/bridge.d.ts

@@ -0,0 +1,211 @@
+import type { Hex } from 'viem';
+/**
+ * Bridge provider types
+ */
+export type BridgeProvider = 'relay' | 'debridge';
+/**
+ * Bridge quote interface
+ */
+export interface BridgeQuote {
+    provider: BridgeProvider;
+    estimatedTime: number;
+    fee: {
+        amount: string;
+        token: string;
+        usdValue?: number;
+    };
+    slippage: number;
+    route: any;
+    txs: BridgeTransaction[];
+}
+/**
+ * Bridge transaction interface
+ */
+export interface BridgeTransaction {
+    to: `0x${string}`;
+    value: string;
+    data: `0x${string}`;
+    gasLimit?: string;
+    chainId: number;
+}
+/**
+ * Bridge status interface
+ */
+export interface BridgeStatus {
+    status: 'pending' | 'success' | 'failed' | 'refund' | 'fallback';
+    txHashes?: Hex[];
+    details?: string;
+    requestId?: string;
+}
+/**
+ * Bridge quote parameters
+ */
+export interface BridgeQuoteParams {
+    /** Source chain ID */
+    srcChainId: number;
+    /** Destination chain ID */
+    dstChainId: number;
+    /** Source token address (0x0 for native) */
+    srcToken: `0x${string}`;
+    /** Destination token address */
+    dstToken: `0x${string}`;
+    /** Amount to bridge (in source token units) */
+    amount: string;
+    /** Recipient address on destination chain */
+    recipient: `0x${string}`;
+    /** User/sender address for the bridge operation */
+    user: `0x${string}`;
+    /** Additional transactions to execute after bridging */
+    additionalTxs?: BridgeTransaction[];
+    /** Trade type for the bridge operation */
+    tradeType: 'EXACT_INPUT' | 'EXACT_OUTPUT' | 'EXPECTED_OUTPUT';
+    /** Whether to prepend operating expenses (deBridge only) */
+    prependOperatingExpenses?: boolean;
+    /** Whether to enable estimation (deBridge only) */
+    enableEstimate?: boolean;
+}
+/**
+ * Get a quote from relay.link
+ */
+export declare function getRelayQuote(params: BridgeQuoteParams, apiKey?: string): Promise<BridgeQuote>;
+/**
+ * Get a quote from debridge (handles both cross-chain and same-chain swaps)
+ */
+export declare function getDebridgeQuote(params: BridgeQuoteParams, apiKey?: string): Promise<BridgeQuote>;
+/**
+ * Execute a relay.link bridge transaction
+ */
+export declare function executeRelayBridge(quote: BridgeQuote, executeTransaction: (tx: BridgeTransaction) => Promise<Hex>, switchChain: (chainId: number) => Promise<void>, setStep: (step: string) => void): Promise<BridgeStatus>;
+/**
+ * Execute a debridge bridge transaction
+ */
+export declare function executeDebridgeBridge(quote: BridgeQuote, executeTransaction: (tx: BridgeTransaction) => Promise<Hex>, switchChain: (chainId: number) => Promise<void>, setStep: (step: string) => void): Promise<BridgeStatus>;
+/**
+ * Get relay.link bridge status
+ */
+export declare function getRelayStatus(requestId: string): Promise<BridgeStatus>;
+/**
+ * Get debridge bridge status
+ */
+export declare function getDebridgeStatus(requestId: string): Promise<BridgeStatus>;
+/**
+ * Advanced bridge API types for optimal solving
+ */
+export interface RelayQuoteParams {
+    user: string;
+    originChainId: number;
+    destinationChainId: number;
+    originCurrency: string;
+    destinationCurrency: string;
+    amount: string;
+    tradeType: 'EXACT_INPUT' | 'EXACT_OUTPUT';
+    recipient?: string;
+    referrer?: string;
+    txs?: Array<{
+        to: string;
+        value: string;
+        data: string;
+    }>;
+    txsGasLimit?: number;
+}
+export interface RelayQuoteResponse {
+    details: {
+        currencyIn: {
+            amount: string;
+            amountUsd: number;
+        };
+        currencyOut: {
+            amount: string;
+            amountUsd: number;
+        };
+        totalImpact: {
+            percent: string;
+        };
+        timeEstimate: number;
+    };
+    fees: {
+        gas: {
+            amount?: string;
+            amountUsd?: string;
+        };
+        relayer: {
+            amountUsd?: string;
+        };
+        relayerGas: {
+            amountUsd?: string;
+        };
+    };
+}
+export interface DeBridgeOrderParams {
+    srcChainId: number;
+    dstChainId: number;
+    srcChainTokenIn: string;
+    dstChainTokenOut: string;
+    srcChainTokenInAmount: string;
+    dstChainTokenOutAmount: string;
+    dstChainTokenOutRecipient?: string;
+    account?: string;
+    prependOperatingExpenses?: boolean;
+    enableEstimate?: boolean;
+    dlnHook?: string;
+}
+export interface DeBridgeOrderResponse {
+    tx: {
+        allowanceTarget?: string;
+    };
+    estimation: {
+        srcChainTokenIn: {
+            amount: string;
+            approximateUsdValue: number;
+        };
+        dstChainTokenOut: {
+            amount: string;
+            approximateUsdValue: number;
+        };
+        costDetails?: Array<{
+            payload?: {
+                feeApproximateUsdValue?: string;
+            };
+        }>;
+    };
+    estimatedTransactionFee?: {
+        total?: string;
+    };
+    order?: {
+        approximateFulfillmentDelay?: number;
+    };
+}
+/**
+ * Fetch a relay.link quote with detailed response
+ */
+export declare function fetchRelayQuote(params: RelayQuoteParams, signal?: AbortSignal): Promise<RelayQuoteResponse>;
+/**
+ * Fetch a deBridge order with detailed response (handles both cross-chain and same-chain swaps)
+ */
+export declare function fetchDebridgeOrder(params: DeBridgeOrderParams, signal?: AbortSignal): Promise<DeBridgeOrderResponse>;
+/**
+ * Result from solving optimal USDC amount
+ */
+export interface SolveUsdcResult {
+    /** Optimal USDC amount out (in microUSDC) */
+    usdcAmountOut: bigint;
+    /** Actual input amount required */
+    actualAmountIn: bigint;
+    /** Bridge provider used */
+    provider: BridgeProvider;
+    /** Allowance target address (for deBridge) */
+    allowanceTarget: string;
+}
+/**
+ * Solve for optimal USDC amount using both relay and debridge providers
+ * Compares rates and returns the best option
+ *
+ * @param srcChainId - Source chain ID
+ * @param srcToken - Source token address (use 0x0 for native)
+ * @param srcAmount - Source amount in token units (as string)
+ * @param userAddress - User's EVM address
+ * @param depositCalldata - Optional deposit calldata (will use phony if not provided)
+ * @param maxImpactPercent - Maximum price impact percentage allowed (default from constants)
+ * @returns Promise resolving to solve result with optimal amounts
+ */
+export declare function solveOptimalUsdcAmount(srcChainId: number, srcToken: string, srcAmount: string, userAddress: string, depositCalldata?: string, maxImpactPercent?: number): Promise<SolveUsdcResult>;