hodl-wallet 2.0.4 → 2.0.6

package/dist/swap/config.js

@@ -0,0 +1,46 @@
+import bsc from '../network/bsc.js';
+import btc from '../network/btc.js';
+export const swapConfig = {
+    source: bsc,
+    destination: btc,
+    asset: 'USDT',
+    token: bsc.tokens.USDT.address,
+    decimals: 18,
+    slippageBps: 50,
+    bitcoinConfirmations: 3,
+    bscConfirmations: 15,
+    httpTimeoutMs: 15_000,
+    pollIntervalMs: 10_000,
+    quoteLifetimeMs: 300_000,
+    referenceMaxAgeMs: 300_000,
+    clockSkewMs: 60_000,
+    fundingMarginMs: 30_000,
+    attentionAfterMs: 3_600_000,
+    bitcoin: {
+        changeDustSats: 546,
+        memoDustSats: 294,
+        maxOutputs: 10,
+        feeTargetBlocks: 1
+    },
+    gas: {
+        approval: 100_000,
+        transfer: 120_000,
+        deposit: 350_000
+    },
+    chainflip: {
+        url: 'https://chainflip-swap.chainflip.io',
+        blockSeconds: 6,
+        refundRetryBlocks: 100,
+        sourceAsset: 'BscUsdt'
+    },
+    thorchain: {
+        midgardUrl: 'https://gateway.liquify.com/chain/thorchain_midgard',
+        streamingInterval: 1,
+        streamingQuantity: 0,
+        url: 'https://gateway.liquify.com/chain/thorchain_api',
+        router: '0xb30ec53f98ff5947ede720d32ac2da7e52a5f56b',
+        asset: `BSC.USDT-${bsc.tokens.USDT.address.toUpperCase()}`
+    },
+    pricesUrl: 'https://api.coingecko.com/api/v3/simple/price?ids=bitcoin,binancecoin,tether&vs_currencies=usd&include_last_updated_at=true&precision=8'
+};
+//# sourceMappingURL=config.js.map

package/dist/swap/config.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"config.js","sourceRoot":"","sources":["../../swap/config.ts"],"names":[],"mappings":"AAAA,OAAO,GAAG,MAAM,mBAAmB,CAAC;AACpC,OAAO,GAAG,MAAM,mBAAmB,CAAC;AAEpC,MAAM,CAAC,MAAM,UAAU,GAAG;IACtB,MAAM,EAAE,GAAG;IACX,WAAW,EAAE,GAAG;IAChB,KAAK,EAAE,MAAM;IACb,KAAK,EAAE,GAAG,CAAC,MAAM,CAAC,IAAI,CAAC,OAAO;IAC9B,QAAQ,EAAE,EAAE;IACZ,WAAW,EAAE,EAAE;IACf,oBAAoB,EAAE,CAAC;IACvB,gBAAgB,EAAE,EAAE;IACpB,aAAa,EAAE,MAAM;IACrB,cAAc,EAAE,MAAM;IACtB,eAAe,EAAE,OAAO;IACxB,iBAAiB,EAAE,OAAO;IAC1B,WAAW,EAAE,MAAM;IACnB,eAAe,EAAE,MAAM;IACvB,gBAAgB,EAAE,SAAS;IAC3B,OAAO,EAAE;QACL,cAAc,EAAE,GAAG;QACnB,YAAY,EAAE,GAAG;QACjB,UAAU,EAAE,EAAE;QACd,eAAe,EAAE,CAAC;KACrB;IACD,GAAG,EAAE;QACD,QAAQ,EAAE,OAAO;QACjB,QAAQ,EAAE,OAAO;QACjB,OAAO,EAAE,OAAO;KACnB;IACD,SAAS,EAAE;QACP,GAAG,EAAE,qCAAqC;QAC1C,YAAY,EAAE,CAAC;QACf,iBAAiB,EAAE,GAAG;QACtB,WAAW,EAAE,SAAS;KACzB;IACD,SAAS,EAAE;QACP,UAAU,EAAE,qDAAqD;QACjE,iBAAiB,EAAE,CAAC;QACpB,iBAAiB,EAAE,CAAC;QACpB,GAAG,EAAE,iDAAiD;QACtD,MAAM,EAAE,4CAA4C;QACpD,KAAK,EAAE,YAAY,GAAG,CAAC,MAAM,CAAC,IAAI,CAAC,OAAO,CAAC,WAAW,EAAE,EAAE;KAC7D;IACD,SAAS,EAAE,yIAAyI;CAC9I,CAAC"}

package/dist/swap/http.d.ts

@@ -0,0 +1,14 @@
+export declare class SwapHttpError extends Error {
+    readonly status: number;
+    constructor(status: number, message: string);
+}
+export declare function swapText(url: string): Promise<string>;
+export declare function swapJson(url: string, body?: unknown): Promise<unknown>;
+export declare function record(value: unknown): Record<string, unknown>;
+export declare function list(value: unknown): unknown[];
+export declare function textField(value: unknown): string;
+export declare function units(value: unknown): bigint;
+export declare function integer(value: unknown): number;
+export declare function evmAddress(value: unknown): string;
+export declare function transactionHash(value: unknown, evm?: boolean): string;
+export declare function ceilDiv(a: bigint, b: bigint): bigint;

package/dist/swap/http.js

@@ -0,0 +1,70 @@
+import { swapConfig } from './config.js';
+export class SwapHttpError extends Error {
+    status;
+    constructor(status, message) {
+        super(message);
+        this.status = status;
+    }
+}
+export async function swapText(url) {
+    const response = await fetch(url, { signal: AbortSignal.timeout(swapConfig.httpTimeoutMs), redirect: 'error' });
+    if (!response.ok)
+        throw new SwapHttpError(response.status, `Provider request failed (HTTP ${response.status}).`);
+    return response.text();
+}
+export async function swapJson(url, body) {
+    const response = await fetch(url, {
+        method: body === undefined ? 'GET' : 'POST',
+        headers: { accept: 'application/json', ...(body === undefined ? {} : { 'content-type': 'application/json' }) },
+        body: body === undefined ? undefined : JSON.stringify(body),
+        signal: AbortSignal.timeout(swapConfig.httpTimeoutMs),
+        redirect: 'error'
+    });
+    if (!response.ok) {
+        throw new SwapHttpError(response.status, `Provider request failed (HTTP ${response.status}).`);
+    }
+    return response.json();
+}
+export function record(value) {
+    if (!value || typeof value !== 'object' || Array.isArray(value))
+        throw new Error('Invalid provider response.');
+    return value;
+}
+export function list(value) {
+    if (!Array.isArray(value))
+        throw new Error('Invalid provider list.');
+    return value;
+}
+export function textField(value) {
+    if (typeof value !== 'string' || !value)
+        throw new Error('Missing provider field.');
+    return value;
+}
+export function units(value) {
+    if (typeof value !== 'string' || !/^\d+$/.test(value))
+        throw new Error('Invalid provider amount.');
+    return BigInt(value);
+}
+export function integer(value) {
+    if (typeof value !== 'number' || !Number.isSafeInteger(value) || value < 0)
+        throw new Error('Invalid provider integer.');
+    return value;
+}
+export function evmAddress(value) {
+    const address = textField(value);
+    if (!/^0x[\da-f]{40}$/i.test(address) || /^0x0{40}$/i.test(address))
+        throw new Error('Invalid provider EVM address.');
+    return address;
+}
+export function transactionHash(value, evm = false) {
+    const hash = textField(value).replace(/^0x/i, '');
+    if (!/^[\da-f]{64}$/i.test(hash) || /^0{64}$/.test(hash))
+        throw new Error('Invalid transaction hash.');
+    return `${evm ? '0x' : ''}${hash.toLowerCase()}`;
+}
+export function ceilDiv(a, b) {
+    if (a < 0n || b <= 0n)
+        throw new Error('Invalid price calculation.');
+    return (a + b - 1n) / b;
+}
+//# sourceMappingURL=http.js.map

package/dist/swap/http.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"http.js","sourceRoot":"","sources":["../../swap/http.ts"],"names":[],"mappings":"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"}

package/dist/swap/providers.d.ts

@@ -0,0 +1,24 @@
+import type { SwapRoute } from './routes.js';
+import type { ProviderProgress, ProviderQuote, SwapInput, SwapOperation, SwapPlan, SwapProvider, SwapQuote } from './types.js';
+export declare class ThorchainSwapProvider implements SwapProvider {
+    private readonly route;
+    readonly id: "thorchain";
+    constructor(route?: SwapRoute);
+    private inbound;
+    quote(input: SwapInput): Promise<ProviderQuote>;
+    prepare(quote: SwapQuote): Promise<SwapPlan>;
+    validate(quote: SwapQuote, plan: SwapPlan): Promise<void>;
+    status(operation: SwapOperation): Promise<ProviderProgress>;
+}
+export declare class ChainflipSwapProvider implements SwapProvider {
+    private readonly route;
+    readonly id: "chainflip";
+    constructor(route?: SwapRoute);
+    private available;
+    quote(input: SwapInput): Promise<ProviderQuote>;
+    prepare(quote: SwapQuote): Promise<SwapPlan>;
+    private checkStatus;
+    validate(quote: SwapQuote, plan: SwapPlan): Promise<void>;
+    status(operation: SwapOperation): Promise<ProviderProgress>;
+}
+export declare function createSwapProviders(route?: SwapRoute): SwapProvider[];

package/dist/swap/providers.js

@@ -0,0 +1,424 @@
+import { assetAddress, sameAssetAddress, swapRoutes } from './routes.js';
+import { swapConfig as config } from './config.js';
+import { ceilDiv, integer, list, record, swapJson, SwapHttpError, textField, transactionHash, units } from './http.js';
+function minimumOutput(expected) {
+    if (expected <= 0n)
+        throw new Error('The swap has no payable output.');
+    return ceilDiv(expected * BigInt(10_000 - config.slippageBps), 10000n).toString();
+}
+function assertTime(expiresAt) {
+    if (expiresAt <= Date.now() + config.fundingMarginMs)
+        throw new Error('Quote or deposit channel expired; obtain a new quote.');
+}
+function sameAddress(left, right) {
+    return typeof left === 'string' && left.toLowerCase() === right.toLowerCase();
+}
+function decimalRatio(value) {
+    const input = textField(value);
+    if (!/^\d+(?:\.\d+)?$/.test(input))
+        throw new Error('Invalid provider price.');
+    const [whole, fraction = ''] = input.split('.');
+    return [BigInt(whole + fraction), 10n ** BigInt(fraction.length)];
+}
+function thorMemo(quote, route) {
+    const interval = quote.details.streaming === true ? integer(quote.details.streamingInterval) : 1;
+    const quantity = quote.details.streaming === true ? integer(quote.details.streamingQuantity) : 1;
+    return `=:${route.destination.thorchain.asset}:${quote.to}/${quote.from}:${BigInt(quote.minimumBaseUnits) / route.destination.thorchain.scale}/${interval}/${quantity}`;
+}
+export class ThorchainSwapProvider {
+    route;
+    id = 'thorchain';
+    constructor(route = swapRoutes['bsc-btc']) {
+        this.route = route;
+    }
+    async inbound() {
+        const entries = list(await swapJson(`${config.thorchain.url}/thorchain/inbound_addresses`)).map(record);
+        for (const chain of ['BSC', 'BTC']) {
+            const entry = entries.find(item => item.chain === chain);
+            if (!entry)
+                throw new Error(`THORChain ${chain} trading is unavailable: chain not listed by the provider API.`);
+            const reasons = [];
+            for (const [field, reason] of [
+                ['halted', 'chain halted'],
+                ['global_trading_paused', 'global trading paused'],
+                ['chain_trading_paused', 'chain trading paused']
+            ]) {
+                if (entry[field] === true)
+                    reasons.push(reason);
+                else if (entry[field] !== false)
+                    reasons.push(`${reason} status unverified`);
+            }
+            if (reasons.length) {
+                throw new Error(`THORChain ${chain} trading is unavailable: ${reasons.join('; ')}.`);
+            }
+        }
+        const bsc = entries.find(item => item.chain === 'BSC');
+        if (!sameAddress(bsc.router, config.thorchain.router))
+            throw new Error('THORChain router changed; integration must be reviewed.');
+        const source = entries.find(item => item.chain === this.route.source.thorchain.chain);
+        assetAddress(this.route.source, source.address);
+        return source;
+    }
+    async quote(input) {
+        if (input.routeId !== this.route.id)
+            throw new Error('Swap route mismatch.');
+        const amount = BigInt(input.amountBaseUnits);
+        const { source, destination } = this.route;
+        if (amount % source.thorchain.scale !== 0n)
+            throw new Error('THORChain supports at most 8 USDT decimal places.');
+        const inbound = await this.inbound();
+        const params = new URLSearchParams({
+            from_asset: source.thorchain.asset, to_asset: destination.thorchain.asset, amount: (amount / source.thorchain.scale).toString(),
+            destination: input.to, refund_address: input.from,
+            ...(source.network.family === 'bitcoin' ? { extended: 'true' } : {}),
+            streaming_interval: String(config.thorchain.streamingInterval), streaming_quantity: String(config.thorchain.streamingQuantity), liquidity_tolerance_bps: String(config.slippageBps)
+        });
+        const data = record(await swapJson(`${config.thorchain.url}/thorchain/quote/swap?${params}`));
+        if (data.error || (source.network.family === 'evm' && !sameAddress(data.router, config.thorchain.router)) || !sameAssetAddress(source, data.inbound_address, textField(inbound.address))) {
+            throw new Error('THORChain returned an unavailable or inconsistent route.');
+        }
+        const recommendedMinimum = units(data.recommended_min_amount_in);
+        if (amount / source.thorchain.scale < recommendedMinimum)
+            throw new Error('Amount is below the safe THORChain minimum, including refund fees.');
+        const fees = record(data.fees);
+        if (textField(fees.asset).toUpperCase() !== destination.thorchain.asset || units(fees.affiliate) !== 0n)
+            throw new Error('Unexpected THORChain fees.');
+        const expectedThorUnits = units(data.expected_amount_out);
+        const expected = expectedThorUnits * destination.thorchain.scale;
+        const minimumBaseUnits = (BigInt(minimumOutput(expectedThorUnits)) * destination.thorchain.scale).toString();
+        const expiresAt = Math.min(integer(data.expiry) * 1_000, Date.now() + config.quoteLifetimeMs);
+        assertTime(expiresAt);
+        const evm = source.network.family === 'evm';
+        if (data.gas_rate_units !== (evm ? 'gwei' : 'satsperbyte'))
+            throw new Error('Unexpected THORChain gas units.');
+        if (!evm && amount <= units(inbound.dust_threshold))
+            throw new Error('Bitcoin deposit is below the THORChain dust threshold.');
+        const gasPrice = units(data.recommended_gas_rate) * (evm ? 1000000000n : 1n);
+        return {
+            provider: this.id, expectedBaseUnits: expected.toString(), minimumBaseUnits, expiresAt,
+            estimatedSeconds: typeof data.total_swap_seconds === 'number' ? integer(data.total_swap_seconds) : null,
+            fees: [
+                { label: 'Liquidity / price impact', asset: destination.asset, amountBaseUnits: (units(fees.liquidity) * destination.thorchain.scale).toString(), decimals: destination.decimals },
+                { label: `${destination.asset} payout`, asset: destination.asset, amountBaseUnits: (units(fees.outbound) * destination.thorchain.scale).toString(), decimals: destination.decimals }
+            ],
+            details: {
+                depositAddress: assetAddress(source, data.inbound_address), ...(evm ? { router: config.thorchain.router } : {}),
+                expirySeconds: integer(data.expiry), gasPrice: gasPrice.toString(),
+                streaming: true, streamingInterval: config.thorchain.streamingInterval, streamingQuantity: config.thorchain.streamingQuantity,
+                memo: `=:${destination.thorchain.asset}:${input.to}/${input.from}:${BigInt(minimumBaseUnits) / destination.thorchain.scale}/${config.thorchain.streamingInterval}/${config.thorchain.streamingQuantity}`
+            }
+        };
+    }
+    async prepare(quote) {
+        const plan = {
+            depositAddress: assetAddress(this.route.source, quote.details.depositAddress),
+            ...(this.route.source.network.family === 'evm' ? { router: config.thorchain.router } : {}),
+            expiresAt: quote.expiresAt, expirySeconds: integer(quote.details.expirySeconds),
+            memo: thorMemo(quote, this.route)
+        };
+        await this.validate(quote, plan);
+        return plan;
+    }
+    async validate(quote, plan) {
+        assertTime(Math.min(quote.expiresAt, plan.expiresAt));
+        const inbound = await this.inbound();
+        if (quote.routeId !== this.route.id || !sameAssetAddress(this.route.source, inbound.address, plan.depositAddress) ||
+            (this.route.source.network.family === 'evm' && plan.router !== config.thorchain.router) ||
+            plan.memo !== thorMemo(quote, this.route)) {
+            throw new Error('THORChain vault or swap parameters changed; obtain a new quote.');
+        }
+        if (this.route.source.network.family === 'bitcoin' &&
+            (BigInt(quote.amountBaseUnits) <= units(inbound.dust_threshold) || units(inbound.gas_rate) > BigInt(quote.funding.rate))) {
+            throw new Error('THORChain Bitcoin funding requirements changed; obtain a new quote.');
+        }
+    }
+    async status(operation) {
+        const { source, destination } = this.route;
+        if (operation.quote.routeId !== this.route.id)
+            throw new Error('Swap route mismatch.');
+        const deposit = operation.steps.find(step => step.kind === 'deposit');
+        if (!deposit)
+            return { state: 'deposit_pending' };
+        let data;
+        try {
+            data = record(await swapJson(`${config.thorchain.url}/thorchain/tx/status/${transactionHash(deposit.hash)}`));
+        }
+        catch (error) {
+            if (error instanceof SwapHttpError && error.status === 404)
+                return { state: 'deposit_pending' };
+            throw error;
+        }
+        if (!data.tx)
+            return { state: 'deposit_pending' };
+        const tx = record(data.tx);
+        if (transactionHash(tx.id) !== transactionHash(deposit.hash) || tx.chain !== source.thorchain.chain ||
+            !sameAssetAddress(source, tx.from_address, operation.quote.from) || tx.memo !== operation.plan?.memo) {
+            throw new Error('THORChain deposit does not match this swap.');
+        }
+        const coins = list(tx.coins).map(record);
+        if (coins.length !== 1 || textField(coins[0].asset).toUpperCase() !== source.thorchain.asset ||
+            units(coins[0].amount) * source.thorchain.scale !== BigInt(operation.quote.amountBaseUnits)) {
+            throw new Error('THORChain deposit asset or amount mismatch.');
+        }
+        const outputs = data.out_txs == null ? [] : list(data.out_txs).map(record);
+        const planned = data.planned_out_txs == null ? [] : list(data.planned_out_txs).map(record);
+        const stages = record(data.stages);
+        const swapStatus = stages.swap_status ? record(stages.swap_status) : null;
+        const progress = {
+            state: 'deposit_confirmed',
+            settlementComplete: swapStatus?.pending === false && !!stages.outbound_signed && record(stages.outbound_signed).completed === true &&
+                planned.length > 0 && outputs.length === planned.length
+        };
+        for (const output of outputs) {
+            const values = list(output.coins).map(record);
+            for (const coin of values) {
+                if (output.chain === destination.thorchain.chain && textField(coin.asset).toUpperCase() === destination.thorchain.asset && sameAssetAddress(destination, output.to_address, operation.quote.to)) {
+                    if (progress.payoutHash)
+                        throw new Error('Unexpected multiple payouts.');
+                    progress.payoutHash = transactionHash(output.id, destination.network.family === 'evm');
+                    progress.payoutBaseUnits = (units(coin.amount) * destination.thorchain.scale).toString();
+                    progress.state = 'payout_pending';
+                }
+                else if (output.chain === source.thorchain.chain && textField(coin.asset).toUpperCase() === source.thorchain.asset &&
+                    sameAssetAddress(source, output.to_address, operation.quote.from) && textField(output.memo).startsWith('REFUND:')) {
+                    if (progress.refundHash)
+                        throw new Error('Unexpected multiple refunds.');
+                    progress.refundHash = transactionHash(output.id, source.network.family === 'evm');
+                    progress.refundBaseUnits = (units(coin.amount) * source.thorchain.scale).toString();
+                    progress.state = 'refund_pending';
+                }
+                else {
+                    throw new Error('Unexpected THORChain payout asset or destination.');
+                }
+            }
+        }
+        if (progress.refundHash || planned.some(item => item.refund === true)) {
+            try {
+                const history = record(await swapJson(`${config.thorchain.midgardUrl}/v2/actions?txid=${transactionHash(deposit.hash)}`));
+                const action = list(history.actions).map(record).find(item => item.type === 'refund' &&
+                    list(item.in).map(record).some(input => transactionHash(input.txID) === transactionHash(deposit.hash)));
+                if (action) {
+                    const reason = textField(record(record(action.metadata).refund).reason).replace(/[\x00-\x1f\x7f]/g, ' ').slice(0, 240);
+                    progress.message = `THORChain refund: ${reason}.`;
+                }
+                else
+                    progress.message = 'THORChain refund reason is not available yet.';
+            }
+            catch {
+                progress.message = 'THORChain refund reason is temporarily unavailable.';
+            }
+        }
+        if (swapStatus?.pending === true) {
+            progress.state = 'swapping';
+            if (swapStatus.streaming) {
+                const streaming = record(swapStatus.streaming);
+                progress.message = [progress.message, `Streaming: ${integer(streaming.count)} / ${integer(streaming.quantity)} swap attempts.`].filter(Boolean).join(' ');
+            }
+            return progress;
+        }
+        if (progress.payoutHash || progress.refundHash)
+            return progress;
+        if (planned.some(item => item.refund === true))
+            return { ...progress, state: 'refund_pending' };
+        if (planned.length)
+            return { ...progress, state: 'payout_pending' };
+        if (stages.swap_finalised && record(stages.swap_finalised).completed === true)
+            return { state: 'payout_pending' };
+        if (stages.inbound_finalised && record(stages.inbound_finalised).completed === true)
+            return { state: 'swapping' };
+        return progress;
+    }
+}
+export class ChainflipSwapProvider {
+    route;
+    id = 'chainflip';
+    constructor(route = swapRoutes['bsc-btc']) {
+        this.route = route;
+    }
+    async available() {
+        const info = record(await swapJson(`${config.chainflip.url}/api/networkInfo`));
+        const assets = list(info.assets).map(record);
+        const source = assets.find(asset => asset.asset === this.route.source.chainflip.id);
+        const destination = assets.find(asset => asset.asset === this.route.destination.chainflip.id);
+        for (const [entry, asset] of [[source, this.route.source], [destination, this.route.destination]]) {
+            if (!entry)
+                throw new Error(`Chainflip ${asset.label} is currently unavailable: asset not listed by the provider API.`);
+        }
+        for (const [entry, asset, field, action] of [
+            [source, this.route.source, 'depositChannelCreationEnabled', 'deposit channel creation'],
+            [source, this.route.source, 'depositChannelDepositsEnabled', 'deposits'],
+            [destination, this.route.destination, 'egressEnabled', 'payouts']
+        ]) {
+            if (entry[field] !== true) {
+                const reason = entry[field] === false ? `${action} disabled by the provider` : `${action} status unverified`;
+                throw new Error(`Chainflip ${asset.label} is currently unavailable: ${reason}.`);
+            }
+        }
+    }
+    async quote(input) {
+        if (input.routeId !== this.route.id)
+            throw new Error('Swap route mismatch.');
+        await this.available();
+        const params = new URLSearchParams({
+            srcChain: this.route.source.chainflip.chain, srcAsset: this.route.source.asset, destChain: this.route.destination.chainflip.chain, destAsset: this.route.destination.asset,
+            amount: input.amountBaseUnits, isVaultSwap: 'false', isOnChain: 'false', dcaV2Enabled: 'false'
+        });
+        const quotes = list(await swapJson(`${config.chainflip.url}/v2/quote?${params}`)).map(record);
+        const regular = quotes.filter(item => item.type === 'REGULAR' && !item.dcaParams && !item.ccmParams &&
+            !item.isVaultSwap && !item.isOnChain && !item.maxBoostFeeBps && item.lowLiquidityWarning !== true);
+        if (!regular.length)
+            throw new Error('Chainflip has no safe single-execution quote.');
+        const data = regular.sort((a, b) => units(a.egressAmount) > units(b.egressAmount) ? -1 : 1)[0];
+        const source = record(data.srcAsset);
+        const target = record(data.destAsset);
+        if (source.chain !== this.route.source.chainflip.chain || source.asset !== this.route.source.asset ||
+            target.chain !== this.route.destination.chainflip.chain || target.asset !== this.route.destination.asset ||
+            units(data.depositAmount) !== BigInt(input.amountBaseUnits))
+            throw new Error('Chainflip quote asset or amount mismatch.');
+        const fees = [];
+        let egress = 0n;
+        const feeEntries = [
+            ...list(data.includedFees),
+            ...list(data.poolInfo).map(pool => ({ ...record(record(pool).fee), type: 'LIQUIDITY' }))
+        ];
+        for (const value of feeEntries) {
+            const fee = record(value);
+            const amount = units(fee.amount);
+            if ((fee.type === 'BOOST' || fee.type === 'BROKER') && amount !== 0n)
+                throw new Error('Unexpected Chainflip extra fee.');
+            const asset = textField(fee.asset);
+            const chain = textField(fee.chain);
+            const decimals = asset === 'BTC' && chain === 'Bitcoin' ? 8 :
+                asset === 'USDT' && chain === 'Bsc' ? 18 :
+                    (asset === 'USDC' || asset === 'USDT') && chain === 'Ethereum' ? 6 : null;
+            if (decimals === null)
+                throw new Error('Unsupported Chainflip fee denomination.');
+            fees.push({ label: textField(fee.type), asset: `${asset} (${chain})`, amountBaseUnits: amount.toString(), decimals });
+            if (fee.type === 'EGRESS') {
+                if (asset !== this.route.destination.asset || chain !== this.route.destination.chainflip.chain)
+                    throw new Error('Invalid Chainflip egress fee.');
+                egress += amount;
+            }
+        }
+        const expected = units(data.egressAmount);
+        const minimumBaseUnits = minimumOutput(expected);
+        const [price, scale] = decimalRatio(data.estimatedPrice);
+        const minPriceX128 = ceilDiv(price * (BigInt(minimumBaseUnits) + egress) * (1n << 128n) * 10n ** BigInt(this.route.destination.decimals), scale * (expected + egress) * 10n ** BigInt(this.route.source.decimals));
+        if (minPriceX128 <= 0n)
+            throw new Error('Invalid Chainflip minimum price.');
+        return {
+            provider: this.id, expectedBaseUnits: expected.toString(), minimumBaseUnits,
+            expiresAt: Date.now() + config.quoteLifetimeMs,
+            estimatedSeconds: integer(data.estimatedDurationSeconds), fees,
+            details: { quote: data, minPriceX128: minPriceX128.toString() }
+        };
+    }
+    async prepare(quote) {
+        assertTime(quote.expiresAt);
+        await this.available();
+        const data = record(await swapJson(`${config.chainflip.url}/api/openSwapDepositChannel`, {
+            srcAsset: { chain: this.route.source.chainflip.chain, asset: this.route.source.asset },
+            destAsset: { chain: this.route.destination.chainflip.chain, asset: this.route.destination.asset },
+            srcAddress: quote.from, destAddress: quote.to, amount: quote.amountBaseUnits,
+            maxBoostFeeBps: 0, takeCommission: false,
+            fillOrKillParams: {
+                refundAddress: quote.from, retryDurationBlocks: config.chainflip.refundRetryBlocks,
+                minPriceX128: textField(quote.details.minPriceX128), maxOraclePriceSlippage: null
+            },
+            quote: record(quote.details.quote)
+        }));
+        if (integer(data.brokerCommissionBps) !== 0 || integer(data.maxBoostFeeBps) !== 0 || units(data.channelOpeningFee) !== 0n) {
+            throw new Error('Chainflip channel introduced an unapproved fee; no funds sent.');
+        }
+        const expiresAt = integer(data.estimatedExpiryTime);
+        const plan = {
+            depositAddress: assetAddress(this.route.source, data.depositAddress), providerId: textField(data.id),
+            expiresAt: Math.min(quote.expiresAt, expiresAt), channelExpiryBlock: units(data.srcChainExpiryBlock).toString()
+        };
+        assertTime(plan.expiresAt);
+        return plan;
+    }
+    checkStatus(data, quote, plan) {
+        if (quote.routeId !== this.route.id || data.srcChain !== this.route.source.chainflip.chain || data.srcAsset !== this.route.source.asset ||
+            data.destChain !== this.route.destination.chainflip.chain || data.destAsset !== this.route.destination.asset ||
+            !sameAssetAddress(this.route.destination, data.destAddress, quote.to) || data.dcaParams || data.ccmParams) {
+            throw new Error('Chainflip channel parameters do not match the accepted swap.');
+        }
+        const channel = record(data.depositChannel);
+        if (channel.id !== plan.providerId || !sameAssetAddress(this.route.source, channel.depositAddress, plan.depositAddress) ||
+            units(channel.expectedDepositAmount) !== BigInt(quote.amountBaseUnits) || channel.dcaParams) {
+            throw new Error('Chainflip deposit channel mismatch.');
+        }
+        const protection = record(data.fillOrKillParams);
+        if (!sameAssetAddress(this.route.source, protection.refundAddress, quote.from))
+            throw new Error('Chainflip refund address mismatch.');
+        const [price, scale] = decimalRatio(protection.minPrice);
+        const actual = ceilDiv(price * (1n << 128n) * 10n ** BigInt(this.route.destination.decimals), scale * 10n ** BigInt(this.route.source.decimals));
+        if (actual + 1n < units(quote.details.minPriceX128))
+            throw new Error('Chainflip price protection is weaker than accepted.');
+        if (integer(protection.retryDurationBlocks) !== config.chainflip.refundRetryBlocks)
+            throw new Error('Chainflip refund deadline mismatch.');
+        if (data.boost && units(String(record(data.boost).maxBoostFeeBps)) !== 0n)
+            throw new Error('Unexpected boosted swap.');
+    }
+    async validate(quote, plan) {
+        assertTime(Math.min(quote.expiresAt, plan.expiresAt));
+        await this.available();
+        const data = record(await swapJson(`${config.chainflip.url}/v2/swaps/${encodeURIComponent(textField(plan.providerId))}`));
+        this.checkStatus(data, quote, plan);
+        if (data.state !== 'WAITING' || record(data.depositChannel).isExpired !== false)
+            throw new Error('Chainflip channel is no longer waiting for this deposit.');
+    }
+    async status(operation) {
+        if (!operation.plan?.providerId)
+            return { state: 'deposit_pending' };
+        const data = record(await swapJson(`${config.chainflip.url}/v2/swaps/${encodeURIComponent(operation.plan.providerId)}`));
+        this.checkStatus(data, operation.quote, operation.plan);
+        const progress = { state: 'deposit_pending' };
+        if (data.deposit) {
+            const deposit = record(data.deposit);
+            if (units(deposit.amount) !== BigInt(operation.quote.amountBaseUnits))
+                throw new Error('Chainflip deposit amount mismatch.');
+            if (deposit.txRef && transactionHash(deposit.txRef, this.route.source.network.family === 'evm') !== operation.steps.find(step => step.kind === 'deposit')?.hash) {
+                throw new Error('Chainflip deposit transaction mismatch.');
+            }
+        }
+        if (data.state === 'SWAPPING')
+            progress.state = 'swapping';
+        else if (data.state === 'RECEIVING')
+            progress.state = 'deposit_confirmed';
+        else if (['SENDING', 'SENT', 'COMPLETED'].includes(textField(data.state)))
+            progress.state = 'payout_pending';
+        else if (data.state === 'FAILED') {
+            progress.state = 'needs_attention';
+            progress.message = 'Provider reports a failure. Funds are not marked refunded until the source-asset refund is verified.';
+        }
+        else if (data.state !== 'WAITING')
+            throw new Error('Unknown Chainflip swap state.');
+        if (data.swapEgress) {
+            const egress = record(data.swapEgress);
+            progress.state = 'payout_pending';
+            if (egress.txRef) {
+                progress.payoutHash = transactionHash(egress.txRef, this.route.destination.network.family === 'evm');
+                progress.payoutBaseUnits = units(egress.amount).toString();
+            }
+        }
+        if (data.refundEgress) {
+            const refund = record(data.refundEgress);
+            progress.state = 'refund_pending';
+            if (refund.txRef) {
+                progress.refundHash = transactionHash(refund.txRef, this.route.source.network.family === 'evm');
+                progress.refundBaseUnits = units(refund.amount).toString();
+            }
+        }
+        if (data.fallbackEgress) {
+            progress.state = 'needs_attention';
+            progress.message = 'Provider reports an unexpected fallback payout. Check the operation before taking action.';
+        }
+        return progress;
+    }
+}
+export function createSwapProviders(route = swapRoutes['bsc-btc']) {
+    return [new ChainflipSwapProvider(route), new ThorchainSwapProvider(route)];
+}
+//# sourceMappingURL=providers.js.map