@silentswap/sdk 0.0.21 → 0.0.22

package/dist/index.d.ts

@@ -1,6 +1,6 @@
 export type { SilentSwapClientConfig, SilentSwapClient, } from './client.js';
 export type * from './types/api.js';
-export type { Caip19 } from './types/core.js';
+export type { Caip19, SignInMessage } from './types/core.js';
 export type { EvmSigner } from './types/sdk.js';
 export * from './order.js';
 export * from './caip19.js';
@@ -10,3 +10,11 @@ export * from './gateway-abi.js';
 export { createHdFacilitatorGroupFromEntropy, exportSecretMnemonicFromEntropy, type HdFacilitatorGroup, } from './hd-facilitator-group.js';
 export { createSignInMessage, createEip712DocForOrder, createEip712DocForWalletGeneration, } from './sdk.js';
 export { createViemSigner, parseTransactionRequestForViem, } from './signer-adapters/viem.js';
+export * from './bridge.js';
+export * from './quote-utils.js';
+export * from './transaction-utils.js';
+export * from './wallet.js';
+export * from './storage.js';
+export * from './chain.js';
+export * from './constants.js';
+export * from './assets.js';

package/dist/index.js

@@ -6,3 +6,11 @@ export * from './gateway-abi.js';
 export { createHdFacilitatorGroupFromEntropy, exportSecretMnemonicFromEntropy, } from './hd-facilitator-group.js';
 export { createSignInMessage, createEip712DocForOrder, createEip712DocForWalletGeneration, } from './sdk.js';
 export { createViemSigner, parseTransactionRequestForViem, } from './signer-adapters/viem.js';
+export * from './bridge.js';
+export * from './quote-utils.js';
+export * from './transaction-utils.js';
+export * from './wallet.js';
+export * from './storage.js';
+export * from './chain.js';
+export * from './constants.js';
+export * from './assets.js';

package/dist/quote-utils.d.ts

@@ -0,0 +1,75 @@
+import type { BridgeProvider, RelayQuoteResponse, DeBridgeOrderResponse } from './bridge.js';
+/**
+ * Estimate sample for retention rate interpolation
+ */
+export interface EstimateSample {
+    /** USD baseline value for this sample */
+    baseline: number;
+    /** Retention rate (0-1) - how much value is retained after fees */
+    retention: number;
+    /** Bridge source that provided this sample */
+    source: BridgeProvider | 'none';
+}
+/**
+ * Estimate for a given direction (ingress or egress)
+ */
+export interface Estimate {
+    /** Gas fee in USD for this direction */
+    gasFee: number;
+    /** Array of samples for retention rate interpolation */
+    samples: EstimateSample[];
+}
+/**
+ * Quote metrics calculated from provider responses
+ */
+export interface QuoteMetrics {
+    retention: number;
+    feeUsd: number;
+    slippage: number;
+    time: number;
+    txCount: number;
+}
+/**
+ * Quote result with all necessary information
+ */
+export interface BridgeQuoteResult {
+    /** Selected bridge provider */
+    provider: BridgeProvider;
+    /** Output amount in destination token units (as string) */
+    outputAmount: string;
+    /** Input amount required in source token units (as string) */
+    inputAmount: string;
+    /** Total fee in USD */
+    feeUsd: number;
+    /** Price slippage/impact percentage */
+    slippage: number;
+    /** Estimated time in seconds */
+    estimatedTime: number;
+    /** Retention rate (how much value is retained after fees, 0-1) */
+    retentionRate: number;
+    /** Number of transactions required */
+    txCount: number;
+    /** Raw response from the provider */
+    rawResponse: RelayQuoteResponse | DeBridgeOrderResponse;
+}
+/**
+ * Calculate metrics from a Relay.link quote response
+ */
+export declare function calculateRelayMetrics(relayQuote: RelayQuoteResponse): QuoteMetrics;
+/**
+ * Calculate metrics from a deBridge quote response
+ */
+export declare function calculateDebridgeMetrics(debridgeQuote: DeBridgeOrderResponse): QuoteMetrics;
+/**
+ * Select the best quote from multiple providers based on retention rate
+ */
+export declare function selectBestQuote(relayQuote: RelayQuoteResponse | null, debridgeQuote: DeBridgeOrderResponse | null, srcAmount: string): BridgeQuoteResult;
+/**
+ * Interpolate retention rate from samples
+ */
+export declare function interpolateSamples(samples: EstimateSample[], usdValue: number, marginHi?: number): number;
+/**
+ * Get quote for cross-chain swap from multiple providers
+ * This is the core logic shared between React and Vue
+ */
+export declare function getBridgeQuote(srcChainId: number, srcToken: string, srcAmount: string, dstChainId: number, dstToken: string, userAddress: `0x${string}`, signal?: AbortSignal): Promise<BridgeQuoteResult>;

package/dist/quote-utils.js

@@ -0,0 +1,185 @@
+import BigNumber from 'bignumber.js';
+import { fetchRelayQuote, fetchDebridgeOrder, } from './bridge.js';
+const ZERO_ADDRESS = '0x0000000000000000000000000000000000000000';
+/**
+ * Calculate metrics from a Relay.link quote response
+ */
+export function calculateRelayMetrics(relayQuote) {
+    const usdIn = relayQuote.details.currencyIn.amountUsd;
+    const usdOut = relayQuote.details.currencyOut.amountUsd;
+    return {
+        retention: BigNumber(usdOut).div(usdIn).toNumber(),
+        feeUsd: Number(relayQuote.fees.relayerGas?.amountUsd || relayQuote.fees.gas?.amountUsd || '0'),
+        slippage: Number(relayQuote.details.totalImpact?.percent || '0') * 100,
+        time: relayQuote.details.timeEstimate || 300,
+        txCount: relayQuote.steps?.length || 1,
+    };
+}
+/**
+ * Calculate metrics from a deBridge quote response
+ */
+export function calculateDebridgeMetrics(debridgeQuote) {
+    const usdIn = debridgeQuote.estimation.srcChainTokenIn.approximateUsdValue;
+    const usdOut = debridgeQuote.estimation.dstChainTokenOut.approximateUsdValue;
+    return {
+        retention: BigNumber(usdOut).div(usdIn).toNumber(),
+        feeUsd: debridgeQuote.estimation.costDetails
+            ?.reduce((sum, detail) => sum + Number(detail.payload?.feeApproximateUsdValue || 0), 0) || 0,
+        slippage: 100 * (1 - usdOut / usdIn),
+        time: debridgeQuote.order?.approximateFulfillmentDelay || 600,
+        txCount: 2, // DeBridge typically requires 2 txs
+    };
+}
+/**
+ * Select the best quote from multiple providers based on retention rate
+ */
+export function selectBestQuote(relayQuote, debridgeQuote, srcAmount) {
+    // Calculate metrics for each provider
+    const relayMetrics = relayQuote ? calculateRelayMetrics(relayQuote) : null;
+    const debridgeMetrics = debridgeQuote ? calculateDebridgeMetrics(debridgeQuote) : null;
+    // Both providers failed
+    if (!relayQuote && !debridgeQuote) {
+        throw new Error('All quote providers failed');
+    }
+    // Determine best provider based on retention rate
+    let bestProvider;
+    let bestQuote;
+    let bestMetrics;
+    if (!relayQuote || (debridgeMetrics && debridgeMetrics.retention > (relayMetrics?.retention || 0))) {
+        bestProvider = 'debridge';
+        bestQuote = debridgeQuote;
+        bestMetrics = debridgeMetrics;
+    }
+    else {
+        bestProvider = 'relay';
+        bestQuote = relayQuote;
+        bestMetrics = relayMetrics;
+    }
+    // Extract output amount
+    const outputAmount = bestProvider === 'relay'
+        ? bestQuote.details.currencyOut.amount
+        : bestQuote.estimation.dstChainTokenOut.amount;
+    return {
+        provider: bestProvider,
+        outputAmount: outputAmount || '0',
+        inputAmount: srcAmount,
+        feeUsd: bestMetrics.feeUsd,
+        slippage: bestMetrics.slippage,
+        estimatedTime: bestMetrics.time,
+        retentionRate: bestMetrics.retention,
+        txCount: bestMetrics.txCount,
+        rawResponse: bestQuote,
+    };
+}
+/**
+ * Interpolate retention rate from samples
+ */
+export function interpolateSamples(samples, usdValue, marginHi = Infinity) {
+    if (samples.length === 0) {
+        throw new Error('No samples provided');
+    }
+    let lo = samples[0];
+    let hi = samples[samples.length - 1];
+    // Less than or equal to lo
+    if (usdValue <= lo.baseline) {
+        return lo.retention;
+    }
+    // Greater than or equal to hi
+    if (usdValue >= hi.baseline) {
+        // Exclusive hi with margin check
+        if (usdValue > hi.baseline + marginHi) {
+            throw new Error(`Value ${usdValue} exceeds maximum ${hi.baseline} by more than margin ${marginHi}`);
+        }
+        return hi.retention;
+    }
+    // In range - find bracketing samples
+    for (let i = 0; i < samples.length; i++) {
+        const sample = samples[i];
+        // Exact match
+        if (sample.baseline === usdValue) {
+            return sample.retention;
+        }
+        // Target is greater than sample
+        if (usdValue > sample.baseline) {
+            lo = sample;
+        }
+        else {
+            // Target is lower than sample
+            hi = sample;
+            break;
+        }
+    }
+    // Linear interpolation
+    const deltaY = hi.retention - lo.retention;
+    const deltaX = hi.baseline - lo.baseline;
+    return ((usdValue - lo.baseline) / deltaX) * deltaY + lo.retention;
+}
+/**
+ * Get quote for cross-chain swap from multiple providers
+ * This is the core logic shared between React and Vue
+ */
+export async function getBridgeQuote(srcChainId, srcToken, srcAmount, dstChainId, dstToken, userAddress, signal) {
+    // Normalize addresses
+    const srcTokenNorm = srcToken === '0x0' || srcToken === '0x0000000000000000000000000000000000000000'
+        ? ZERO_ADDRESS
+        : srcToken;
+    const dstTokenNorm = dstToken === '0x0' || dstToken === '0x0000000000000000000000000000000000000000'
+        ? ZERO_ADDRESS
+        : dstToken;
+    // Fetch quotes from both providers in parallel
+    const [relayResult, debridgeResult] = await Promise.allSettled([
+        // Relay.link quote
+        (async () => {
+            try {
+                const quote = await fetchRelayQuote({
+                    user: userAddress,
+                    referrer: 'silentswap',
+                    originChainId: srcChainId,
+                    destinationChainId: dstChainId,
+                    originCurrency: srcTokenNorm,
+                    destinationCurrency: dstTokenNorm,
+                    amount: srcAmount,
+                    tradeType: 'EXACT_INPUT',
+                }, signal);
+                return quote;
+            }
+            catch (err) {
+                if (err instanceof Error && err.name !== 'AbortError') {
+                    console.warn('Relay quote failed:', err);
+                }
+                return null;
+            }
+        })(),
+        // deBridge quote
+        (async () => {
+            try {
+                const quote = await fetchDebridgeOrder({
+                    srcChainId,
+                    srcChainTokenIn: srcTokenNorm,
+                    srcChainTokenInAmount: srcAmount,
+                    dstChainId,
+                    dstChainTokenOut: dstTokenNorm,
+                    dstChainTokenOutAmount: 'auto',
+                    prependOperatingExpenses: true,
+                }, signal);
+                return quote;
+            }
+            catch (err) {
+                if (err instanceof Error && err.name !== 'AbortError') {
+                    console.warn('DeBridge quote failed:', err);
+                }
+                return null;
+            }
+        })(),
+    ]);
+    const relayQuote = relayResult.status === 'fulfilled' ? relayResult.value : null;
+    const debridgeQuote = debridgeResult.status === 'fulfilled' ? debridgeResult.value : null;
+    // Select best quote
+    const result = selectBestQuote(relayQuote, debridgeQuote, srcAmount);
+    console.info(`Selected ${result.provider} for quote:`, {
+        retention: result.retentionRate,
+        feeUsd: result.feeUsd,
+        time: result.estimatedTime,
+    });
+    return result;
+}

package/dist/storage.d.ts

@@ -0,0 +1,74 @@
+import type { AuthResponse } from './types/api.js';
+/**
+ * Storage key prefix for authentication data
+ */
+export declare const STORAGE_KEY_AUTH_PREFIX = "silentswap:auth:";
+/**
+ * Storage key prefix for wallet data
+ */
+export declare const STORAGE_KEY_WALLET_PREFIX = "silentswap:signer:";
+/**
+ * Get storage key for authentication data
+ *
+ * @param address - The user's EVM address
+ * @returns The storage key for the auth data
+ */
+export declare function getAuthStorageKey(address: `0x${string}`): string;
+/**
+ * Get storage key for wallet data
+ *
+ * @param address - The user's EVM address
+ * @returns The storage key for the wallet data
+ */
+export declare function getWalletStorageKey(address: `0x${string}`): string;
+/**
+ * Load cached authentication data
+ *
+ * @param address - The user's EVM address
+ * @returns The cached auth response or null if not found/expired
+ */
+export declare function loadCachedAuth(address: `0x${string}`): AuthResponse | null;
+/**
+ * Save authentication data to cache
+ *
+ * @param address - The user's EVM address
+ * @param authData - The authentication response to cache
+ */
+export declare function saveAuth(address: `0x${string}`, authData: AuthResponse): void;
+/**
+ * Clear cached authentication data
+ *
+ * @param address - The user's EVM address
+ */
+export declare function clearAuth(address: `0x${string}`): void;
+/**
+ * Save wallet data to sessionStorage
+ *
+ * @param address - The user's EVM address
+ * @param walletData - The wallet data to cache
+ * @param expirationMs - Expiration time in milliseconds from now
+ */
+export declare function saveWalletData(address: `0x${string}`, walletData: {
+    entropy: string;
+    accounts: {
+        nonce: number;
+    }[];
+}, expirationMs?: number): void;
+/**
+ * Load cached wallet data from sessionStorage
+ *
+ * @param address - The user's EVM address
+ * @returns The cached wallet data or null if not found/expired
+ */
+export declare function loadWalletData(address: `0x${string}`): {
+    entropy: string;
+    accounts: {
+        nonce: number;
+    }[];
+} | null;
+/**
+ * Clear cached wallet data
+ *
+ * @param address - The user's EVM address
+ */
+export declare function clearWalletData(address: `0x${string}`): void;

package/dist/storage.js

@@ -0,0 +1,161 @@
+import { getAddress } from 'viem';
+/**
+ * Storage key prefix for authentication data
+ */
+export const STORAGE_KEY_AUTH_PREFIX = 'silentswap:auth:';
+/**
+ * Storage key prefix for wallet data
+ */
+export const STORAGE_KEY_WALLET_PREFIX = 'silentswap:signer:';
+/**
+ * Get storage key for authentication data
+ *
+ * @param address - The user's EVM address
+ * @returns The storage key for the auth data
+ */
+export function getAuthStorageKey(address) {
+    return `${STORAGE_KEY_AUTH_PREFIX}${getAddress(address)}`;
+}
+/**
+ * Get storage key for wallet data
+ *
+ * @param address - The user's EVM address
+ * @returns The storage key for the wallet data
+ */
+export function getWalletStorageKey(address) {
+    return `${STORAGE_KEY_WALLET_PREFIX}${getAddress(address)}`;
+}
+/**
+ * Load cached authentication data
+ *
+ * @param address - The user's EVM address
+ * @returns The cached auth response or null if not found/expired
+ */
+export function loadCachedAuth(address) {
+    const normalizedAddress = getAddress(address);
+    try {
+        const storageKey = getAuthStorageKey(normalizedAddress);
+        const cachedData = typeof localStorage !== 'undefined' ? localStorage.getItem(storageKey) : null;
+        if (!cachedData)
+            return null;
+        const cachedAuth = JSON.parse(cachedData);
+        // Check if auth is still valid
+        if (cachedAuth.authExpires && cachedAuth.authExpires > Date.now()) {
+            return cachedAuth;
+        }
+        else {
+            // Remove expired auth
+            if (typeof localStorage !== 'undefined') {
+                localStorage.removeItem(storageKey);
+            }
+            return null;
+        }
+    }
+    catch (err) {
+        console.warn('Failed to load cached auth:', err);
+        return null;
+    }
+}
+/**
+ * Save authentication data to cache
+ *
+ * @param address - The user's EVM address
+ * @param authData - The authentication response to cache
+ */
+export function saveAuth(address, authData) {
+    const normalizedAddress = getAddress(address);
+    try {
+        const storageKey = getAuthStorageKey(normalizedAddress);
+        if (typeof localStorage !== 'undefined') {
+            localStorage.setItem(storageKey, JSON.stringify(authData));
+        }
+    }
+    catch (err) {
+        console.warn('Failed to save auth:', err);
+    }
+}
+/**
+ * Clear cached authentication data
+ *
+ * @param address - The user's EVM address
+ */
+export function clearAuth(address) {
+    const normalizedAddress = getAddress(address);
+    const storageKey = getAuthStorageKey(normalizedAddress);
+    if (typeof localStorage !== 'undefined') {
+        localStorage.removeItem(storageKey);
+    }
+}
+/**
+ * Save wallet data to sessionStorage
+ *
+ * @param address - The user's EVM address
+ * @param walletData - The wallet data to cache
+ * @param expirationMs - Expiration time in milliseconds from now
+ */
+export function saveWalletData(address, walletData, expirationMs = 24 * 60 * 60 * 1000 // 24 hours
+) {
+    const normalizedAddress = getAddress(address);
+    try {
+        const storageKey = getWalletStorageKey(normalizedAddress);
+        const data = {
+            ...walletData,
+            expiration: Date.now() + expirationMs,
+        };
+        if (typeof sessionStorage !== 'undefined') {
+            sessionStorage.setItem(storageKey, JSON.stringify(data));
+        }
+    }
+    catch (err) {
+        console.warn('Failed to save wallet data:', err);
+    }
+}
+/**
+ * Load cached wallet data from sessionStorage
+ *
+ * @param address - The user's EVM address
+ * @returns The cached wallet data or null if not found/expired
+ */
+export function loadWalletData(address) {
+    const normalizedAddress = getAddress(address);
+    try {
+        const storageKey = getWalletStorageKey(normalizedAddress);
+        const sessionData = typeof sessionStorage !== 'undefined'
+            ? sessionStorage.getItem(storageKey)
+            : null;
+        if (!sessionData)
+            return null;
+        const cached = JSON.parse(sessionData);
+        // Check expiration
+        if (cached.expiration <= Date.now()) {
+            if (typeof sessionStorage !== 'undefined') {
+                sessionStorage.removeItem(storageKey);
+            }
+            return null;
+        }
+        return {
+            entropy: cached.entropy,
+            accounts: cached.accounts,
+        };
+    }
+    catch (err) {
+        console.warn('Failed to load wallet data:', err);
+        if (typeof sessionStorage !== 'undefined') {
+            const storageKey = getWalletStorageKey(normalizedAddress);
+            sessionStorage.removeItem(storageKey);
+        }
+        return null;
+    }
+}
+/**
+ * Clear cached wallet data
+ *
+ * @param address - The user's EVM address
+ */
+export function clearWalletData(address) {
+    const normalizedAddress = getAddress(address);
+    const storageKey = getWalletStorageKey(normalizedAddress);
+    if (typeof sessionStorage !== 'undefined') {
+        sessionStorage.removeItem(storageKey);
+    }
+}

package/dist/transaction-utils.d.ts

@@ -0,0 +1,19 @@
+import type { Hex, WalletClient } from 'viem';
+import type { Connector } from 'wagmi';
+import type { BridgeProvider, BridgeQuote, BridgeTransaction, BridgeStatus } from './bridge.js';
+/**
+ * Create transaction execution wrapper for framework-agnostic bridge execution
+ */
+export declare function createTransactionExecutor(walletClient: WalletClient, connector: Connector): (tx: BridgeTransaction) => Promise<Hex>;
+/**
+ * Create chain switching wrapper
+ */
+export declare function createChainSwitcher(walletClient: WalletClient, connector: Connector): (chainId: number) => Promise<void>;
+/**
+ * Execute a bridge transaction (framework-agnostic)
+ */
+export declare function executeBridgeTransaction(quote: BridgeQuote, walletClient: WalletClient, connector: Connector, setStep: (step: string) => void): Promise<BridgeStatus>;
+/**
+ * Get bridge status (framework-agnostic)
+ */
+export declare function getBridgeStatus(requestId: string, provider: BridgeProvider): Promise<BridgeStatus>;

package/dist/transaction-utils.js

@@ -0,0 +1,85 @@
+import { executeRelayBridge, executeDebridgeBridge, getRelayStatus, getDebridgeStatus, } from './bridge.js';
+/**
+ * Create transaction execution wrapper for framework-agnostic bridge execution
+ */
+export function createTransactionExecutor(walletClient, connector) {
+    return async (tx) => {
+        // Switch to the correct chain if needed
+        let currentChainId;
+        try {
+            currentChainId = await walletClient.getChainId();
+        }
+        catch {
+            currentChainId = -1;
+        }
+        if (currentChainId !== tx.chainId) {
+            try {
+                await connector.switchChain?.({ chainId: tx.chainId });
+            }
+            catch (switchError) {
+                throw new Error(`Failed to switch to chain ${tx.chainId}`);
+            }
+        }
+        // Send transaction
+        const hash = await walletClient.sendTransaction({
+            account: walletClient.account,
+            chain: null,
+            to: tx.to,
+            value: BigInt(tx.value),
+            data: tx.data,
+            gas: tx.gasLimit ? BigInt(tx.gasLimit) : undefined,
+        });
+        return hash;
+    };
+}
+/**
+ * Create chain switching wrapper
+ */
+export function createChainSwitcher(walletClient, connector) {
+    return async (chainId) => {
+        // Check current chain
+        let currentChainId;
+        try {
+            currentChainId = await walletClient?.getChainId() || -1;
+        }
+        catch {
+            currentChainId = -1;
+        }
+        if (currentChainId !== chainId) {
+            try {
+                await connector.switchChain?.({ chainId });
+            }
+            catch (switchError) {
+                throw new Error(`Failed to switch to chain ${chainId}`);
+            }
+        }
+    };
+}
+/**
+ * Execute a bridge transaction (framework-agnostic)
+ */
+export async function executeBridgeTransaction(quote, walletClient, connector, setStep) {
+    const executeTransaction = createTransactionExecutor(walletClient, connector);
+    const switchChain = createChainSwitcher(walletClient, connector);
+    switch (quote.provider) {
+        case 'relay':
+            return await executeRelayBridge(quote, executeTransaction, switchChain, setStep);
+        case 'debridge':
+            return await executeDebridgeBridge(quote, executeTransaction, switchChain, setStep);
+        default:
+            throw new Error(`Unsupported bridge provider: ${quote.provider}`);
+    }
+}
+/**
+ * Get bridge status (framework-agnostic)
+ */
+export async function getBridgeStatus(requestId, provider) {
+    switch (provider) {
+        case 'relay':
+            return await getRelayStatus(requestId);
+        case 'debridge':
+            return await getDebridgeStatus(requestId);
+        default:
+            throw new Error(`Unsupported bridge provider: ${provider}`);
+    }
+}

package/dist/wallet.d.ts

@@ -0,0 +1,18 @@
+import { type Hex } from 'viem';
+/**
+ * Query the number of deposits made by a user to the Gateway contract
+ *
+ * @param userAddress - The user's EVM address
+ * @returns The number of deposits made by the user
+ */
+export declare function queryDepositCount(userAddress: `0x${string}`): Promise<bigint>;
+/**
+ * Generate phony deposit proxy calldata for testing/estimation purposes
+ * This creates a valid calldata structure without actual signature data
+ *
+ * @param signerAddress - The signer's EVM address (or zero address for anonymous)
+ * @param approvalExpiration - Timestamp when approval expires (default: 12 hours from now)
+ * @param duration - Duration of the deposit in seconds (default: 7 days)
+ * @returns Encoded calldata for depositProxy2 function
+ */
+export declare function createPhonyDepositCalldata(signerAddress?: `0x${string}`, approvalExpiration?: bigint, duration?: bigint): Hex;