@gobob/bob-sdk 4.4.10-rc9 → 4.4.11-rc1

package/dist/gateway/client.js

@@ -1,582 +1,110 @@
 "use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
-    Object.defineProperty(o, "default", { enumerable: true, value: v });
-}) : function(o, v) {
-    o["default"] = v;
-});
-var __importStar = (this && this.__importStar) || (function () {
-    var ownKeys = function(o) {
-        ownKeys = Object.getOwnPropertyNames || function (o) {
-            var ar = [];
-            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
-            return ar;
-        };
-        return ownKeys(o);
-    };
-    return function (mod) {
-        if (mod && mod.__esModule) return mod;
-        var result = {};
-        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
-        __setModuleDefault(result, mod);
-        return result;
-    };
-})();
 var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.GatewayApiClient = exports.ORDER_DEADLINE_IN_SECONDS = exports.SIGNET_GATEWAY_BASE_URL = exports.MAINNET_GATEWAY_BASE_URL = void 0;
-const bitcoin_address_validation_1 = require("bitcoin-address-validation");
-const bitcoin = __importStar(require("bitcoinjs-lib"));
+exports.GatewayApiClient = exports.SIGNET_GATEWAY_BASE_URL = exports.MAINNET_GATEWAY_BASE_URL = exports.WBTC_OFT_ADDRESS = void 0;
 const viem_1 = require("viem");
 const chains_1 = require("viem/chains");
-const esplora_1 = require("../esplora");
 const utils_1 = require("../utils");
-const wallet_1 = require("../wallet");
 const abi_1 = require("./abi");
 const base_client_1 = require("./base-client");
 const strategy_1 = __importDefault(require("./strategy"));
+const generated_client_1 = require("./generated-client");
 const tokens_1 = require("./tokens");
-const types_1 = require("./types");
-const utils_2 = require("./utils");
-exports.MAINNET_GATEWAY_BASE_URL = 'https://gateway-api-mainnet.gobob.xyz';
+exports.WBTC_OFT_ADDRESS = '0x0555E30da8f98308EdB960aa94C0Db47230d2B9c';
+exports.MAINNET_GATEWAY_BASE_URL = 'https://gateway-api-staging.gobob.xyz';
 exports.SIGNET_GATEWAY_BASE_URL = 'https://gateway-api-signet.gobob.xyz';
-exports.ORDER_DEADLINE_IN_SECONDS = 30 * 60;
 class GatewayApiClient extends base_client_1.BaseClient {
     chain;
     strategy;
-    isSignet = false;
+    api;
     constructor(chainId, options) {
         super();
         switch (chainId) {
             case chains_1.bob.id:
                 this.chain = chains_1.bob;
                 this.strategy = new strategy_1.default(chains_1.bob, options?.rpcUrl);
+                this.api = new generated_client_1.DefaultApi(new generated_client_1.Configuration({
+                    basePath: exports.MAINNET_GATEWAY_BASE_URL,
+                }));
                 break;
             case chains_1.bobSepolia.id:
                 this.chain = chains_1.bobSepolia;
                 this.strategy = new strategy_1.default(chains_1.bobSepolia, options?.rpcUrl);
-                this.isSignet = true;
+                this.api = new generated_client_1.DefaultApi(new generated_client_1.Configuration({
+                    basePath: exports.SIGNET_GATEWAY_BASE_URL,
+                }));
                 break;
             default:
                 throw new Error('Invalid chain');
         }
     }
-    get baseUrl() {
-        return this.chain.id === chains_1.bob.id ? exports.MAINNET_GATEWAY_BASE_URL : exports.SIGNET_GATEWAY_BASE_URL;
-    }
     get chainId() {
         return this.chain.id;
     }
-    async mapRawOrderToOfframpOrder(order) {
-        const status = order.status;
-        const offrampRegistryAddress = order.offrampRegistryAddress;
-        const canOrderBeUnlocked = await this.canOrderBeUnlocked(status, Number(order.orderTimestamp), offrampRegistryAddress);
-        return {
-            orderId: (0, utils_2.safeBigInt)(order.orderId),
-            token: order.token,
-            satAmountLocked: (0, utils_2.safeBigInt)(order.satAmountLocked),
-            satSolverFeeMax: (0, utils_2.safeBigInt)(order.satFeesMax),
-            status,
-            orderTimestamp: (0, utils_2.safeNumber)(order.orderTimestamp),
-            submitOrderEvmTx: order.submitOrderEvmTx,
-            refundedEvmTx: order.refundedEvmTx,
-            btcTx: order.btcTx,
-            shouldFeesBeBumped: order.shouldFeesBeBumped,
-            canOrderBeUnlocked,
-            offrampRegistryAddress,
-            satAffiliateFee: (0, utils_2.safeBigInt)(order.satAffiliateFee),
-            affiliateFeeRecipient: order.affiliateFeeRecipient,
-            offrampRegistryVersion: (0, utils_2.safeNumber)(order.offrampRegistryVersion),
-            bumpFeeAmountInSats: order.bumpFeeAmountInSats !== null ? (0, utils_2.safeBigInt)(order.bumpFeeAmountInSats) : null,
-            userAddress: order.userAddress,
-        };
-    }
     async getQuote(params) {
-        if (params.fromChain?.toString().toLowerCase() === 'bitcoin') {
-            const data = await this.getOnrampQuote(params);
-            return {
-                type: types_1.GatewayOrderType.Onramp,
-                params,
-                finalOutputSats: data.outputSatoshis,
-                finalFeeSats: data.feeBreakdown.overallFeeSats + data.feeBreakdown.affiliateFeeSats,
-                data,
-            };
-        }
-        else if (params.toChain.toString().toLowerCase() === 'bitcoin') {
-            const data = await this.getOfframpQuote(params);
-            let createOrderGasCost = 0n;
-            try {
-                createOrderGasCost = await this.getOfframpCreateOrderGasCost(params, data);
-            }
-            catch (err) {
-                console.warn('Failed to get create order gas cost, defaulting to 0', err);
-            }
-            return {
-                type: types_1.GatewayOrderType.Offramp,
-                params,
-                finalOutputSats: data.amountReceiveInSat,
-                finalFeeSats: data.feeBreakdown.overallFeeSats + data.feeBreakdown.affiliateFeeSats,
-                data: {
-                    ...data,
-                    feeBreakdown: {
-                        ...data.feeBreakdown,
-                        gasFee: createOrderGasCost,
-                    },
-                },
-            };
-        }
-        throw new Error('Invalid quote arguments');
-    }
-    async getOfframpCreateOrderGasCost(params, offrampQuote) {
-        const chain = (0, utils_2.getChainConfig)(params.l0ChainId ?? params.fromChain);
-        const publicClient = (0, utils_2.viemClient)(chain);
-        if (!params.toUserAddress) {
-            params.toUserAddress = this.isSignet
-                ? 'tb1q0c2qnya702wrna5hqjp83jqqhx8zh5p9au2rqt'
-                : '14EvE4gm1yiYSzN8dYBtgYDppsaa1VVfud';
-        }
-        if (!params.fromUserAddress ||
-            ((0, viem_1.isAddress)(params.fromUserAddress) && (0, viem_1.isAddressEqual)(params.fromUserAddress, viem_1.zeroAddress))) {
-            params.fromUserAddress = '0x1111111111111111111111111111111111111111';
-        }
-        const [offrampOrder, offrampRegistryAddress, feeValues, gasPrice] = await Promise.all([
-            this.createOfframpOrder(offrampQuote, params),
-            this.fetchOfframpRegistryAddress(),
-            publicClient.estimateFeesPerGas(),
-            publicClient.getGasPrice(),
-        ]);
-        const fee = feeValues.maxFeePerGas ?? gasPrice;
-        const slots = (0, tokens_1.getTokenSlots)(offrampOrder.quote.token);
-        const user = params.fromUserAddress;
-        const allowanceSlot = (0, utils_2.computeAllowanceSlot)(user, offrampRegistryAddress, slots.allowanceSlot);
-        const balanceSlot = (0, utils_2.computeBalanceSlot)(user, slots.balanceSlot);
-        const args = [
-            {
-                ...offrampOrder.offrampArgs[0],
-                owner: user,
-            },
-        ];
-        const createOrderGasEstimate = await publicClient.estimateContractGas({
-            address: offrampRegistryAddress,
-            abi: offrampOrder.offrampABI,
-            functionName: offrampOrder.offrampFunctionName,
-            args,
-            account: user,
-            stateOverride: [
-                {
-                    address: offrampOrder.quote.token,
-                    stateDiff: [
-                        {
-                            slot: allowanceSlot,
-                            value: (0, viem_1.toHex)(viem_1.maxUint256),
-                        },
-                        {
-                            slot: balanceSlot,
-                            value: (0, viem_1.toHex)(viem_1.maxUint256),
-                        },
-                    ],
-                },
-                {
-                    address: user,
-                    balance: (0, viem_1.parseEther)('1'),
-                },
-            ],
-        });
-        return createOrderGasEstimate * fee;
-    }
-    async getOnrampQuote(params) {
-        const isMainnet = params.toChain === chains_1.bob.id ||
-            (typeof params.toChain === 'string' && params.toChain.toLowerCase() === chains_1.bob.name.toLowerCase());
-        const isTestnet = params.toChain === chains_1.bobSepolia.id ||
-            (typeof params.toChain === 'string' && params.toChain.toLowerCase() === chains_1.bobSepolia.name.toLowerCase());
-        if ((!isMainnet && !isTestnet) ||
-            (isMainnet && this.chain.id !== chains_1.bob.id) ||
-            (isTestnet && this.chain.id !== chains_1.bobSepolia.id)) {
-            throw new Error('Invalid output chain');
-        }
-        const outputTokenAddress = (0, tokens_1.getTokenAddress)(this.chainId, params.toToken);
-        const strategyAddress = params.strategyAddress?.startsWith('0x') ? params.strategyAddress : undefined;
-        const url = new URL(`${this.baseUrl}/v4/quote/${outputTokenAddress}`);
-        url.searchParams.append('userAddress', `${params.toUserAddress}`);
-        if (strategyAddress)
-            url.searchParams.append('strategy', strategyAddress);
-        if (params.amount)
-            url.searchParams.append('satoshis', `${params.amount}`);
-        if (params.gasRefill)
-            url.searchParams.append('ethAmountToReceive', `${params.gasRefill}`);
-        if (params.message)
-            url.searchParams.append('strategyExtraData', `${params.message}`);
-        if (params.affiliateFeeRecipient && params.affiliateFeeSats) {
-            url.searchParams.append('affiliateFee', params.affiliateFeeSats.toString());
-            url.searchParams.append('affiliateRecipient', params.affiliateFeeRecipient.toString());
-        }
-        const response = await this.safeFetch(url, {
-            headers: {
-                'Content-Type': 'application/json',
-                Accept: 'application/json',
-            },
-        }, 'Failed to get onramp liquidity');
-        if (!response.ok) {
-            const errorData = await response.json().catch(() => null);
-            const errorMessage = errorData?.message || 'Failed to get onramp liquidity';
-            throw new Error(errorMessage);
-        }
-        const jsonResponse = await response.json();
-        if (!jsonResponse.orderDetails) {
-            const errorData = jsonResponse.errorData;
-            const apiMessage = errorData?.message;
-            const errorMessage = apiMessage || 'Failed to get onramp quote';
-            throw new Error(errorMessage);
-        }
-        const quote = {
-            ...jsonResponse,
-            orderDetails: (0, utils_2.convertOrderDetailsRawToOrderDetails)(jsonResponse.orderDetails),
-            feeBreakdown: (0, utils_2.convertOnrampFeeBreakdown)(jsonResponse.feeBreakdown),
-        };
-        return {
-            ...quote,
-            outputSatoshis: quote.satoshis - quote.feeBreakdown.overallFeeSats - quote.feeBreakdown.affiliateFeeSats,
-            baseToken: (0, tokens_1.getTokenDetails)(this.chainId, quote.baseTokenAddress),
-            outputToken: quote.strategyAddress ? (0, tokens_1.getTokenDetails)(this.chainId, outputTokenAddress) : undefined,
-        };
-    }
-    async getOfframpQuote(params) {
-        if (!params.fromToken) {
-            throw new Error('`fromToken` must be specified for offramp');
-        }
-        const tokenAddress = (0, tokens_1.getTokenAddress)(this.chainId, params.fromToken);
-        const quote = await this.fetchOfframpQuote(tokenAddress, BigInt(params.amount || 0), params.fromUserAddress, params.toUserAddress, params.affiliateFeeRecipient, params.affiliateFeeSats);
-        return quote;
-    }
-    async fetchOfframpRegistryAddress() {
-        const response = await this.safeFetch(`${this.baseUrl}/offramp-registry-address`, undefined, 'Failed to fetch offramp registry contract address');
-        if (!response.ok) {
-            const errorData = await response.json().catch(() => null);
-            const apiMessage = errorData?.message;
-            const errorMessage = apiMessage || 'Failed to fetch offramp registry contract';
-            throw new Error(errorMessage);
-        }
-        return response.text();
-    }
-    async fetchOfframpLiquidity(token, userAddress) {
-        const tokenAddress = (0, tokens_1.getTokenAddress)(this.chainId, token);
-        const finalUserAddress = userAddress ?? viem_1.zeroAddress;
-        const queryParams = new URLSearchParams({
-            tokenAddress: tokenAddress,
-            userAddress: finalUserAddress,
-        });
-        const requestUrl = `${this.baseUrl}/v2/offramp-liquidity?${queryParams}`;
-        const response = await this.safeFetch(requestUrl, undefined, 'Failed to get offramp v2 liquidity');
-        if (!response.ok) {
-            const errorData = await response.json().catch(() => null);
-            const errorMessage = errorData?.message || 'Failed to get offramp v2 liquidity';
-            throw new Error(errorMessage);
-        }
-        const rawLiquidity = await response.json();
-        return {
-            tokenAddress: rawLiquidity.tokenAddress,
-            maxOrderAmountInSats: BigInt(rawLiquidity.maxOrderAmountInSats),
-            totalOfframpLiquidityInSats: BigInt(rawLiquidity.totalOfframpLiquidityInSats),
-            minimumOfframpQuote: {
-                minimumAmountInSats: BigInt(rawLiquidity.minimumOfframpQuote.minimumAmountInSats),
-                calculatedForFeeRate: BigInt(rawLiquidity.minimumOfframpQuote.calculatedForFeeRate),
-            },
-        };
-    }
-    async fetchOnrampLiquidity(token, userAddress, gasRefill) {
-        const tokenAddress = (0, tokens_1.getTokenAddress)(this.chainId, token.toLowerCase());
-        const finalUserAddress = userAddress ?? viem_1.zeroAddress;
-        const queryParams = new URLSearchParams({
-            tokenAddress: tokenAddress,
-            userAddress: finalUserAddress,
-        });
-        if (gasRefill) {
-            queryParams.append('gasRefill', gasRefill.toString());
-        }
-        const requestUrl = `${this.baseUrl}/onramp-liquidity?${queryParams.toString()}`;
-        const response = await this.safeFetch(requestUrl, undefined, 'Failed to get onramp liquidity');
-        if (!response.ok) {
-            const errorData = await response.json().catch(() => null);
-            const errorMessage = errorData?.message || 'Failed to get onramp liquidity';
-            throw new Error(errorMessage);
-        }
-        const rawLiquidity = await response.json();
-        return {
-            tokenAddress: rawLiquidity.tokenAddress,
-            maxOrderAmountInSats: BigInt(rawLiquidity.maxOrderAmountInSats),
-            totalOnrampLiquidityInSats: BigInt(rawLiquidity.totalOnrampLiquidityInSats),
-            minSatsAmount: BigInt(rawLiquidity.minSatsAmount),
-        };
-    }
-    async fetchOfframpQuote(token, amountInToken, userAddress, toUserAddress, affiliateFeeRecipient, affiliateFeeSats) {
-        const queryParams = new URLSearchParams({
-            amountInWrappedToken: amountInToken.toString(),
-            token,
-            userAddress: userAddress,
-        });
-        if (toUserAddress) {
-            queryParams.append('userBtcAddress', toUserAddress);
-        }
-        if (affiliateFeeRecipient && affiliateFeeSats) {
-            queryParams.append('affiliateFee', affiliateFeeSats.toString());
-            queryParams.append('affiliateRecipient', affiliateFeeRecipient.toString());
-        }
-        const response = await this.safeFetch(`${this.baseUrl}/offramp-quote?${queryParams}`, undefined, 'Failed to get offramp quote');
-        if (!response.ok) {
-            const errorData = await response.json().catch(() => null);
-            const apiMessage = errorData?.message;
-            const errorMessage = apiMessage || `Failed to get offramp quote`;
-            throw new Error(`${errorMessage}`);
-        }
-        const rawQuote = await response.json();
-        const currentUnixTimeInSec = Math.floor(Date.now() / 1000);
-        const deadline = currentUnixTimeInSec + exports.ORDER_DEADLINE_IN_SECONDS;
-        const normalizedAffiliateFeeRecipient = affiliateFeeRecipient ?? viem_1.zeroAddress;
-        return {
-            amountLockInSat: rawQuote.amountLockInSat,
-            deadline: deadline,
-            token: token,
-            feeBreakdown: {
-                overallFeeSats: rawQuote.feeBreakdown.overallFeeSats,
-                inclusionFeeSats: rawQuote.feeBreakdown.inclusionFeeSats,
-                protocolFeeSats: rawQuote.feeBreakdown.protocolFeeSats,
-                affiliateFeeSats: rawQuote.feeBreakdown.affiliateFeeSats,
-                fastestFeeRate: rawQuote.feeBreakdown.fastestFeeRate,
-            },
-            amountReceiveInSat: rawQuote.amountLockInSat -
-                rawQuote.feeBreakdown.overallFeeSats -
-                rawQuote.feeBreakdown.affiliateFeeSats,
-            affiliateFeeRecipient: normalizedAffiliateFeeRecipient,
-        };
-    }
-    async createOfframpOrder(quote, params) {
-        let bitcoinNetwork = bitcoin.networks.regtest;
-        if (this.chain.id == chains_1.bob.id) {
-            bitcoinNetwork = bitcoin.networks.bitcoin;
-        }
-        else if (this.chain.id == chains_1.bobSepolia.id) {
-            bitcoinNetwork = bitcoin.networks.testnet;
-        }
-        const receiverAddress = (0, utils_2.toHexScriptPubKey)(params.toUserAddress, bitcoinNetwork);
-        return {
-            quote,
-            offrampABI: abi_1.offrampCallerV2,
-            feeBreakdown: quote.feeBreakdown,
-            offrampFunctionName: 'createOrderV2',
-            offrampArgs: [
-                {
-                    satAmountToLock: BigInt(quote.amountLockInSat),
-                    satSolverFeeMax: BigInt(quote.feeBreakdown.overallFeeSats),
-                    satAffiliateFee: BigInt(quote.feeBreakdown.affiliateFeeSats),
-                    affiliateFeeRecipient: quote.affiliateFeeRecipient,
-                    creationDeadline: BigInt(quote.deadline),
-                    outputScript: receiverAddress,
-                    token: quote.token,
-                    owner: params.fromUserAddress,
-                },
-            ],
-        };
-    }
-    async bumpFeeForOfframpOrder({ orderId, offrampRegistryAddress, walletClient, publicClient, }) {
-        const orderDetails = await this.fetchOfframpOrder(orderId, offrampRegistryAddress);
-        if (orderDetails.status !== 'Active') {
-            throw new Error(`Offramp order needs to be Active for bumping fees`);
-        }
-        if (orderDetails.bumpFeeAmountInSats === null) {
-            throw new Error(`No need to bump fees, the current fees are sufficient`);
-        }
-        const { request } = await publicClient.simulateContract({
-            address: offrampRegistryAddress,
-            abi: abi_1.offrampCallerV2,
-            functionName: 'bumpFeeOfExistingOrder',
-            args: [orderId, BigInt(orderDetails.bumpFeeAmountInSats)],
-            account: walletClient.account,
-        });
-        const transactionHash = await walletClient.writeContract(request);
-        await publicClient.waitForTransactionReceipt({ hash: transactionHash });
-        return transactionHash;
-    }
-    async unlockOfframpOrder({ orderId, receiver, offrampRegistryAddress, walletClient, publicClient, }) {
-        const orderDetails = await this.fetchOfframpOrder(orderId, offrampRegistryAddress);
-        if (orderDetails.status == 'Processed' || orderDetails.status == 'Refunded') {
-            throw new Error(`Offramp order already processed / refunded`);
-        }
-        if (!(await this.canOrderBeUnlocked(orderDetails.status, orderDetails.orderTimestamp, offrampRegistryAddress))) {
-            throw new Error(`Offramp order is still within the 7-day claim delay and cannot be unlocked yet.`);
-        }
-        const { request } = await publicClient.simulateContract({
-            address: offrampRegistryAddress,
-            abi: abi_1.offrampCallerV2,
-            functionName: 'refundOrder',
-            args: [orderId, receiver],
-            account: walletClient.account,
+        return this.api.getQuote({
+            srcChain: params.fromChain.toString(),
+            dstChain: params.toChain.toString(),
+            sender: params.fromUserAddress?.toString() || '',
+            recipient: params.toUserAddress.toString(),
+            srcToken: params.fromToken.toString(),
+            dstToken: params.toToken.toString(),
+            amount: params.amount.toString(),
+            slippage: params.maxSlippage?.toString() || '0',
+            gasRefill: params.gasRefill?.toString(),
         });
-        const transactionHash = await walletClient.writeContract(request);
-        await publicClient.waitForTransactionReceipt({ hash: transactionHash });
-        return transactionHash;
-    }
-    async getOfframpOrders(userAddress) {
-        const response = await this.safeFetch(`${this.baseUrl}/offramp-orders/${userAddress}`, undefined, 'Failed to fetch offramp orders');
-        const rawOrders = await response.json();
-        return Promise.all(rawOrders.map((order) => this.mapRawOrderToOfframpOrder(order)));
-    }
-    async canOrderBeUnlocked(status, orderTimestamp, offrampRegistryAddress) {
-        if (status === 'Active' && Math.floor(Date.now() / 1000) - orderTimestamp >= 60) {
-            return true;
-        }
-        if (status !== 'Accepted') {
-            return false;
-        }
-        const nowInSec = Math.floor(Date.now() / 1000);
-        const publicClient = (0, utils_2.viemClient)(this.chain);
-        const claimDelay = await publicClient.readContract({
-            address: offrampRegistryAddress,
-            abi: abi_1.claimDelayAbi,
-            functionName: 'CLAIM_DELAY',
-        });
-        return orderTimestamp + Number(claimDelay) <= nowInSec;
-    }
-    async fetchOfframpOrder(orderId, registryAddress) {
-        const queryParams = new URLSearchParams({
-            registryAddress: registryAddress.toString(),
-            orderId: orderId.toString(),
-        });
-        const response = await this.safeFetch(`${this.baseUrl}/offramp-order?${queryParams}`, undefined, 'Failed to fetch offramp order');
-        if (!response.ok) {
-            const errorData = await response.json().catch(() => null);
-            const apiMessage = errorData?.message;
-            const errorMessage = apiMessage || `Failed to get offramp order (status: ${response.status} ${response.statusText})`;
-            throw new Error(`${errorMessage}`);
-        }
-        const offrampRawOrder = await response.json();
-        return await this.mapRawOrderToOfframpOrder(offrampRawOrder);
-    }
-    async startOnrampOrder(gatewayQuote, params) {
-        if (!params.toUserAddress || !(0, viem_1.isAddress)(params.toUserAddress)) {
-            throw new Error('Invalid user address');
-        }
-        const request = {
-            gatewayAddress: gatewayQuote.gatewayAddress,
-            strategyAddress: gatewayQuote.strategyAddress,
-            userAddress: params.toUserAddress,
-            gatewayExtraData: undefined,
-            strategyExtraData: params.message,
-            satoshis: gatewayQuote.satoshis,
-            campaignId: params.campaignId,
-            orderDetails: (0, utils_2.convertOrderDetailsToRaw)(gatewayQuote.orderDetails),
-        };
-        const response = await this.safeFetch(`${this.baseUrl}/v4/order`, {
-            method: 'POST',
-            headers: {
-                'Content-Type': 'application/json',
-                Accept: 'application/json',
-            },
-            body: JSON.stringify(request),
-        }, 'Failed to create order');
-        if (!response.ok) {
-            const errorData = await response.json().catch(() => null);
-            const apiMessage = errorData?.message;
-            const errorMessage = apiMessage || 'Failed to create order';
-            throw new Error(errorMessage);
-        }
-        const data = await response.json();
-        let psbtBase64 = '';
-        if (params.fromUserAddress &&
-            typeof params.fromChain === 'string' &&
-            params.fromChain.toLowerCase() === 'bitcoin') {
-            psbtBase64 = await (0, wallet_1.createBitcoinPsbt)(params.fromUserAddress, gatewayQuote.bitcoinAddress, gatewayQuote.satoshis, params.fromUserPublicKey, data.opReturnHash, params.feeRate, gatewayQuote.txProofDifficultyFactor, this.isSignet);
-            return {
-                uuid: data.uuid,
-                opReturnHash: data.opReturnHash,
-                bitcoinAddress: gatewayQuote.bitcoinAddress,
-                satoshis: gatewayQuote.satoshis,
-                psbtBase64,
-            };
-        }
-        throw new Error('Failed to create bitcoin psbt due to an unexpected error.');
     }
     async executeQuote({ quote, walletClient, publicClient, btcSigner, }) {
-        if (quote.type === 'onramp') {
-            const { params, data } = quote;
-            const esploraClient = new esplora_1.EsploraClient(this.chain.id === chains_1.bob.id ? bitcoin_address_validation_1.Network.mainnet : bitcoin_address_validation_1.Network.signet);
-            const availableBtcBalance = await esploraClient.getBalance(params.fromUserAddress);
-            if (availableBtcBalance.total < BigInt(data.satoshis)) {
-                throw new Error(`Insufficient BTC balance in address ${data.bitcoinAddress}. Required: ${(0, utils_2.formatBtc)(BigInt(data.satoshis))}, Got: ${(0, utils_2.formatBtc)(BigInt(availableBtcBalance.total))}`);
-            }
-            const { uuid, psbtBase64, bitcoinAddress, satoshis, opReturnHash } = await this.startOnrampOrder(data, params);
+        if ((0, generated_client_1.instanceOfGatewayQuoteOneOf)(quote)) {
             if (!btcSigner) {
                 throw new Error(`btcSigner is required for onramp order`);
             }
+            const { id, psbt } = await this.api.startOnramp({ gatewayOnrampQuote: quote.onramp });
             let bitcoinTxHex;
             if (btcSigner.sendBitcoin) {
-                bitcoinTxHex = await btcSigner.sendBitcoin({
-                    from: params.fromUserAddress,
-                    to: bitcoinAddress,
-                    value: (0, utils_2.formatBtc)(BigInt(satoshis)),
-                    opReturn: opReturnHash,
-                    isSignet: this.isSignet,
-                });
+                bitcoinTxHex = '';
             }
             else if (btcSigner.signAllInputs) {
-                bitcoinTxHex = await btcSigner.signAllInputs(psbtBase64);
+                bitcoinTxHex = await btcSigner.signAllInputs(psbt);
             }
             else {
                 throw new Error('btcSigner must implement either sendBitcoin or signAllInputs method');
             }
             if (!bitcoinTxHex)
                 throw new Error('Failed to get signed transaction');
-            const txId = await this.finalizeOnrampOrder(uuid, bitcoinTxHex);
+            const txId = await this.api.registerBtcTx({ registerBtcTx: { bitcoinTx: bitcoinTxHex, id } });
             return txId;
         }
-        else if (quote.type === 'offramp') {
-            const { params, data } = quote;
-            const tokenAddress = (0, tokens_1.getTokenAddress)(this.chainId, params.fromToken);
-            const [offrampOrder, offrampRegistryAddress] = await Promise.all([
-                this.createOfframpOrder(data, params),
-                this.fetchOfframpRegistryAddress(),
-            ]);
-            const accountAddress = walletClient.account?.address ?? params.fromUserAddress;
-            const [ethBalance, feeValues, gasPrice, [allowance, decimals]] = await Promise.all([
-                publicClient.getBalance({
-                    address: accountAddress,
-                }),
-                publicClient.estimateFeesPerGas(),
-                publicClient.getGasPrice(),
-                publicClient.multicall({
-                    allowFailure: false,
-                    contracts: [
-                        {
-                            address: tokenAddress,
-                            abi: viem_1.erc20Abi,
-                            functionName: 'allowance',
-                            args: [params.fromUserAddress, offrampRegistryAddress],
-                        },
-                        {
-                            address: tokenAddress,
-                            abi: viem_1.erc20Abi,
-                            functionName: 'decimals',
-                        },
-                    ],
-                }),
-            ]);
-            const fee = feeValues.maxFeePerGas ?? gasPrice;
+        else if ((0, generated_client_1.instanceOfGatewayQuoteOneOf1)(quote)) {
+            if (!walletClient.account) {
+                throw new Error(`walletClient is required for offramp order`);
+            }
+            const accountAddress = walletClient.account.address;
+            const tokenAddress = exports.WBTC_OFT_ADDRESS;
+            const spenderAddress = quote.offramp.tx.to;
+            const [allowance, decimals] = await publicClient.multicall({
+                allowFailure: false,
+                contracts: [
+                    {
+                        address: tokenAddress,
+                        abi: viem_1.erc20Abi,
+                        functionName: 'allowance',
+                        args: [accountAddress, spenderAddress],
+                    },
+                    {
+                        address: tokenAddress,
+                        abi: viem_1.erc20Abi,
+                        functionName: 'decimals',
+                    },
+                ],
+            });
             if (decimals < 8) {
                 throw new Error('Tokens with less than 8 decimals are not supported');
             }
             const multiplier = 10n ** BigInt(decimals - 8);
-            const requiredAmount = BigInt(data.amountLockInSat) * multiplier;
+            const requiredAmount = BigInt(quote.offramp.inputAmount) * multiplier;
             const needsApproval = requiredAmount > allowance;
             if (needsApproval) {
                 const { request } = await publicClient.simulateContract({
@@ -584,36 +112,22 @@ class GatewayApiClient extends base_client_1.BaseClient {
                     address: tokenAddress,
                     abi: viem_1.erc20Abi,
                     functionName: 'approve',
-                    args: [offrampRegistryAddress, viem_1.maxUint256],
+                    args: [spenderAddress, viem_1.maxUint256],
                 });
                 const approveTxHash = await walletClient.writeContract(request);
                 await publicClient.waitForTransactionReceipt({ hash: approveTxHash });
             }
-            const balanceForCreate = needsApproval
-                ? await publicClient.getBalance({ address: accountAddress })
-                : ethBalance;
-            const createOrderGasEstimate = await publicClient.estimateContractGas({
-                address: offrampRegistryAddress,
-                abi: offrampOrder.offrampABI,
-                functionName: offrampOrder.offrampFunctionName,
-                args: offrampOrder.offrampArgs,
-                account: walletClient.account,
-            });
-            const createOrderGasCost = createOrderGasEstimate * fee;
-            if (balanceForCreate < createOrderGasCost) {
-                throw new Error(`Insufficient ETH balance for gas fees. Required: ${createOrderGasCost} wei, Available: ${ethBalance} wei`);
-            }
-            const { request } = await publicClient.simulateContract({
+            const transactionHash = await walletClient.sendTransaction({
                 account: walletClient.account,
-                address: offrampRegistryAddress,
-                abi: offrampOrder.offrampABI,
-                functionName: offrampOrder.offrampFunctionName,
-                args: offrampOrder.offrampArgs,
+                data: quote.offramp.tx.data,
+                to: spenderAddress,
+                value: BigInt(quote.offramp.tx.value || 0),
             });
-            const transactionHash = await walletClient.writeContract(request);
             await publicClient?.waitForTransactionReceipt({ hash: transactionHash });
             return transactionHash;
         }
+        else if ((0, generated_client_1.instanceOfGatewayQuoteOneOf2)(quote)) {
+        }
         throw new Error('Invalid quote type');
     }
     async executeStrategy({ walletClient, publicClient, ...params }) {
@@ -645,191 +159,8 @@ class GatewayApiClient extends base_client_1.BaseClient {
         await publicClient?.waitForTransactionReceipt({ hash: transactionHash });
         return transactionHash;
     }
-    async finalizeOnrampOrder(uuid, bitcoinTxOrId) {
-        bitcoinTxOrId = (0, utils_2.stripHexPrefix)(bitcoinTxOrId);
-        let bitcoinTxHex;
-        if (bitcoinTxOrId.length === 64) {
-            const esploraClient = new esplora_1.EsploraClient(this.chain.id === chains_1.bob.id ? bitcoin_address_validation_1.Network.mainnet : bitcoin_address_validation_1.Network.signet);
-            bitcoinTxHex = await esploraClient.getTransactionHex(bitcoinTxOrId);
-        }
-        else {
-            bitcoinTxHex = bitcoinTxOrId;
-        }
-        const response = await this.safeFetch(`${this.baseUrl}/order/${uuid}`, {
-            method: 'PATCH',
-            headers: {
-                'Content-Type': 'application/json',
-                Accept: 'application/json',
-            },
-            body: JSON.stringify({ bitcoinTx: bitcoinTxHex }),
-        }, 'Failed to update order');
-        if (!response.ok) {
-            const errorData = await response.json().catch(() => null);
-            const apiMessage = errorData?.message;
-            const errorMessage = apiMessage || `Failed to update order`;
-            throw new Error(errorMessage);
-        }
-        return response.json();
-    }
-    async getOnrampOrders(userAddress) {
-        const chainId = this.chainId;
-        const response = await this.safeFetch(`${this.baseUrl}/orders/${userAddress}`, undefined, 'Failed to fetch onramp orders');
-        const orders = await response.json();
-        return orders.map((order) => {
-            const outputTokenAddress = order.outputTokenAddress ?? order.tokensReceived?.[0]?.tokenAddress ?? null;
-            const outputTokenAmount = order.outputTokenAmount ?? order.tokensReceived?.[0]?.amount ?? null;
-            function getFinal(base, output) {
-                return order.status
-                    ? order.strategyAddress
-                        ? output
-                            ? output
-                            : base
-                        : base
-                    : order.strategyAddress
-                        ? output
-                        : base;
-            }
-            const getTokenAddress = () => {
-                return getFinal(order.baseTokenAddress, outputTokenAddress);
-            };
-            const getTokenAmount = () => {
-                let amount = order.satoshis - order.fee;
-                const token = getToken();
-                if (token && !outputTokenAmount) {
-                    amount *= Math.pow(10, token.decimals - 8);
-                }
-                return getFinal(amount, outputTokenAmount);
-            };
-            const getToken = () => {
-                return (0, tokens_1.getTokenDetails)(chainId, getTokenAddress());
-            };
-            const getConfirmations = async (esploraClient, latestHeight) => {
-                const txStatus = await esploraClient.getTransactionStatus(order.txid);
-                if (!latestHeight) {
-                    latestHeight = await esploraClient.getLatestHeight();
-                }
-                return txStatus.confirmed ? latestHeight - txStatus.block_height + 1 : 0;
-            };
-            const orderDetails = order.orderDetails
-                ? (0, utils_2.convertOrderDetailsRawToOrderDetails)(order.orderDetails)
-                : undefined;
-            const getOutputTokens = () => {
-                const tokens = order.tokensReceived
-                    ? order.tokensReceived
-                    : outputTokenAmount && outputTokenAddress
-                        ? [{ amount: outputTokenAmount, tokenAddress: outputTokenAddress }]
-                        : [];
-                return tokens
-                    .map(({ amount, tokenAddress }) => ({
-                    amount: amount,
-                    token: (0, tokens_1.getTokenDetails)(chainId, tokenAddress),
-                }))
-                    .filter((x) => x.token);
-            };
-            const getTokens = () => {
-                const tokens = order.tokensReceived
-                    ? order.tokensReceived
-                    : [{ amount: getTokenAmount(), tokenAddress: getTokenAddress() }];
-                return tokens.map(({ amount, tokenAddress }) => ({
-                    amount: amount,
-                    token: (0, tokens_1.getTokenDetails)(chainId, tokenAddress),
-                }));
-            };
-            return {
-                ...order,
-                orderDetails,
-                gasRefill: order.satsToConvertToEth,
-                baseToken: (0, tokens_1.getTokenDetails)(chainId, order.baseTokenAddress),
-                outputToken: order.outputTokenAddress ? (0, tokens_1.getTokenDetails)(chainId, order.outputTokenAddress) : undefined,
-                getTokenAddress,
-                getToken,
-                getTokenAmount,
-                getTokens,
-                getOutputTokens,
-                getConfirmations,
-                async getStatus(esploraClient, latestHeight) {
-                    const confirmations = await getConfirmations(esploraClient, latestHeight);
-                    const hasEnoughConfirmations = confirmations >= order.txProofDifficultyFactor;
-                    const data = { confirmations };
-                    if (!hasEnoughConfirmations) {
-                        return { confirmed: false, data };
-                    }
-                    return {
-                        success: !(order.strategyAddress && order.strategyFailed === true),
-                        data,
-                    };
-                },
-            };
-        });
-    }
-    async getStrategies() {
-        const response = await this.safeFetch(`${this.baseUrl}/strategies`, undefined, 'Failed to fetch gateway strategies');
-        const chainName = this.chain.name;
-        const chainId = this.chainId;
-        const strategies = await response.json();
-        return strategies.map((strategy) => {
-            const strategySlug = (0, utils_2.slugify)(strategy.strategyName);
-            const inputToken = (0, tokens_1.getTokenDetails)(chainId, strategy.inputTokenAddress);
-            if (!inputToken) {
-                throw new Error(`Token not found: ${strategy.inputTokenAddress} on chain ${chainId}`);
-            }
-            const outputToken = strategy.outputTokenAddress
-                ? (0, tokens_1.getTokenDetails)(chainId, strategy.outputTokenAddress)
-                : undefined;
-            return {
-                id: strategySlug,
-                type: 'deposit',
-                address: strategy.strategyAddress,
-                method: '',
-                chain: {
-                    id: '',
-                    chainId: chainId,
-                    slug: chainName,
-                    name: chainName,
-                    logo: '',
-                    type: 'evm',
-                    singleChainSwap: true,
-                    singleChainStaking: true,
-                },
-                integration: {
-                    type: strategy.strategyType,
-                    slug: strategySlug,
-                    name: strategy.strategyName,
-                    logo: strategy.projectLogo || outputToken?.logoURI || '',
-                    monetization: false,
-                },
-                inputToken: {
-                    symbol: inputToken.symbol,
-                    address: inputToken.address,
-                    logo: inputToken.logoURI,
-                    decimals: inputToken.decimals,
-                    chain: chainName,
-                },
-                outputToken: outputToken
-                    ? {
-                        symbol: outputToken.symbol,
-                        address: outputToken.address,
-                        logo: outputToken.logoURI,
-                        decimals: outputToken.decimals,
-                        chain: chainName,
-                    }
-                    : null,
-            };
-        });
-    }
-    async getTokenAddresses(includeStrategies = true) {
-        const response = await this.safeFetch(`${this.baseUrl}/tokens?includeStrategies=${includeStrategies}`, undefined, 'Failed to fetch supported token addresses');
-        if (!response.ok) {
-            const errorData = await response.json().catch(() => null);
-            const apiMessage = errorData?.message;
-            const errorMessage = apiMessage || 'Failed to fetch supported token addresses';
-            throw new Error(errorMessage);
-        }
-        return response.json();
-    }
-    async getTokens(includeStrategies = true) {
-        const tokens = await this.getTokenAddresses(includeStrategies);
-        return tokens.map((token) => (0, tokens_1.getTokenDetails)(this.chainId, token)).filter((token) => token !== undefined);
+    async getTokens() {
+        return this.api.getTokens();
     }
     async getPrices() {
         const response = await this.safeFetch('https://fusion-api.gobob.xyz/pricefeed', undefined, 'Failed to fetch prices from Fusion API');
@@ -840,8 +171,8 @@ class GatewayApiClient extends base_client_1.BaseClient {
         const list = await response.json();
         return new Map(list.map((x) => [x.token_address.toLowerCase(), Number(x.price)]));
     }
-    async getEnrichedTokens(includeStrategies = true) {
-        const [tokens, prices] = await Promise.all([this.getTokenAddresses(includeStrategies), this.getPrices()]);
+    async getEnrichedTokens() {
+        const [tokens, prices] = await Promise.all([this.getTokens(), this.getPrices()]);
         const tokensIncentives = await this.strategy.getTokensIncentives(tokens);
         return Promise.all(tokens.map(async (address, i) => {
             const token = (0, tokens_1.getTokenDetails)(this.chainId, address);
@@ -874,14 +205,13 @@ class GatewayApiClient extends base_client_1.BaseClient {
         }));
     }
     async getOrders(userAddress) {
-        const [onrampOrders, offrampOrders] = await Promise.all([
-            this.getOnrampOrders(userAddress),
-            this.getOfframpOrders(userAddress),
-        ]);
-        return [
-            ...onrampOrders.map((order) => ({ type: types_1.GatewayOrderType.Onramp, order })),
-            ...offrampOrders.map((order) => ({ type: types_1.GatewayOrderType.Offramp, order })),
-        ];
+        return this.api.getOrders({ userAddress: userAddress.toString() });
+    }
+    async getChains() {
+        return this.api.getChains();
+    }
+    async getRoutes() {
+        return this.api.getRoutes();
     }
 }
 exports.GatewayApiClient = GatewayApiClient;