@silentswap/vue 0.0.41

package/README.md

@@ -0,0 +1,134 @@
+# @silentswap/vue
+
+Vue 3 composables for integrating with SilentSwap SDK.
+
+## Installation
+
+```bash
+npm install @silentswap/vue
+# or
+bun add @silentswap/vue
+# or
+yarn add @silentswap/vue
+```
+
+## Usage
+
+### getSilentSwapClient
+
+Create and manage a SilentSwap client instance:
+
+```typescript
+import { getSilentSwapClient } from '@silentswap/vue';
+
+const { client } = getSilentSwapClient({
+  config: {
+    baseUrl: 'https://api.silentswap.com',
+  },
+});
+```
+
+### getSilentSwapAuth
+
+Handle authentication utilities:
+
+```typescript
+import { getSilentSwapAuth } from '@silentswap/vue';
+
+const {
+  createSignInMessage,
+  createEip712DocForOrder,
+  createEip712DocForWalletGeneration,
+} = getSilentSwapAuth();
+
+// Create a sign-in message
+const message = createSignInMessage('0x...', 'nonce123', 'app.silentswap.com');
+
+// Create EIP-712 document for order
+const orderDoc = createEip712DocForOrder(quoteResponse);
+
+// Create EIP-712 document for wallet generation
+const walletDoc = createEip712DocForWalletGeneration('scope', 'token');
+```
+
+### getSilentSwapOrders
+
+Manage orders and related operations with reactive state:
+
+```typescript
+import { getSilentSwapOrders } from '@silentswap/vue';
+
+const { client } = getSilentSwapClient({ config: yourConfig });
+
+const {
+  isLoading,
+  error,
+  getNonce,
+  authenticate,
+  getQuote,
+  createOrder,
+} = getSilentSwapOrders({ client });
+
+// Get nonce for authentication
+const nonce = await getNonce('0x...');
+
+// Authenticate user
+const authResult = await authenticate({
+  address: '0x...',
+  signature: '0x...',
+  message: '...',
+});
+
+// Get a quote
+const quote = await getQuote({
+  sellToken: '0x...',
+  buyToken: '0x...',
+  sellAmount: '1000000000000000000',
+});
+
+// Create an order
+const order = await createOrder({
+  quoteId: quote.quoteId,
+  signature: '0x...',
+});
+```
+
+## API Reference
+
+### getSilentSwapClient
+
+#### Parameters
+
+- `config: SilentSwapClientConfig` - Configuration for the SilentSwap client
+
+#### Returns
+
+- `client: SilentSwapClient` - The SilentSwap client instance
+
+### getSilentSwapAuth
+
+#### Returns
+
+- `createSignInMessage(address, nonce, domain?)` - Create a sign-in message
+- `createEip712DocForOrder(quoteResponse)` - Create EIP-712 typed data for order
+- `createEip712DocForWalletGeneration(scope, token)` - Create EIP-712 typed data for wallet generation
+
+### getSilentSwapOrders
+
+#### Parameters
+
+- `client: SilentSwapClient` - The SilentSwap client instance
+
+#### Returns
+
+- `isLoading: boolean` - Reactive loading state
+- `error: Error | null` - Reactive error state
+- `getNonce(address)` - Get nonce for authentication
+- `authenticate(auth)` - Authenticate user
+- `getQuote(quote)` - Get a quote
+- `createOrder(order)` - Create an order
+
+## Requirements
+
+- Vue 3.0+
+- TypeScript (recommended)

package/dist/composables/getQuote.d.ts

@@ -0,0 +1,44 @@
+import { ref } from 'vue';
+import type { Hex } from 'viem';
+import type { BridgeProvider, RelayQuoteResponse, DeBridgeOrderResponse, SolveUsdcResult, EstimateSample, Estimate, BridgeQuoteResult } from '@silentswap/sdk';
+export interface GetQuoteOptions {
+    /** User's EVM address */
+    address?: `0x${string}`;
+    /** Depositor address for bridge operations (required for solveUsdcAmount) */
+    depositorAddress: Hex;
+    /** Maximum price impact percentage allowed (default from SDK constants) */
+    maxImpactPercent?: number;
+    /** Timeout for quote requests in milliseconds (default: 30000) */
+    quoteTimeout?: number;
+}
+export type { RelayQuoteResponse, DeBridgeOrderResponse, SolveUsdcResult, EstimateSample, Estimate, BridgeQuoteResult, } from '@silentswap/sdk';
+export type SolveResult = SolveUsdcResult;
+/**
+ * Estimate result with quote details
+ */
+export interface EstimateResult {
+    /** Estimate data with samples */
+    estimate: Estimate;
+    /** Amount of gas needed on source chain */
+    gasAmount: bigint;
+    /** Raw response from provider */
+    response: RelayQuoteResponse | DeBridgeOrderResponse;
+    /** Bridge provider used */
+    provider: BridgeProvider;
+    /** Calculated input amount for reverse calculation (output-to-input) */
+    calculatedInputAmount?: number;
+}
+export interface GetQuoteReturn {
+    isLoading: Readonly<ReturnType<typeof ref<boolean>>>;
+    error: Readonly<ReturnType<typeof ref<Error | null>>>;
+    ingressEstimates: Readonly<ReturnType<typeof ref<Record<string, Estimate>>>>;
+    egressEstimates: Readonly<ReturnType<typeof ref<Record<string, Estimate>>>>;
+    getQuote: (srcChainId: number, srcToken: string, srcAmount: string, dstChainId: number, dstToken: string) => Promise<BridgeQuoteResult>;
+    solveUsdcAmount: (srcChainId: number, srcToken: string, srcAmount: string, depositCalldata?: string) => Promise<SolveResult>;
+    estimateLive: (direction: 'ingress' | 'egress', assetCaip19: string, chainId: number | string, tokenAddress: string, amount: number, usdPrice: number, externalSignal?: AbortSignal, recipientAddress?: string, isReverseCalculation?: boolean, targetAmount?: number) => Promise<EstimateResult>;
+    interpolateSamples: (samples: EstimateSample[], usdValue: number, marginHi?: number) => number;
+}
+/**
+ * Vue composable for getting optimized bridge quotes from multiple providers
+ */
+export declare function getQuote({ address, depositorAddress, maxImpactPercent, quoteTimeout, }: GetQuoteOptions): GetQuoteReturn;

package/dist/composables/getQuote.js

@@ -0,0 +1,405 @@
+import { ref, computed, onUnmounted } from 'vue';
+import BigNumber from 'bignumber.js';
+import { NI_CHAIN_ID_AVALANCHE, S0X_ADDR_USDC_AVALANCHE, S_CAIP19_USDC_AVALANCHE, X_MAX_IMPACT_PERCENT, solveOptimalUsdcAmount, getBridgeQuote as sdkGetBridgeQuote, interpolateSamples as sdkInterpolateSamples, fetchRelayQuote, fetchDebridgeOrder, normalizeAddress, getAssetByCaip19, N_DEBRIDGE_CHAIN_ID_SOLANA, N_RELAY_CHAIN_ID_SOLANA, SB58_ADDR_SOL_PROGRAM_SYSTEM, S0X_ADDR_EVM_RELAY_LINK_DEAD, SB58_ADDR_SOL_RELAY_LINK_RECIPIENT, isSolanaAsset, } from '@silentswap/sdk';
+const ZERO_ADDRESS = '0x0000000000000000000000000000000000000000';
+const EVM_PHONY_ADDRESS_FALLBACK = '0x1111111111111111111111111111111111111111';
+/**
+ * Vue composable for getting optimized bridge quotes from multiple providers
+ */
+export function getQuote({ address, depositorAddress, maxImpactPercent = X_MAX_IMPACT_PERCENT, quoteTimeout = 30000, }) {
+    const isLoading = ref(false);
+    const error = ref(null);
+    // Estimates cache
+    const ingressEstimates = ref({});
+    const egressEstimates = ref({});
+    // Normalize address - handle both EVM (hex) and Solana (base58) addresses
+    const normalizedAddress = computed(() => address ? normalizeAddress(address) : null);
+    // Abort controller for cancelling requests
+    const abortControllerRef = ref(null);
+    // Cleanup on unmount
+    onUnmounted(() => {
+        if (abortControllerRef.value) {
+            abortControllerRef.value.abort();
+            abortControllerRef.value = null;
+        }
+    });
+    /**
+     * Cancel any ongoing requests and create a new abort controller
+     */
+    const createNewAbortController = () => {
+        // Cancel previous request if any
+        if (abortControllerRef.value) {
+            abortControllerRef.value.abort();
+        }
+        // Create new abort controller
+        const controller = new AbortController();
+        abortControllerRef.value = controller;
+        return controller;
+    };
+    /**
+     * Get quote for cross-chain swap
+     */
+    const getQuoteFn = async (srcChainId, srcToken, srcAmount, dstChainId, dstToken) => {
+        if (!normalizedAddress.value) {
+            throw new Error('Address required for bridge quote operations');
+        }
+        isLoading.value = true;
+        error.value = null;
+        try {
+            // Normalize addresses
+            const srcTokenNorm = srcToken === '0x0' || srcToken === '0x0000000000000000000000000000000000000000'
+                ? ZERO_ADDRESS
+                : srcToken;
+            const dstTokenNorm = dstToken === '0x0' || dstToken === '0x0000000000000000000000000000000000000000'
+                ? ZERO_ADDRESS
+                : dstToken;
+            // Create abort controller for timeout
+            const controller = new AbortController();
+            const timeoutId = setTimeout(() => controller.abort(), quoteTimeout);
+            try {
+                // Use shared quote fetching function
+                const result = await sdkGetBridgeQuote(srcChainId, srcTokenNorm, srcAmount, dstChainId, dstTokenNorm, normalizedAddress.value, controller.signal);
+                clearTimeout(timeoutId);
+                return result;
+            }
+            catch (err) {
+                clearTimeout(timeoutId);
+                throw err;
+            }
+        }
+        catch (err) {
+            const errorInstance = err instanceof Error ? err : new Error('Failed to get quote');
+            error.value = errorInstance;
+            throw errorInstance;
+        }
+        finally {
+            isLoading.value = false;
+        }
+    };
+    /**
+     * Solve for optimal USDC amount
+     */
+    const solveUsdcAmountFn = async (srcChainId, srcToken, srcAmount, depositCalldata) => {
+        isLoading.value = true;
+        error.value = null;
+        try {
+            if (!normalizedAddress.value) {
+                throw new Error('Address required for solving USDC amount');
+            }
+            const result = await solveOptimalUsdcAmount(srcChainId, srcToken, srcAmount, normalizedAddress.value, depositCalldata, maxImpactPercent, depositorAddress);
+            return result;
+        }
+        catch (err) {
+            const errorInstance = err instanceof Error ? err : new Error('Failed to solve USDC amount');
+            error.value = errorInstance;
+            throw errorInstance;
+        }
+        finally {
+            isLoading.value = false;
+        }
+    };
+    /**
+     * Get live estimate for a given asset and direction
+     */
+    const estimateLiveFn = async (direction, assetCaip19, chainId, tokenAddress, amount, usdPrice, externalSignal, recipientAddress, isReverseCalculation, targetAmount) => {
+        // Determine if this is a Solana chain by checking the asset CAIP-19
+        const isSolanaChain = isSolanaAsset(assetCaip19);
+        let numericChainId;
+        if (isSolanaChain) {
+            numericChainId = 0; // Placeholder, will be set per provider
+        }
+        else {
+            if (typeof chainId === 'string') {
+                const parsed = parseInt(chainId, 10);
+                if (isNaN(parsed)) {
+                    throw new Error(`Invalid chain ID: ${chainId}`);
+                }
+                numericChainId = parsed;
+            }
+            else {
+                numericChainId = chainId;
+            }
+        }
+        if (!normalizedAddress.value) {
+            throw new Error('Address required');
+        }
+        // Use external signal if provided, otherwise create new abort controller
+        let signal;
+        if (externalSignal) {
+            signal = externalSignal;
+        }
+        else {
+            const controller = createNewAbortController();
+            signal = controller.signal;
+        }
+        try {
+            // Special case for USDC on Avalanche
+            const checkChainId = isSolanaChain ? 0 : numericChainId;
+            if (checkChainId === NI_CHAIN_ID_AVALANCHE &&
+                tokenAddress.toLowerCase() === S0X_ADDR_USDC_AVALANCHE.toLowerCase()) {
+                const estimate = {
+                    gasFee: 0,
+                    samples: [
+                        {
+                            baseline: Infinity,
+                            retention: 1,
+                            source: 'none',
+                        },
+                    ],
+                };
+                if (direction === 'ingress') {
+                    ingressEstimates.value[assetCaip19] = estimate;
+                }
+                else {
+                    egressEstimates.value[assetCaip19] = estimate;
+                }
+                return {
+                    estimate,
+                    gasAmount: BigInt(BigNumber(300_000).times(2).shiftedBy(9).toFixed(0)),
+                    response: {},
+                    provider: 'relay',
+                };
+            }
+            // Get asset info to determine correct decimals
+            const assetInfo = getAssetByCaip19(assetCaip19);
+            if (!assetInfo) {
+                throw new Error(`Asset not found: ${assetCaip19}`);
+            }
+            // Calculate amount in token units
+            const decimalsToUse = (direction === 'egress' && !isReverseCalculation)
+                ? 6 // USDC has 6 decimals (for normal egress)
+                : assetInfo.decimals; // Use asset decimals (for ingress or reverse egress)
+            const tokenAmount = BigNumber(amount).shiftedBy(decimalsToUse).toFixed(0);
+            // Determine user address based on direction and chain
+            let userAddress;
+            if (direction === 'ingress') {
+                if (isSolanaChain) {
+                    userAddress = normalizedAddress.value && !normalizedAddress.value.startsWith('0x')
+                        ? normalizedAddress.value
+                        : SB58_ADDR_SOL_PROGRAM_SYSTEM;
+                }
+                else {
+                    userAddress = normalizedAddress.value && normalizedAddress.value.startsWith('0x')
+                        ? normalizedAddress.value
+                        : EVM_PHONY_ADDRESS_FALLBACK;
+                }
+            }
+            else {
+                userAddress = normalizedAddress.value && normalizedAddress.value.startsWith('0x')
+                    ? normalizedAddress.value
+                    : EVM_PHONY_ADDRESS_FALLBACK;
+            }
+            // For Solana, use different chain IDs for different providers
+            const relayChainId = isSolanaChain ? N_RELAY_CHAIN_ID_SOLANA : numericChainId;
+            const debridgeChainId = isSolanaChain ? N_DEBRIDGE_CHAIN_ID_SOLANA : numericChainId;
+            // Fetch quotes from both providers
+            const [relayResult, debridgeResult] = await Promise.allSettled([
+                (async () => {
+                    try {
+                        const tradeType = isReverseCalculation ? 'EXACT_OUTPUT' : 'EXACT_INPUT';
+                        let quoteAmount = tokenAmount;
+                        if (isReverseCalculation && direction === 'ingress' && targetAmount) {
+                            const usdcAsset = getAssetByCaip19(S_CAIP19_USDC_AVALANCHE);
+                            if (usdcAsset) {
+                                quoteAmount = BigNumber(targetAmount).shiftedBy(usdcAsset.decimals).toFixed(0);
+                            }
+                            else {
+                                throw new Error('USDC asset not found');
+                            }
+                        }
+                        else if (isReverseCalculation && direction === 'egress' && targetAmount) {
+                            quoteAmount = tokenAmount;
+                        }
+                        const quote = await fetchRelayQuote({
+                            user: userAddress,
+                            referrer: 'silentswap',
+                            tradeType,
+                            ...(direction === 'ingress'
+                                ? {
+                                    originChainId: relayChainId,
+                                    destinationChainId: NI_CHAIN_ID_AVALANCHE,
+                                    originCurrency: tokenAddress === ZERO_ADDRESS ? ZERO_ADDRESS : tokenAddress,
+                                    destinationCurrency: S0X_ADDR_USDC_AVALANCHE,
+                                    ...(isReverseCalculation && tradeType === 'EXACT_OUTPUT'
+                                        ? { amount: quoteAmount }
+                                        : { amount: tokenAmount }),
+                                    ...(isSolanaChain
+                                        ? { recipient: EVM_PHONY_ADDRESS_FALLBACK }
+                                        : {}),
+                                }
+                                : {
+                                    originChainId: NI_CHAIN_ID_AVALANCHE,
+                                    originCurrency: S0X_ADDR_USDC_AVALANCHE,
+                                    destinationChainId: relayChainId,
+                                    destinationCurrency: tokenAddress === ZERO_ADDRESS ? ZERO_ADDRESS : tokenAddress,
+                                    ...(isReverseCalculation && tradeType === 'EXACT_OUTPUT'
+                                        ? { amount: quoteAmount }
+                                        : { amount: tokenAmount }),
+                                    ...(isSolanaChain
+                                        ? {
+                                            user: S0X_ADDR_EVM_RELAY_LINK_DEAD,
+                                            recipient: recipientAddress || SB58_ADDR_SOL_RELAY_LINK_RECIPIENT,
+                                        }
+                                        : {}),
+                                }),
+                        }, signal);
+                        return quote;
+                    }
+                    catch (err) {
+                        if (err instanceof Error && err.name !== 'AbortError') {
+                            console.warn('Relay quote failed:', err);
+                        }
+                        return null;
+                    }
+                })(),
+                (async () => {
+                    try {
+                        if (direction === 'egress') {
+                            return null;
+                        }
+                        const debridgeParams = {
+                            srcChainId: debridgeChainId,
+                            srcChainTokenIn: tokenAddress === ZERO_ADDRESS ? ZERO_ADDRESS : tokenAddress,
+                            dstChainId: NI_CHAIN_ID_AVALANCHE,
+                            dstChainTokenOut: S0X_ADDR_USDC_AVALANCHE,
+                        };
+                        if (isReverseCalculation && direction === 'ingress' && targetAmount) {
+                            const usdcAsset = getAssetByCaip19(S_CAIP19_USDC_AVALANCHE);
+                            if (usdcAsset) {
+                                debridgeParams.srcChainTokenInAmount = 'auto';
+                                debridgeParams.dstChainTokenOutAmount = BigNumber(targetAmount)
+                                    .shiftedBy(usdcAsset.decimals)
+                                    .toFixed(0);
+                            }
+                            else {
+                                throw new Error('USDC asset not found');
+                            }
+                        }
+                        else {
+                            debridgeParams.srcChainTokenInAmount = tokenAmount;
+                            debridgeParams.dstChainTokenOutAmount = 'auto';
+                        }
+                        const quote = await fetchDebridgeOrder(debridgeParams, 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;
+            if (!relayQuote && !debridgeQuote) {
+                throw new AggregateError([
+                    relayResult.status === 'rejected' ? relayResult.reason : null,
+                    debridgeResult.status === 'rejected' ? debridgeResult.reason : null,
+                ].filter(Boolean), 'All quote providers failed');
+            }
+            // Calculate retention rates
+            let retentionRelay = 0;
+            let retentionDebridge = 0;
+            let gasAmountRelay = 0n;
+            let gasAmountDebridge = 0n;
+            let gasFeeUsd = 0;
+            let calculatedInputAmount = undefined;
+            if (relayQuote) {
+                if (isReverseCalculation && direction === 'ingress') {
+                    calculatedInputAmount = Number(relayQuote.details.currencyIn.amount);
+                    if (!calculatedInputAmount) {
+                        const calculatedInputAmountUsd = Number(relayQuote.details.currencyIn.amountUsd || 0);
+                        if (calculatedInputAmountUsd > 0 && usdPrice > 0) {
+                            calculatedInputAmount = calculatedInputAmountUsd / usdPrice;
+                        }
+                    }
+                    retentionRelay = BigNumber(relayQuote.details.currencyOut.amountUsd)
+                        .div(relayQuote.details.currencyIn.amountUsd)
+                        .toNumber();
+                }
+                else {
+                    retentionRelay = BigNumber(relayQuote.details.currencyOut.amountUsd)
+                        .div(relayQuote.details.currencyIn.amountUsd)
+                        .toNumber();
+                }
+                gasFeeUsd = Number(relayQuote.fees.relayerGas.amountUsd || '0');
+                gasAmountRelay = BigInt((BigInt(relayQuote.fees.gas.amount || 0) * 15n) / 10n);
+            }
+            if (debridgeQuote) {
+                if (isReverseCalculation && direction === 'ingress') {
+                    calculatedInputAmount = Number(debridgeQuote.estimation.srcChainTokenIn.amount);
+                    if (!calculatedInputAmount) {
+                        const calculatedInputAmountUsd = Number(debridgeQuote.estimation.srcChainTokenIn.approximateUsdValue || 0);
+                        if (calculatedInputAmountUsd > 0 && usdPrice > 0) {
+                            calculatedInputAmount = calculatedInputAmountUsd / usdPrice;
+                        }
+                    }
+                    retentionDebridge = BigNumber(debridgeQuote.estimation.dstChainTokenOut.approximateUsdValue)
+                        .div(debridgeQuote.estimation.srcChainTokenIn.approximateUsdValue)
+                        .toNumber();
+                }
+                else {
+                    retentionDebridge = BigNumber(debridgeQuote.estimation.dstChainTokenOut.approximateUsdValue)
+                        .div(debridgeQuote.estimation.srcChainTokenIn.approximateUsdValue)
+                        .toNumber();
+                }
+                gasFeeUsd =
+                    debridgeQuote.estimation.costDetails?.reduce((sum, detail) => sum + Number(detail.payload?.feeApproximateUsdValue || 0), 0) || 0;
+                gasAmountDebridge = BigInt((BigInt(debridgeQuote.estimatedTransactionFee?.total || 0) * 15n) / 10n);
+            }
+            // Determine best source
+            const retention = Math.max(retentionRelay, retentionDebridge);
+            const source = retentionRelay >= retentionDebridge ? 'relay' : 'debridge';
+            const usdValue = BigNumber(usdPrice).times(amount).toNumber();
+            // Create sample
+            const sample = {
+                baseline: usdValue,
+                retention,
+                source,
+            };
+            // Update estimates cache
+            const estimatesCache = direction === 'ingress' ? ingressEstimates.value : egressEstimates.value;
+            const existingEstimate = estimatesCache[assetCaip19];
+            // Filter out samples within $5 of this price
+            const filteredSamples = (existingEstimate?.samples || []).filter((s) => !(s.baseline >= sample.baseline - 5 && s.baseline <= sample.baseline + 5));
+            // Add new sample and sort
+            const samples = [...filteredSamples, sample].sort((a, b) => a.baseline - b.baseline);
+            const estimate = {
+                gasFee: direction === 'ingress' ? 0 : gasFeeUsd,
+                samples,
+            };
+            estimatesCache[assetCaip19] = estimate;
+            return {
+                estimate,
+                gasAmount: source === 'relay' ? gasAmountRelay : gasAmountDebridge,
+                response: (source === 'relay' ? relayQuote : debridgeQuote),
+                provider: source,
+                calculatedInputAmount,
+            };
+        }
+        catch (err) {
+            if (err instanceof Error && err.name === 'AbortError') {
+                throw err;
+            }
+            const errorInstance = err instanceof Error ? err : new Error('Failed to get live estimate');
+            throw errorInstance;
+        }
+    };
+    /**
+     * Interpolate retention rate from samples
+     */
+    const interpolateSamplesFn = (samples, usdValue, marginHi = Infinity) => {
+        return sdkInterpolateSamples(samples, usdValue, marginHi);
+    };
+    return {
+        isLoading: computed(() => isLoading.value),
+        error: computed(() => error.value),
+        ingressEstimates: computed(() => ingressEstimates.value),
+        egressEstimates: computed(() => egressEstimates.value),
+        getQuote: getQuoteFn,
+        solveUsdcAmount: solveUsdcAmountFn,
+        estimateLive: estimateLiveFn,
+        interpolateSamples: interpolateSamplesFn,
+    };
+}

package/dist/composables/getSilentSwapAuth.d.ts

@@ -0,0 +1,12 @@
+import { createEip712DocForOrder, createEip712DocForWalletGeneration, type QuoteResponse } from '@silentswap/sdk';
+export interface GetSilentSwapAuthReturn {
+    createSignInMessage: (address: `0x${string}`, nonce: string, domain?: string) => string;
+    createEip712DocForOrder: (quoteResponse: QuoteResponse) => ReturnType<typeof createEip712DocForOrder>;
+    createEip712DocForWalletGeneration: (scope: string, token: string) => ReturnType<typeof createEip712DocForWalletGeneration>;
+}
+/**
+ * Vue composable for SilentSwap authentication utilities
+ *
+ * @returns Object with authentication utility functions
+ */
+export declare function getSilentSwapAuth(): GetSilentSwapAuthReturn;

package/dist/composables/getSilentSwapAuth.js

@@ -0,0 +1,23 @@
+import { createSignInMessage, createEip712DocForOrder, createEip712DocForWalletGeneration, } from '@silentswap/sdk';
+/**
+ * Vue composable for SilentSwap authentication utilities
+ *
+ * @returns Object with authentication utility functions
+ */
+export function getSilentSwapAuth() {
+    const createSignInMessageFn = (address, nonce, domain) => {
+        const signInMessage = createSignInMessage(address, nonce, domain);
+        return signInMessage.message;
+    };
+    const createEip712DocForOrderFn = (quoteResponse) => {
+        return createEip712DocForOrder(quoteResponse);
+    };
+    const createEip712DocForWalletGenerationFn = (scope, token) => {
+        return createEip712DocForWalletGeneration(scope, token);
+    };
+    return {
+        createSignInMessage: createSignInMessageFn,
+        createEip712DocForOrder: createEip712DocForOrderFn,
+        createEip712DocForWalletGeneration: createEip712DocForWalletGenerationFn,
+    };
+}

package/dist/composables/getSilentSwapClient.d.ts

@@ -0,0 +1,14 @@
+import { type SilentSwapClient, type SilentSwapClientConfig } from '@silentswap/sdk';
+export interface GetSilentSwapClientOptions {
+    config: SilentSwapClientConfig;
+}
+export interface GetSilentSwapClientReturn {
+    client: SilentSwapClient;
+}
+/**
+ * Vue composable for creating and managing a SilentSwap client instance
+ *
+ * @param options - Configuration options for the client
+ * @returns Object containing the SilentSwap client instance
+ */
+export declare function getSilentSwapClient({ config, }: GetSilentSwapClientOptions): GetSilentSwapClientReturn;

package/dist/composables/getSilentSwapClient.js

@@ -0,0 +1,16 @@
+import { computed } from 'vue';
+import { createSilentSwapClient, } from '@silentswap/sdk';
+/**
+ * Vue composable for creating and managing a SilentSwap client instance
+ *
+ * @param options - Configuration options for the client
+ * @returns Object containing the SilentSwap client instance
+ */
+export function getSilentSwapClient({ config, }) {
+    const client = computed(() => {
+        return createSilentSwapClient(config);
+    });
+    return {
+        client: client.value,
+    };
+}

package/dist/composables/getSilentSwapOrders.d.ts

@@ -0,0 +1,20 @@
+import { ref } from 'vue';
+import type { SilentSwapClient, AuthRequest, AuthResponse, NonceResponse, OrderRequest, OrderResponse, QuoteRequest, QuoteResponse } from '@silentswap/sdk';
+export interface GetSilentSwapOrdersOptions {
+    client: SilentSwapClient;
+}
+export interface GetSilentSwapOrdersReturn {
+    isLoading: Readonly<ReturnType<typeof ref<boolean>>>;
+    error: Readonly<ReturnType<typeof ref<Error | null>>>;
+    getNonce: (address: `0x${string}`) => Promise<NonceResponse | null>;
+    authenticate: (auth: AuthRequest) => Promise<AuthResponse | null>;
+    getQuote: (quote: QuoteRequest) => Promise<QuoteResponse | null>;
+    createOrder: (order: OrderRequest) => Promise<OrderResponse | null>;
+}
+/**
+ * Vue composable for managing SilentSwap orders and related operations
+ *
+ * @param options - Options containing the SilentSwap client
+ * @returns Object with order management methods and state
+ */
+export declare function getSilentSwapOrders({ client, }: GetSilentSwapOrdersOptions): GetSilentSwapOrdersReturn;

package/dist/composables/getSilentSwapOrders.js

@@ -0,0 +1,73 @@
+import { ref, computed } from 'vue';
+/**
+ * Vue composable for managing SilentSwap orders and related operations
+ *
+ * @param options - Options containing the SilentSwap client
+ * @returns Object with order management methods and state
+ */
+export function getSilentSwapOrders({ client, }) {
+    const isLoading = ref(false);
+    const error = ref(null);
+    const handleAsyncOperation = async (operation, errorMessage) => {
+        isLoading.value = true;
+        error.value = null;
+        try {
+            const result = await operation();
+            return result ?? null;
+        }
+        catch (err) {
+            const errorInstance = err instanceof Error ? err : new Error(errorMessage);
+            error.value = errorInstance;
+            return null;
+        }
+        finally {
+            isLoading.value = false;
+        }
+    };
+    const getNonce = async (address) => {
+        return handleAsyncOperation(async () => {
+            const [error, response] = await client.nonce(address);
+            if (error) {
+                throw new Error(`Failed to get nonce: ${error.error}`);
+            }
+            return response;
+        }, 'Failed to fetch nonce');
+    };
+    const authenticate = async (auth) => {
+        return handleAsyncOperation(async () => {
+            const [error, response] = await client.authenticate(auth);
+            if (error) {
+                throw new Error(`Authentication failed: ${error.error}`);
+            }
+            return response;
+        }, 'Authentication failed');
+    };
+    const getQuote = async (quote) => {
+        return handleAsyncOperation(async () => {
+            const [error, response] = await client.quote(quote);
+            if (error) {
+                throw new Error(`Failed to get quote: ${error.error}`);
+            }
+            return response;
+        }, 'Failed to fetch quote');
+    };
+    const createOrder = async (order) => {
+        return handleAsyncOperation(async () => {
+            const [error, response] = await client.order(order);
+            if (error) {
+                throw new Error(`Failed to create order: ${error.error}`);
+            }
+            return response;
+        }, 'Failed to create order');
+    };
+    return {
+        // State
+        isLoading: computed(() => isLoading.value),
+        error: computed(() => error.value),
+        // Methods
+        getNonce,
+        authenticate,
+        getQuote,
+        createOrder,
+    };
+}

package/dist/composables/getTransaction.d.ts

@@ -0,0 +1,26 @@
+import { ref } from 'vue';
+import type { WalletClient } from 'viem';
+import type { Connector } from 'wagmi';
+import type { BridgeProvider, BridgeQuote, BridgeStatus } from '@silentswap/sdk';
+export interface GetTransactionOptions {
+    /** User's EVM address */
+    address: `0x${string}`;
+    /** Wallet client for signing operations */
+    walletClient?: WalletClient;
+    /** Wagmi connector */
+    connector?: Connector;
+}
+export interface GetTransactionReturn {
+    isLoading: Readonly<ReturnType<typeof ref<boolean>>>;
+    currentStep: Readonly<ReturnType<typeof ref<string>>>;
+    error: Readonly<ReturnType<typeof ref<Error | null>>>;
+    executeTransaction: (quote: BridgeQuote) => Promise<BridgeStatus | null>;
+    getStatus: (requestId: string, provider: BridgeProvider) => Promise<BridgeStatus | null>;
+}
+/**
+ * Vue composable for executing bridge transactions
+ *
+ * This composable provides transaction execution for bridge quotes from any provider.
+ * It handles chain switching and transaction sending automatically.
+ */
+export declare function getTransaction({ address, walletClient, connector, }: GetTransactionOptions): GetTransactionReturn;

package/dist/composables/getTransaction.js

@@ -0,0 +1,82 @@
+import { ref, computed } from 'vue';
+import { executeRelayBridge, executeDebridgeBridge, getBridgeStatus, createTransactionExecutor, createChainSwitcher, } from '@silentswap/sdk';
+/**
+ * Vue composable for executing bridge transactions
+ *
+ * This composable provides transaction execution for bridge quotes from any provider.
+ * It handles chain switching and transaction sending automatically.
+ */
+export function getTransaction({ address, walletClient, connector, }) {
+    const isLoading = ref(false);
+    const currentStep = ref('');
+    const error = ref(null);
+    /**
+     * Execute a bridge transaction
+     */
+    const executeTransaction = async (quote) => {
+        if (!walletClient) {
+            throw new Error('Wallet client required for bridge execution');
+        }
+        if (!connector) {
+            throw new Error('Connector required for bridge execution');
+        }
+        isLoading.value = true;
+        error.value = null;
+        currentStep.value = '';
+        try {
+            // Create wrapper functions using shared utilities
+            const executeTransaction = createTransactionExecutor(walletClient, connector);
+            const switchChain = createChainSwitcher(walletClient, connector);
+            // Execute based on provider
+            switch (quote.provider) {
+                case 'relay':
+                    return await executeRelayBridge(quote, executeTransaction, switchChain, (step) => {
+                        currentStep.value = step;
+                    });
+                case 'debridge':
+                    return await executeDebridgeBridge(quote, executeTransaction, switchChain, (step) => {
+                        currentStep.value = step;
+                    });
+                default:
+                    throw new Error(`Unsupported bridge provider: ${quote.provider}`);
+            }
+        }
+        catch (err) {
+            const errorInstance = err instanceof Error ? err : new Error('Bridge execution failed');
+            error.value = errorInstance;
+            return null;
+        }
+        finally {
+            isLoading.value = false;
+            currentStep.value = '';
+        }
+    };
+    /**
+     * Get bridge status for a request
+     */
+    const getStatus = async (requestId, provider) => {
+        isLoading.value = true;
+        currentStep.value = 'Checking bridge status';
+        error.value = null;
+        try {
+            // Use shared status function
+            return await getBridgeStatus(requestId, provider);
+        }
+        catch (err) {
+            const errorInstance = err instanceof Error ? err : new Error('Failed to get bridge status');
+            error.value = errorInstance;
+            return null;
+        }
+        finally {
+            isLoading.value = false;
+            currentStep.value = '';
+        }
+    };
+    return {
+        isLoading: computed(() => isLoading.value),
+        currentStep: computed(() => currentStep.value),
+        error: computed(() => error.value),
+        executeTransaction,
+        getStatus,
+    };
+}

package/dist/index.d.ts

@@ -0,0 +1,8 @@
+export { getSilentSwapClient } from './composables/getSilentSwapClient.js';
+export { getSilentSwapOrders } from './composables/getSilentSwapOrders.js';
+export { getSilentSwapAuth } from './composables/getSilentSwapAuth.js';
+export { getQuote } from './composables/getQuote.js';
+export { getTransaction } from './composables/getTransaction.js';
+export type { SilentSwapClientConfig } from '@silentswap/sdk';
+export type { GetQuoteOptions, GetQuoteReturn, BridgeQuoteResult, EstimateResult, EstimateSample, Estimate, SolveResult, } from './composables/getQuote.js';
+export type { GetTransactionOptions, GetTransactionReturn, } from './composables/getTransaction.js';

package/dist/index.js

@@ -0,0 +1,5 @@
+export { getSilentSwapClient } from './composables/getSilentSwapClient.js';
+export { getSilentSwapOrders } from './composables/getSilentSwapOrders.js';
+export { getSilentSwapAuth } from './composables/getSilentSwapAuth.js';
+export { getQuote } from './composables/getQuote.js';
+export { getTransaction } from './composables/getTransaction.js';

package/package.json

@@ -0,0 +1,41 @@
+{
+  "name": "@silentswap/vue",
+  "type": "module",
+  "version": "0.0.41",
+  "license": "MIT",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "build": "tsc",
+    "clean": "rm -rf dist",
+    "dev": "tsc --watch",
+    "lint": "eslint src --ext .ts",
+    "lint:fix": "eslint src --ext .ts --fix"
+  },
+  "peerDependencies": {
+    "vue": ">=3.0.0",
+    "viem": "2.43.3",
+    "wagmi": "3.1.3"  
+  },
+  "dependencies": {
+    "@silentswap/sdk": "workspace:*",
+    "bignumber.js": "9.3.1"
+  },
+  "devDependencies": {
+    "@eslint/js": "9.38.0",
+    "@stylistic/eslint-plugin": "5.5.0",
+    "@tsconfig/node24": "24.0.1",
+    "@types/node": "24.9.1",
+    "@types/web": "0.0.283",
+    "@typescript-eslint/parser": "8.46.2",
+    "eslint": "9.38.0",
+    "eslint-import-resolver-typescript": "4.4.4",
+    "eslint-plugin-import-x": "4.16.1",
+    "typescript": "5.9.3",
+    "typescript-eslint": "8.46.2",
+    "vue": "3.4.0"
+  }
+}