@vultisig/rujira 1.0.0

package/dist/modules/swap.d.ts

@@ -0,0 +1,48 @@
+import { Coin } from '@cosmjs/proto-signing';
+import type { RujiraClient } from '../client.js';
+import { type EasyRouteName, type EasySwapRequest } from '../easy-routes.js';
+import type { FinExecuteMsg, QuoteParams, SwapOptions, SwapQuote, SwapResult } from '../types.js';
+import { type QuoteCacheOptions } from '../utils/cache.js';
+export type RujiraSwapOptions = {
+    cache?: QuoteCacheOptions | false;
+    quoteExpiryBufferMs?: number;
+    quoteTtlMs?: number;
+    batchConcurrency?: number;
+    /** Minimum swap amount in base units. Amounts at or below this are rejected. Default: 0 (contract enforces). */
+    dustThreshold?: string;
+};
+export declare class RujiraSwap {
+    private readonly client;
+    private readonly quoteCache;
+    private readonly quoteExpiryBufferMs;
+    private readonly quoteTtlMs;
+    private readonly batchConcurrency;
+    private readonly dustThreshold;
+    constructor(client: RujiraClient, options?: RujiraSwapOptions);
+    clearCache(): void;
+    getCacheStats(): {
+        size: number;
+        maxSize: number;
+        ttlMs: number;
+    } | null;
+    getQuote(params: QuoteParams, options?: {
+        skipCache?: boolean;
+        maxStalenessMs?: number;
+    } | boolean): Promise<SwapQuote>;
+    execute(quote: SwapQuote, options?: SwapOptions): Promise<SwapResult>;
+    executeSwap(params: QuoteParams, options?: SwapOptions): Promise<SwapResult>;
+    buildTransaction(params: QuoteParams): Promise<{
+        contractAddress: string;
+        msg: FinExecuteMsg;
+        funds: Coin[];
+    }>;
+    buildL1Memo(params: QuoteParams): Promise<string>;
+    easySwap(request: EasySwapRequest): Promise<SwapResult>;
+    batchGetQuotes(routes: EasyRouteName[], amount: string, destination?: string): Promise<Map<EasyRouteName, SwapQuote | null>>;
+    getAllRouteQuotes(amount: string, destination?: string): Promise<Map<EasyRouteName, SwapQuote | null>>;
+    private recomputeMinimumOutput;
+    private findContract;
+    private validateQuoteParams;
+    private validateBalance;
+}
+//# sourceMappingURL=swap.d.ts.map

package/dist/modules/swap.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"swap.d.ts","sourceRoot":"","sources":["../../src/modules/swap.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,IAAI,EAAE,MAAM,uBAAuB,CAAA;AAI5C,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,cAAc,CAAA;AAChD,OAAO,EAAe,KAAK,aAAa,EAAE,KAAK,eAAe,EAAE,MAAM,mBAAmB,CAAA;AAGzF,OAAO,KAAK,EAAE,aAAa,EAAE,WAAW,EAAE,WAAW,EAAE,SAAS,EAAE,UAAU,EAAE,MAAM,aAAa,CAAA;AACjG,OAAO,EAAc,KAAK,iBAAiB,EAAE,MAAM,mBAAmB,CAAA;AAKtE,MAAM,MAAM,iBAAiB,GAAG;IAC9B,KAAK,CAAC,EAAE,iBAAiB,GAAG,KAAK,CAAA;IACjC,mBAAmB,CAAC,EAAE,MAAM,CAAA;IAC5B,UAAU,CAAC,EAAE,MAAM,CAAA;IACnB,gBAAgB,CAAC,EAAE,MAAM,CAAA;IACzB,gHAAgH;IAChH,aAAa,CAAC,EAAE,MAAM,CAAA;CACvB,CAAA;AAED,qBAAa,UAAU;IAQnB,OAAO,CAAC,QAAQ,CAAC,MAAM;IAPzB,OAAO,CAAC,QAAQ,CAAC,UAAU,CAA8B;IACzD,OAAO,CAAC,QAAQ,CAAC,mBAAmB,CAAQ;IAC5C,OAAO,CAAC,QAAQ,CAAC,UAAU,CAAQ;IACnC,OAAO,CAAC,QAAQ,CAAC,gBAAgB,CAAQ;IACzC,OAAO,CAAC,QAAQ,CAAC,aAAa,CAAQ;gBAGnB,MAAM,EAAE,YAAY,EACrC,OAAO,GAAE,iBAAsB;IASjC,UAAU,IAAI,IAAI;IAIlB,aAAa,IAAI;QAAE,IAAI,EAAE,MAAM,CAAC;QAAC,OAAO,EAAE,MAAM,CAAC;QAAC,KAAK,EAAE,MAAM,CAAA;KAAE,GAAG,IAAI;IAIlE,QAAQ,CACZ,MAAM,EAAE,WAAW,EACnB,OAAO,GAAE;QAAE,SAAS,CAAC,EAAE,OAAO,CAAC;QAAC,cAAc,CAAC,EAAE,MAAM,CAAA;KAAE,GAAG,OAAe,GAC1E,OAAO,CAAC,SAAS,CAAC;IAiGf,OAAO,CAAC,KAAK,EAAE,SAAS,EAAE,OAAO,GAAE,WAAgB,GAAG,OAAO,CAAC,UAAU,CAAC;IAoDzE,WAAW,CAAC,MAAM,EAAE,WAAW,EAAE,OAAO,GAAE,WAAgB,GAAG,OAAO,CAAC,UAAU,CAAC;IAKhF,gBAAgB,CAAC,MAAM,EAAE,WAAW,GAAG,OAAO,CAAC;QACnD,eAAe,EAAE,MAAM,CAAA;QACvB,GAAG,EAAE,aAAa,CAAA;QAClB,KAAK,EAAE,IAAI,EAAE,CAAA;KACd,CAAC;IAoCI,WAAW,CAAC,MAAM,EAAE,WAAW,GAAG,OAAO,CAAC,MAAM,CAAC;IAMjD,QAAQ,CAAC,OAAO,EAAE,eAAe,GAAG,OAAO,CAAC,UAAU,CAAC;IA2CvD,cAAc,CAClB,MAAM,EAAE,aAAa,EAAE,EACvB,MAAM,EAAE,MAAM,EACd,WAAW,CAAC,EAAE,MAAM,GACnB,OAAO,CAAC,GAAG,CAAC,aAAa,EAAE,SAAS,GAAG,IAAI,CAAC,CAAC;IAqC1C,iBAAiB,CAAC,MAAM,EAAE,MAAM,EAAE,WAAW,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC,GAAG,CAAC,aAAa,EAAE,SAAS,GAAG,IAAI,CAAC,CAAC;IAK5G,OAAO,CAAC,sBAAsB;YAOhB,YAAY;IAiC1B,OAAO,CAAC,mBAAmB;YAoCb,eAAe;CA6B9B"}

package/dist/modules/swap.js

@@ -0,0 +1,318 @@
+import Big from 'big.js';
+import { Amount, findAssetByFormat } from '../assets/index.js';
+import { EASY_ROUTES } from '../easy-routes.js';
+import { RujiraError, RujiraErrorCode } from '../errors.js';
+import { calculatePriceImpact } from '../services/price-impact.js';
+import { QuoteCache } from '../utils/cache.js';
+import { base64Encode } from '../utils/encoding.js';
+import { calculateMinReturn, generateQuoteId } from '../utils/format.js';
+import { validateThorAddress } from '../validation/address-validator.js';
+export class RujiraSwap {
+    constructor(client, options = {}) {
+        this.client = client;
+        this.quoteCache = options.cache === false ? null : new QuoteCache(options.cache);
+        this.quoteExpiryBufferMs = options.quoteExpiryBufferMs ?? 60000;
+        this.quoteTtlMs = options.quoteTtlMs ?? 120000;
+        this.batchConcurrency = options.batchConcurrency ?? 3;
+        this.dustThreshold = BigInt(options.dustThreshold ?? '0');
+    }
+    clearCache() {
+        this.quoteCache?.clear();
+    }
+    getCacheStats() {
+        return this.quoteCache?.stats() ?? null;
+    }
+    async getQuote(params, options = false) {
+        const skipCache = typeof options === 'boolean' ? options : (options.skipCache ?? false);
+        const maxStalenessMs = typeof options === 'boolean' ? undefined : options.maxStalenessMs;
+        this.validateQuoteParams(params);
+        if (params.destination) {
+            validateThorAddress(params.destination);
+        }
+        if (!skipCache && this.quoteCache) {
+            const cached = this.quoteCache.get(params.fromAsset, params.toAsset, params.amount);
+            if (cached) {
+                if (Date.now() >= cached.expiresAt) {
+                    // expired; fall through to fetch
+                }
+                else if (maxStalenessMs !== undefined && cached.cachedAt) {
+                    const age = Date.now() - cached.cachedAt;
+                    if (age <= maxStalenessMs) {
+                        return this.recomputeMinimumOutput(cached, params.slippageBps);
+                    }
+                }
+                else {
+                    const age = cached.cachedAt ? Date.now() - cached.cachedAt : 0;
+                    if (age > 5000) {
+                        return this.recomputeMinimumOutput({
+                            ...cached,
+                            warning: cached.warning ??
+                                `Quote is ${Math.round(age / 1000)}s old. Consider refreshing for volatile markets.`,
+                        }, params.slippageBps);
+                    }
+                    return this.recomputeMinimumOutput(cached, params.slippageBps);
+                }
+            }
+        }
+        const fromAsset = findAssetByFormat(params.fromAsset);
+        const toAsset = findAssetByFormat(params.toAsset);
+        if (!fromAsset) {
+            throw new RujiraError(RujiraErrorCode.INVALID_ASSET, `Unknown asset: ${params.fromAsset}`);
+        }
+        if (!toAsset) {
+            throw new RujiraError(RujiraErrorCode.INVALID_ASSET, `Unknown asset: ${params.toAsset}`);
+        }
+        const contractAddress = await this.findContract(params.fromAsset, params.toAsset);
+        const [simulation, orderbook] = await Promise.all([
+            this.client.simulateSwap(contractAddress, fromAsset.formats.fin, params.amount),
+            this.client.orderbook.getOrderBook(contractAddress).catch(() => null),
+        ]);
+        const slippageBps = params.slippageBps ?? this.client.config.defaultSlippageBps;
+        const minimumOutput = calculateMinReturn(simulation.returned, slippageBps);
+        const inputAmount = Big(params.amount);
+        const outputAmount = Big(simulation.returned);
+        const rate = outputAmount.gt(0)
+            ? inputAmount.mul(100000000).div(outputAmount).toFixed(0, 0) // round down
+            : '0';
+        const priceImpact = calculatePriceImpact(params.amount, simulation.returned, orderbook);
+        const priceImpactEstimated = !orderbook || !orderbook.bids[0]?.price || !orderbook.asks[0]?.price;
+        const quote = {
+            params,
+            expectedOutput: simulation.returned,
+            minimumOutput,
+            rate,
+            priceImpact,
+            fees: {
+                network: '0',
+                protocol: simulation.fee,
+                affiliate: '0',
+                total: simulation.fee,
+            },
+            contractAddress,
+            expiresAt: Date.now() + this.quoteTtlMs,
+            quoteId: generateQuoteId(),
+            cachedAt: Date.now(),
+            warning: priceImpactEstimated || priceImpact === 'unknown'
+                ? 'Price impact is estimated or unknown - orderbook data unavailable. Actual slippage may differ.'
+                : undefined,
+        };
+        this.quoteCache?.set(params.fromAsset, params.toAsset, params.amount, quote);
+        return quote;
+    }
+    async execute(quote, options = {}) {
+        const effectiveExpiry = quote.expiresAt - this.quoteExpiryBufferMs;
+        if (Date.now() > effectiveExpiry) {
+            const isActuallyExpired = Date.now() > quote.expiresAt;
+            throw new RujiraError(RujiraErrorCode.QUOTE_EXPIRED, isActuallyExpired
+                ? 'Quote has expired. Please get a new quote.'
+                : `Quote is about to expire (within ${this.quoteExpiryBufferMs}ms safety buffer). Please get a new quote to ensure execution completes.`);
+        }
+        if (!options.skipBalanceValidation) {
+            await this.validateBalance(quote.params.fromAsset, quote.params.amount);
+        }
+        const fromAsset = findAssetByFormat(quote.params.fromAsset);
+        if (!fromAsset) {
+            throw new RujiraError(RujiraErrorCode.INVALID_ASSET, `Unknown asset: ${quote.params.fromAsset}`);
+        }
+        const slippageBps = options.slippageBps ?? quote.params.slippageBps ?? this.client.config.defaultSlippageBps;
+        const minReturn = calculateMinReturn(quote.expectedOutput, slippageBps);
+        const swapMsg = {
+            swap: {
+                min: {
+                    min_return: minReturn,
+                    to: quote.params.destination,
+                },
+            },
+        };
+        const funds = [
+            {
+                denom: fromAsset.formats.fin,
+                amount: quote.params.amount,
+            },
+        ];
+        const result = await this.client.executeContract(quote.contractAddress, swapMsg, funds, options.memo);
+        return {
+            txHash: result.transactionHash,
+            status: 'pending',
+            fromAmount: quote.params.amount,
+            fee: quote.fees.total,
+            timestamp: Date.now(),
+        };
+    }
+    async executeSwap(params, options = {}) {
+        const quote = await this.getQuote(params);
+        return this.execute(quote, options);
+    }
+    async buildTransaction(params) {
+        const quote = await this.getQuote(params);
+        const fromAsset = findAssetByFormat(params.fromAsset);
+        if (!fromAsset) {
+            throw new RujiraError(RujiraErrorCode.INVALID_ASSET, `Unknown asset: ${params.fromAsset}`);
+        }
+        const minReturn = calculateMinReturn(quote.expectedOutput, params.slippageBps ?? this.client.config.defaultSlippageBps);
+        const msg = {
+            swap: {
+                min: {
+                    min_return: minReturn,
+                    to: params.destination,
+                },
+            },
+        };
+        const funds = [
+            {
+                denom: fromAsset.formats.fin,
+                amount: params.amount,
+            },
+        ];
+        return {
+            contractAddress: quote.contractAddress,
+            msg,
+            funds,
+        };
+    }
+    async buildL1Memo(params) {
+        const { contractAddress, msg } = await this.buildTransaction(params);
+        const msgBase64 = base64Encode(JSON.stringify(msg));
+        return `x:${contractAddress}:${msgBase64}`;
+    }
+    async easySwap(request) {
+        validateThorAddress(request.destination);
+        let fromAsset;
+        let toAsset;
+        if (request.route) {
+            const route = EASY_ROUTES[request.route];
+            if (!route) {
+                throw new RujiraError(RujiraErrorCode.INVALID_PAIR, `Unknown easy route: ${request.route}. Use listEasyRoutes() to see available routes.`);
+            }
+            fromAsset = route.from;
+            toAsset = route.to;
+        }
+        else if (request.from && request.to) {
+            fromAsset = request.from;
+            toAsset = request.to;
+        }
+        else {
+            throw new RujiraError(RujiraErrorCode.INVALID_PAIR, 'EasySwapRequest must specify either route or both from and to');
+        }
+        await this.validateBalance(fromAsset, request.amount);
+        const slippageBps = request.maxSlippagePercent !== undefined ? Math.round(request.maxSlippagePercent * 100) : undefined;
+        const quoteParams = {
+            fromAsset,
+            toAsset,
+            amount: request.amount,
+            destination: request.destination,
+            slippageBps,
+        };
+        const quote = await this.getQuote(quoteParams);
+        return this.execute(quote, { skipBalanceValidation: true });
+    }
+    async batchGetQuotes(routes, amount, destination) {
+        const results = [];
+        for (let i = 0; i < routes.length; i += this.batchConcurrency) {
+            const batch = routes.slice(i, i + this.batchConcurrency);
+            const batchResults = await Promise.all(batch.map(async (routeName) => {
+                try {
+                    const route = EASY_ROUTES[routeName];
+                    if (!route) {
+                        return { routeName, quote: null };
+                    }
+                    const quote = await this.getQuote({
+                        fromAsset: route.from,
+                        toAsset: route.to,
+                        amount,
+                        destination,
+                    });
+                    return { routeName, quote };
+                }
+                catch {
+                    return { routeName, quote: null };
+                }
+            }));
+            results.push(...batchResults);
+        }
+        const resultMap = new Map();
+        for (const { routeName, quote } of results) {
+            resultMap.set(routeName, quote);
+        }
+        return resultMap;
+    }
+    async getAllRouteQuotes(amount, destination) {
+        const allRoutes = Object.keys(EASY_ROUTES);
+        return this.batchGetQuotes(allRoutes, amount, destination);
+    }
+    recomputeMinimumOutput(quote, slippageBps) {
+        const effectiveSlippage = slippageBps ?? quote.params.slippageBps ?? this.client.config.defaultSlippageBps;
+        const minimumOutput = calculateMinReturn(quote.expectedOutput, effectiveSlippage);
+        if (minimumOutput === quote.minimumOutput)
+            return quote;
+        return { ...quote, minimumOutput, params: { ...quote.params, slippageBps: effectiveSlippage } };
+    }
+    async findContract(fromAsset, toAsset) {
+        const pairKey = `${fromAsset}/${toAsset}`;
+        const reversePairKey = `${toAsset}/${fromAsset}`;
+        const knownContracts = this.client.config.contracts.finContracts;
+        if (knownContracts[pairKey]) {
+            return knownContracts[pairKey];
+        }
+        if (knownContracts[reversePairKey]) {
+            return knownContracts[reversePairKey];
+        }
+        let address = await this.client.discovery.getContractAddress(fromAsset, toAsset);
+        if (!address) {
+            address = await this.client.discovery.getContractAddress(toAsset, fromAsset);
+        }
+        if (address) {
+            this.client.config.contracts.finContracts[pairKey] = address;
+            this.client.persistFinContracts().catch(() => undefined);
+            return address;
+        }
+        throw new RujiraError(RujiraErrorCode.INVALID_PAIR, `No FIN contract found for pair: ${fromAsset}/${toAsset}. ` +
+            'Market may not exist on Rujira or discovery failed.');
+    }
+    validateQuoteParams(params) {
+        if (!params.fromAsset) {
+            throw new RujiraError(RujiraErrorCode.INVALID_ASSET, 'fromAsset is required');
+        }
+        if (!params.toAsset) {
+            throw new RujiraError(RujiraErrorCode.INVALID_ASSET, 'toAsset is required');
+        }
+        if (params.fromAsset === params.toAsset) {
+            throw new RujiraError(RujiraErrorCode.INVALID_PAIR, 'Cannot swap asset to itself');
+        }
+        if (!params.amount || !/^\d+$/.test(params.amount)) {
+            throw new RujiraError(RujiraErrorCode.INVALID_AMOUNT, 'amount must be a positive integer string in base units');
+        }
+        if (BigInt(params.amount) <= 0n) {
+            throw new RujiraError(RujiraErrorCode.INVALID_AMOUNT, 'amount must be greater than zero');
+        }
+        if (this.dustThreshold > 0n && BigInt(params.amount) <= this.dustThreshold) {
+            throw new RujiraError(RujiraErrorCode.INVALID_AMOUNT, `Swap amount ${params.amount} is at or below dust threshold (${this.dustThreshold}). ` +
+                `Minimum swap amount: ${(this.dustThreshold + 1n).toString()}`);
+        }
+        if (params.slippageBps !== undefined) {
+            if (params.slippageBps < 1 || params.slippageBps > 5000) {
+                throw new RujiraError(RujiraErrorCode.INVALID_SLIPPAGE, 'slippageBps must be between 1 (0.01%) and 5000 (50%)');
+            }
+        }
+    }
+    async validateBalance(fromAsset, amount) {
+        const asset = findAssetByFormat(fromAsset);
+        if (!asset) {
+            throw new RujiraError(RujiraErrorCode.INVALID_ASSET, `Unknown asset: ${fromAsset}`);
+        }
+        const ticker = asset.id.toUpperCase();
+        const address = await this.client.getAddress();
+        const balance = await this.client.getBalance(address, asset.formats.fin);
+        const required = Amount.fromRaw(BigInt(amount), asset, 'fin');
+        const available = Amount.fromRaw(BigInt(balance.amount || '0'), asset, 'fin');
+        if (available.raw < required.raw) {
+            throw new RujiraError(RujiraErrorCode.INSUFFICIENT_BALANCE, `Insufficient ${ticker} balance. Required: ${required.toHuman()}, Available: ${available.toHuman()}`, {
+                asset: fromAsset,
+                denom: asset.formats.fin,
+                required: amount,
+                available: balance.amount,
+                shortfall: (required.raw - available.raw).toString(),
+            });
+        }
+    }
+}

package/dist/modules/withdraw.d.ts

@@ -0,0 +1,46 @@
+import type { Coin } from '@cosmjs/proto-signing';
+import type { RujiraClient } from '../client.js';
+export type WithdrawParams = {
+    asset: string;
+    amount: string;
+    l1Address: string;
+    maxFeeBps?: number;
+};
+export type PreparedWithdraw = {
+    chain: string;
+    asset: string;
+    denom: string;
+    amount: string;
+    destination: string;
+    memo: string;
+    estimatedFee: string;
+    estimatedTimeMinutes: number;
+    funds: Coin[];
+};
+export type WithdrawResult = {
+    txHash: string;
+    asset: string;
+    amount: string;
+    destination: string;
+    status: 'pending' | 'success' | 'failed';
+};
+export declare class RujiraWithdraw {
+    private readonly client;
+    private thornodeUrl;
+    constructor(client: RujiraClient);
+    prepare(params: WithdrawParams): Promise<PreparedWithdraw>;
+    execute(prepared: PreparedWithdraw): Promise<WithdrawResult>;
+    private getAccountInfo;
+    private getNetworkFee;
+    buildWithdrawMemo(l1Address: string): string;
+    estimateWithdrawTime(chain: string): number;
+    estimateWithdrawFee(asset: string, amount: string): Promise<string>;
+    getMinimumWithdraw(asset: string): Promise<string>;
+    canWithdraw(asset: string): Promise<{
+        possible: boolean;
+        reason?: string;
+    }>;
+    private validateWithdrawParams;
+    private parseAsset;
+}
+//# sourceMappingURL=withdraw.d.ts.map

package/dist/modules/withdraw.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"withdraw.d.ts","sourceRoot":"","sources":["../../src/modules/withdraw.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,uBAAuB,CAAA;AAGjD,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,cAAc,CAAA;AAchD,MAAM,MAAM,cAAc,GAAG;IAC3B,KAAK,EAAE,MAAM,CAAA;IACb,MAAM,EAAE,MAAM,CAAA;IACd,SAAS,EAAE,MAAM,CAAA;IACjB,SAAS,CAAC,EAAE,MAAM,CAAA;CACnB,CAAA;AAED,MAAM,MAAM,gBAAgB,GAAG;IAC7B,KAAK,EAAE,MAAM,CAAA;IACb,KAAK,EAAE,MAAM,CAAA;IACb,KAAK,EAAE,MAAM,CAAA;IACb,MAAM,EAAE,MAAM,CAAA;IACd,WAAW,EAAE,MAAM,CAAA;IACnB,IAAI,EAAE,MAAM,CAAA;IACZ,YAAY,EAAE,MAAM,CAAA;IACpB,oBAAoB,EAAE,MAAM,CAAA;IAC5B,KAAK,EAAE,IAAI,EAAE,CAAA;CACd,CAAA;AAED,MAAM,MAAM,cAAc,GAAG;IAC3B,MAAM,EAAE,MAAM,CAAA;IACd,KAAK,EAAE,MAAM,CAAA;IACb,MAAM,EAAE,MAAM,CAAA;IACd,WAAW,EAAE,MAAM,CAAA;IACnB,MAAM,EAAE,SAAS,GAAG,SAAS,GAAG,QAAQ,CAAA;CACzC,CAAA;AAwBD,qBAAa,cAAc;IAGb,OAAO,CAAC,QAAQ,CAAC,MAAM;IAFnC,OAAO,CAAC,WAAW,CAAQ;gBAEE,MAAM,EAAE,YAAY;IAI3C,OAAO,CAAC,MAAM,EAAE,cAAc,GAAG,OAAO,CAAC,gBAAgB,CAAC;IAyC1D,OAAO,CAAC,QAAQ,EAAE,gBAAgB,GAAG,OAAO,CAAC,cAAc,CAAC;YA0EpD,cAAc;YA2Bd,aAAa;IAiB3B,iBAAiB,CAAC,SAAS,EAAE,MAAM,GAAG,MAAM;IAI5C,oBAAoB,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM;IAIrC,mBAAmB,CAAC,KAAK,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC;IAInE,kBAAkB,CAAC,KAAK,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC;IA8BlD,WAAW,CAAC,KAAK,EAAE,MAAM,GAAG,OAAO,CAAC;QAAE,QAAQ,EAAE,OAAO,CAAC;QAAC,MAAM,CAAC,EAAE,MAAM,CAAA;KAAE,CAAC;IAmCjF,OAAO,CAAC,sBAAsB;IAsB9B,OAAO,CAAC,UAAU;CAInB"}

package/dist/modules/withdraw.js

@@ -0,0 +1,218 @@
+import { findAssetByFormat } from '../assets/index.js';
+import { CHAIN_PROCESSING_TIMES } from '../config.js';
+import { DEFAULT_THORCHAIN_FEE } from '../config/constants.js';
+import { RujiraError, RujiraErrorCode } from '../errors.js';
+import { estimateWithdrawFee } from '../services/fee-estimator.js';
+import { buildWithdrawalKeysignPayload } from '../signer/keysign-builder.js';
+import { isWithdrawCapable } from '../signer/types.js';
+import { parseAsset as sharedParseAsset } from '../utils/denom-conversion.js';
+import { buildSecureRedeemMemo } from '../utils/memo.js';
+import { thornodeRateLimiter } from '../utils/rate-limiter.js';
+import { isFinAsset, parseAsset } from '../utils/type-guards.js';
+import { validateL1Address } from '../validation/address-validator.js';
+function hasVaultAccess(signer) {
+    return (signer !== null &&
+        typeof signer === 'object' &&
+        'getVault' in signer &&
+        typeof signer.getVault === 'function');
+}
+export class RujiraWithdraw {
+    constructor(client) {
+        this.client = client;
+        this.thornodeUrl = client.config.restEndpoint;
+    }
+    async prepare(params) {
+        this.validateWithdrawParams(params);
+        const { chain } = parseAsset(params.asset);
+        const assetData = findAssetByFormat(params.asset);
+        if (!isFinAsset(assetData)) {
+            throw new RujiraError(RujiraErrorCode.INVALID_ASSET, `Unknown asset: ${params.asset}`);
+        }
+        const denom = assetData.formats.fin;
+        validateL1Address(chain, params.l1Address);
+        const memo = this.buildWithdrawMemo(params.l1Address);
+        const fee = await this.estimateWithdrawFee(params.asset, params.amount);
+        if (BigInt(params.amount) <= BigInt(fee)) {
+            throw new RujiraError(RujiraErrorCode.INVALID_AMOUNT, `Withdrawal amount (${params.amount}) is too small to cover estimated outbound fee (${fee}) for ${params.asset}. ` +
+                'Try a larger amount or wait for lower gas.');
+        }
+        const funds = [{ denom, amount: params.amount }];
+        return {
+            chain,
+            asset: params.asset,
+            denom,
+            amount: params.amount,
+            destination: params.l1Address,
+            memo,
+            estimatedFee: fee,
+            estimatedTimeMinutes: this.estimateWithdrawTime(chain),
+            funds,
+        };
+    }
+    async execute(prepared) {
+        if (!this.client.canSign()) {
+            throw new RujiraError(RujiraErrorCode.MISSING_SIGNER, 'Cannot execute withdrawal without a signer');
+        }
+        const clientInternal = this.client;
+        const signer = clientInternal.signer;
+        if (!hasVaultAccess(signer)) {
+            throw new RujiraError(RujiraErrorCode.MISSING_SIGNER, 'Withdrawal requires a VultisigRujiraProvider signer with vault access. ' +
+                'Standard Cosmos signers are not supported for MsgDeposit operations.');
+        }
+        try {
+            const vault = signer.getVault();
+            if (!isWithdrawCapable(vault)) {
+                throw new RujiraError(RujiraErrorCode.SIGNING_FAILED, 'Vault does not support withdrawal operations. ' +
+                    'Required methods: extractMessageHashes, sign, broadcastTx.');
+            }
+            const senderAddress = await vault.address('THORChain');
+            const [accountInfo, fee] = await Promise.all([this.getAccountInfo(senderAddress), this.getNetworkFee()]);
+            const keysignPayload = await buildWithdrawalKeysignPayload({
+                vault,
+                senderAddress,
+                prepared,
+                accountInfo,
+                fee,
+            });
+            const messageHashes = await vault.extractMessageHashes(keysignPayload);
+            const signature = await vault.sign({
+                transaction: keysignPayload,
+                chain: 'THORChain',
+                messageHashes,
+            });
+            const txHash = await vault.broadcastTx({
+                chain: 'THORChain',
+                keysignPayload,
+                signature,
+            });
+            return {
+                txHash,
+                asset: prepared.asset,
+                amount: prepared.amount,
+                destination: prepared.destination,
+                status: 'pending',
+            };
+        }
+        catch (error) {
+            if (error instanceof RujiraError) {
+                throw error;
+            }
+            const errorMsg = error instanceof Error ? error.message : String(error);
+            throw new RujiraError(RujiraErrorCode.CONTRACT_ERROR, `Withdrawal execution failed: ${errorMsg}. To withdraw manually, use the Vultisig mobile app with memo: ${prepared.memo}`, { originalError: errorMsg, prepared });
+        }
+    }
+    async getAccountInfo(address) {
+        try {
+            const response = await thornodeRateLimiter.fetch(`${this.thornodeUrl}/auth/accounts/${address}`);
+            if (!response.ok) {
+                throw new Error(`HTTP ${response.status}: ${response.statusText}`);
+            }
+            const data = (await response.json());
+            const accountData = data.result?.value || data.account;
+            if (!accountData) {
+                throw new Error('Invalid account response structure');
+            }
+            return {
+                accountNumber: accountData.account_number || '0',
+                sequence: accountData.sequence || '0',
+            };
+        }
+        catch (error) {
+            throw new RujiraError(RujiraErrorCode.NETWORK_ERROR, `Failed to fetch account info for ${address}: ${error instanceof Error ? error.message : String(error)}`);
+        }
+    }
+    async getNetworkFee() {
+        try {
+            const response = await thornodeRateLimiter.fetch(`${this.thornodeUrl}/thorchain/network`);
+            if (response.ok) {
+                const data = (await response.json());
+                if (data.native_tx_fee_rune) {
+                    return BigInt(data.native_tx_fee_rune);
+                }
+            }
+        }
+        catch {
+            // fall back below
+        }
+        return DEFAULT_THORCHAIN_FEE;
+    }
+    buildWithdrawMemo(l1Address) {
+        return buildSecureRedeemMemo(l1Address);
+    }
+    estimateWithdrawTime(chain) {
+        return CHAIN_PROCESSING_TIMES[chain.toUpperCase()] || 15;
+    }
+    async estimateWithdrawFee(asset, amount) {
+        return estimateWithdrawFee(this.thornodeUrl, asset, amount);
+    }
+    async getMinimumWithdraw(asset) {
+        const { chain } = parseAsset(asset);
+        try {
+            const response = await thornodeRateLimiter.fetch(`${this.thornodeUrl}/thorchain/inbound_addresses`);
+            if (response.ok) {
+                const addresses = (await response.json());
+                const chainInfo = addresses.find(a => a.chain === chain);
+                if (chainInfo) {
+                    return chainInfo.dust_threshold;
+                }
+            }
+        }
+        catch {
+            // fall back below
+        }
+        const defaults = {
+            BTC: '10000',
+            ETH: '0',
+            BSC: '0',
+            AVAX: '0',
+            GAIA: '0',
+            DOGE: '100000000',
+            LTC: '10000',
+            BCH: '10000',
+        };
+        return defaults[chain] || '0';
+    }
+    async canWithdraw(asset) {
+        const { chain } = parseAsset(asset);
+        try {
+            const response = await thornodeRateLimiter.fetch(`${this.thornodeUrl}/thorchain/inbound_addresses`);
+            if (!response.ok) {
+                return { possible: false, reason: 'Cannot reach THORNode' };
+            }
+            const addresses = (await response.json());
+            const chainInfo = addresses.find(a => a.chain === chain);
+            if (!chainInfo) {
+                return { possible: false, reason: `Chain ${chain} not supported` };
+            }
+            if (chainInfo.halted) {
+                return { possible: false, reason: `Chain ${chain} is halted` };
+            }
+            if (chainInfo.chain_trading_paused || chainInfo.global_trading_paused) {
+                return { possible: true, reason: 'Trading paused - withdrawals may be delayed' };
+            }
+            return { possible: true };
+        }
+        catch {
+            return { possible: false, reason: 'Network error checking withdrawal status' };
+        }
+    }
+    validateWithdrawParams(params) {
+        if (!params.asset || !params.asset.includes('.')) {
+            throw new RujiraError(RujiraErrorCode.INVALID_ASSET, `Invalid asset format: ${params.asset}. Expected format: CHAIN.SYMBOL`);
+        }
+        if (!params.amount || !/^\d+$/.test(params.amount)) {
+            throw new RujiraError(RujiraErrorCode.INVALID_AMOUNT, 'Amount must be a positive integer in base units');
+        }
+        const amountBigInt = BigInt(params.amount);
+        if (amountBigInt <= 0n) {
+            throw new RujiraError(RujiraErrorCode.INVALID_AMOUNT, 'Amount must be greater than zero');
+        }
+        if (!params.l1Address || params.l1Address.length === 0) {
+            throw new RujiraError(RujiraErrorCode.INVALID_ADDRESS, 'L1 destination address is required');
+        }
+    }
+    parseAsset(asset) {
+        const parsed = sharedParseAsset(asset);
+        return { chain: parsed.chain, symbol: parsed.symbol };
+    }
+}

package/dist/services/fee-estimator.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Withdraw fee estimation service
+ * @module services/fee-estimator
+ */
+/**
+ * Estimate the outbound fee for a withdrawal.
+ *
+ * Resolution order:
+ * 1. Fetch live outbound_fee from THORNode inbound_addresses
+ * 2. Fall back to hardcoded FALLBACK_OUTBOUND_FEES
+ * 3. For non-gas-asset tokens, convert via pool ratio
+ */
+export declare function estimateWithdrawFee(thornodeUrl: string, asset: string, _amount: string): Promise<string>;
+//# sourceMappingURL=fee-estimator.d.ts.map

package/dist/services/fee-estimator.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"fee-estimator.d.ts","sourceRoot":"","sources":["../../src/services/fee-estimator.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAqBH;;;;;;;GAOG;AACH,wBAAsB,mBAAmB,CACvC,WAAW,EAAE,MAAM,EACnB,KAAK,EAAE,MAAM,EACb,OAAO,EAAE,MAAM,GACd,OAAO,CAAC,MAAM,CAAC,CA2EjB"}