@pioneer-platform/chainflip-client 0.0.2

package/lib/broker.d.ts

@@ -0,0 +1,15 @@
+import { type AssetValue, type GenericSwapParams } from "@swapkit/helpers";
+import type { ETHToolbox } from "@swapkit/toolbox-evm";
+import type { ChainflipToolbox } from "@swapkit/toolbox-substrate";
+import type { SwapDepositResponse, WithdrawFeeResponse } from "./types.ts";
+export declare const ChainflipBroker: (chainflipToolbox: Awaited<ReturnType<typeof ChainflipToolbox>>) => {
+    registerAsBroker: (address: string) => Promise<string | (() => void)>;
+    requestSwapDepositAddress: (chainflipTransaction: GenericSwapParams & {
+        brokerCommissionBPS: number;
+    }) => Promise<SwapDepositResponse>;
+    fundStateChainAccount: (stateChainAccount: string, amount: AssetValue, evmToolbox: ReturnType<typeof ETHToolbox>) => Promise<string>;
+    withdrawFee: (params: {
+        feeAsset: AssetValue;
+        recipient: string;
+    }) => Promise<WithdrawFeeResponse>;
+};

package/lib/broker.js

@@ -0,0 +1,128 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ChainflipBroker = void 0;
+const swap_1 = require("@chainflip/sdk/swap");
+const helpers_1 = require("@swapkit/helpers");
+const helpers_2 = require("@swapkit/helpers");
+const keyring_1 = require("@polkadot/keyring");
+const util_1 = require("@polkadot/util");
+const chainflipGatewayABI_ts_1 = require("./chainflipGatewayABI.ts");
+const chainToChainflipChain = new Map([
+    [helpers_2.Chain.Ethereum, swap_1.Chains.Ethereum],
+    [helpers_2.Chain.Bitcoin, swap_1.Chains.Bitcoin],
+    [helpers_2.Chain.Polkadot, swap_1.Chains.Polkadot],
+]);
+const registerAsBroker = (toolbox, address) => {
+    var _a, _b;
+    const extrinsic = (_b = (_a = toolbox.api.tx.swapping) === null || _a === void 0 ? void 0 : _a.registerAsBroker) === null || _b === void 0 ? void 0 : _b.call(_a, address);
+    if (!extrinsic) {
+        throw new Error("chainflip_broker_register");
+    }
+    return toolbox.signAndBroadcast(extrinsic);
+};
+const requestSwapDepositAddress = (toolbox, { sellAsset, buyAsset, recipient, brokerCommissionBPS, }) => __awaiter(void 0, void 0, void 0, function* () {
+    const isBuyChainPolkadot = buyAsset.chain === helpers_2.Chain.Polkadot;
+    const recipientAddress = (0, helpers_1.wrapWithThrow)(() => {
+        return isBuyChainPolkadot
+            ? toolbox.encodeAddress(toolbox.decodeAddress(recipient), "hex")
+            : recipient;
+    }, "chainflip_broker_recipient_error");
+    return new Promise((resolve) => {
+        var _a, _b;
+        const tx = (_b = (_a = toolbox.api.tx.swapping) === null || _a === void 0 ? void 0 : _a.requestSwapDepositAddress) === null || _b === void 0 ? void 0 : _b.call(_a, sellAsset.ticker.toLowerCase(), buyAsset.ticker.toLowerCase(), { [buyAsset.chain.toLowerCase()]: recipientAddress }, helpers_1.SwapKitNumber.fromBigInt(BigInt(brokerCommissionBPS)).getBaseValue("number"), null, 0);
+        if (!tx) {
+            throw new Error("chainflip_broker_tx_error");
+        }
+        toolbox.signAndBroadcast(tx, (result) => __awaiter(void 0, void 0, void 0, function* () {
+            var _c, _d, _e;
+            if (!((_c = result.status) === null || _c === void 0 ? void 0 : _c.isFinalized)) {
+                return;
+            }
+            const depositChannelEvent = result.events.find((event) => event.event.method === "SwapDepositAddressReady");
+            if (!depositChannelEvent) {
+                throw new helpers_1.SwapKitError("chainflip_channel_error", "Could not find 'SwapDepositAddressReady' event");
+            }
+            const { event: { data: { depositAddress, sourceChainExpiryBlock, destinationAddress, channelId }, }, } = depositChannelEvent.toHuman();
+            const hash = (_e = (_d = result.status) === null || _d === void 0 ? void 0 : _d.toJSON) === null || _e === void 0 ? void 0 : _e.call(_d);
+            const header = yield toolbox.api.rpc.chain.getHeader(hash === null || hash === void 0 ? void 0 : hash.finalized);
+            const depositChannelId = `${header.number}-${chainToChainflipChain.get(sellAsset.chain)}-${channelId.replaceAll(",", "")}`;
+            resolve({
+                brokerCommissionBPS,
+                buyAsset,
+                depositAddress: Object.values(depositAddress)[0],
+                depositChannelId,
+                recipient: Object.values(destinationAddress)[0],
+                sellAsset,
+                srcChainExpiryBlock: Number(sourceChainExpiryBlock.replaceAll(",", "")),
+            });
+        }));
+    });
+});
+const withdrawFee = (toolbox, { feeAsset, recipient }) => {
+    const isFeeChainPolkadot = feeAsset.chain === helpers_2.Chain.Polkadot;
+    const recipientAddress = (0, helpers_1.wrapWithThrow)(() => {
+        return isFeeChainPolkadot
+            ? toolbox.encodeAddress(toolbox.decodeAddress(recipient), "hex")
+            : recipient;
+    }, "chainflip_broker_recipient_error");
+    return new Promise((resolve) => {
+        var _a, _b, _c;
+        const extrinsic = (_c = (_b = (_a = toolbox.api.tx) === null || _a === void 0 ? void 0 : _a.swapping) === null || _b === void 0 ? void 0 : _b.withdraw) === null || _c === void 0 ? void 0 : _c.call(_b, feeAsset.ticker.toLowerCase(), {
+            [feeAsset.chain.toLowerCase()]: recipientAddress,
+        });
+        if (!extrinsic) {
+            throw new Error("chainflip_broker_withdraw");
+        }
+        toolbox.signAndBroadcast(extrinsic, (result) => __awaiter(void 0, void 0, void 0, function* () {
+            var _d;
+            if (!((_d = result.status) === null || _d === void 0 ? void 0 : _d.isFinalized)) {
+                return;
+            }
+            const withdrawEvent = result.events.find((event) => event.event.method === "WithdrawalRequested");
+            if (!withdrawEvent) {
+                throw new helpers_1.SwapKitError("chainflip_channel_error", "Could not find 'WithdrawalRequested' event");
+            }
+            const { event: { data: { egressId, egressAsset, egressAmount, egressFee, destinationAddress }, }, } = withdrawEvent.toHuman();
+            resolve({
+                egressId,
+                egressAsset,
+                egressAmount,
+                egressFee,
+                destinationAddress,
+            });
+        }));
+    });
+};
+const fundStateChainAccount = (evmToolbox, chainflipToolbox, stateChainAccount, amount) => {
+    if (amount.symbol !== "FLIP") {
+        throw new Error("Only FLIP is supported");
+    }
+    if (!chainflipToolbox.validateAddress(stateChainAccount)) {
+        throw new Error("Invalid address");
+    }
+    const hexAddress = (0, util_1.isHex)(stateChainAccount)
+        ? stateChainAccount
+        : (0, util_1.u8aToHex)((0, keyring_1.decodeAddress)(stateChainAccount));
+    return evmToolbox.call({
+        abi: chainflipGatewayABI_ts_1.chainflipGateway,
+        contractAddress: "0x6995ab7c4d7f4b03f467cf4c8e920427d9621dbd",
+        funcName: "fundStateChainAccount",
+        funcParams: [hexAddress, amount],
+    });
+};
+const ChainflipBroker = (chainflipToolbox) => ({
+    registerAsBroker: (address) => registerAsBroker(chainflipToolbox, address),
+    requestSwapDepositAddress: (chainflipTransaction) => requestSwapDepositAddress(chainflipToolbox, chainflipTransaction),
+    fundStateChainAccount: (stateChainAccount, amount, evmToolbox) => fundStateChainAccount(evmToolbox, chainflipToolbox, stateChainAccount, amount),
+    withdrawFee: (params) => withdrawFee(chainflipToolbox, params),
+});
+exports.ChainflipBroker = ChainflipBroker;

package/lib/chainflipGatewayABI.d.ts

@@ -0,0 +1,80 @@
+export declare const chainflipGateway: ({
+    inputs: {
+        internalType: string;
+        name: string;
+        type: string;
+    }[];
+    stateMutability: string;
+    type: string;
+    anonymous?: undefined;
+    name?: undefined;
+    outputs?: undefined;
+} | {
+    anonymous: boolean;
+    inputs: {
+        indexed: boolean;
+        internalType: string;
+        name: string;
+        type: string;
+    }[];
+    name: string;
+    type: string;
+    stateMutability?: undefined;
+    outputs?: undefined;
+} | {
+    inputs: {
+        internalType: string;
+        name: string;
+        type: string;
+    }[];
+    name: string;
+    outputs: {
+        internalType: string;
+        name: string;
+        type: string;
+    }[];
+    stateMutability: string;
+    type: string;
+    anonymous?: undefined;
+} | {
+    inputs: {
+        internalType: string;
+        name: string;
+        type: string;
+    }[];
+    name: string;
+    outputs: {
+        components: {
+            internalType: string;
+            name: string;
+            type: string;
+        }[];
+        internalType: string;
+        name: string;
+        type: string;
+    }[];
+    stateMutability: string;
+    type: string;
+    anonymous?: undefined;
+} | {
+    inputs: ({
+        components: {
+            internalType: string;
+            name: string;
+            type: string;
+        }[];
+        internalType: string;
+        name: string;
+        type: string;
+    } | {
+        internalType: string;
+        name: string;
+        type: string;
+        components?: undefined;
+    })[];
+    name: string;
+    outputs: never[];
+    stateMutability: string;
+    type: string;
+    anonymous?: undefined;
+})[];

package/lib/chainflipGatewayABI.js

@@ -0,0 +1,333 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.chainflipGateway = void 0;
+exports.chainflipGateway = [
+    {
+        inputs: [
+            { internalType: "contract IKeyManager", name: "keyManager", type: "address" },
+            { internalType: "uint256", name: "minFunding", type: "uint256" },
+            { internalType: "uint48", name: "redemptionDelay", type: "uint48" },
+        ],
+        stateMutability: "nonpayable",
+        type: "constructor",
+    },
+    {
+        anonymous: false,
+        inputs: [
+            { indexed: false, internalType: "bool", name: "communityGuardDisabled", type: "bool" },
+        ],
+        name: "CommunityGuardDisabled",
+        type: "event",
+    },
+    {
+        anonymous: false,
+        inputs: [{ indexed: false, internalType: "address", name: "flip", type: "address" }],
+        name: "FLIPSet",
+        type: "event",
+    },
+    {
+        anonymous: false,
+        inputs: [
+            { indexed: false, internalType: "uint256", name: "oldSupply", type: "uint256" },
+            { indexed: false, internalType: "uint256", name: "newSupply", type: "uint256" },
+            { indexed: false, internalType: "uint256", name: "stateChainBlockNumber", type: "uint256" },
+        ],
+        name: "FlipSupplyUpdated",
+        type: "event",
+    },
+    {
+        anonymous: false,
+        inputs: [
+            { indexed: true, internalType: "bytes32", name: "nodeID", type: "bytes32" },
+            { indexed: false, internalType: "uint256", name: "amount", type: "uint256" },
+            { indexed: false, internalType: "address", name: "funder", type: "address" },
+        ],
+        name: "Funded",
+        type: "event",
+    },
+    {
+        anonymous: false,
+        inputs: [
+            { indexed: false, internalType: "address", name: "to", type: "address" },
+            { indexed: false, internalType: "uint256", name: "amount", type: "uint256" },
+        ],
+        name: "GovernanceWithdrawal",
+        type: "event",
+    },
+    {
+        anonymous: false,
+        inputs: [
+            { indexed: false, internalType: "uint256", name: "oldMinFunding", type: "uint256" },
+            { indexed: false, internalType: "uint256", name: "newMinFunding", type: "uint256" },
+        ],
+        name: "MinFundingChanged",
+        type: "event",
+    },
+    {
+        anonymous: false,
+        inputs: [
+            { indexed: true, internalType: "bytes32", name: "nodeID", type: "bytes32" },
+            { indexed: false, internalType: "uint256", name: "amount", type: "uint256" },
+        ],
+        name: "RedemptionExecuted",
+        type: "event",
+    },
+    {
+        anonymous: false,
+        inputs: [
+            { indexed: true, internalType: "bytes32", name: "nodeID", type: "bytes32" },
+            { indexed: false, internalType: "uint256", name: "amount", type: "uint256" },
+        ],
+        name: "RedemptionExpired",
+        type: "event",
+    },
+    {
+        anonymous: false,
+        inputs: [
+            { indexed: true, internalType: "bytes32", name: "nodeID", type: "bytes32" },
+            { indexed: false, internalType: "uint256", name: "amount", type: "uint256" },
+            { indexed: true, internalType: "address", name: "redeemAddress", type: "address" },
+            { indexed: false, internalType: "uint48", name: "startTime", type: "uint48" },
+            { indexed: false, internalType: "uint48", name: "expiryTime", type: "uint48" },
+            { indexed: false, internalType: "address", name: "executor", type: "address" },
+        ],
+        name: "RedemptionRegistered",
+        type: "event",
+    },
+    {
+        anonymous: false,
+        inputs: [{ indexed: false, internalType: "bool", name: "suspended", type: "bool" }],
+        name: "Suspended",
+        type: "event",
+    },
+    {
+        anonymous: false,
+        inputs: [{ indexed: false, internalType: "address", name: "keyManager", type: "address" }],
+        name: "UpdatedKeyManager",
+        type: "event",
+    },
+    {
+        inputs: [],
+        name: "REDEMPTION_DELAY",
+        outputs: [{ internalType: "uint48", name: "", type: "uint48" }],
+        stateMutability: "view",
+        type: "function",
+    },
+    {
+        inputs: [],
+        name: "disableCommunityGuard",
+        outputs: [],
+        stateMutability: "nonpayable",
+        type: "function",
+    },
+    {
+        inputs: [],
+        name: "enableCommunityGuard",
+        outputs: [],
+        stateMutability: "nonpayable",
+        type: "function",
+    },
+    {
+        inputs: [{ internalType: "bytes32", name: "nodeID", type: "bytes32" }],
+        name: "executeRedemption",
+        outputs: [
+            { internalType: "address", name: "", type: "address" },
+            { internalType: "uint256", name: "", type: "uint256" },
+        ],
+        stateMutability: "nonpayable",
+        type: "function",
+    },
+    {
+        inputs: [
+            { internalType: "bytes32", name: "nodeID", type: "bytes32" },
+            { internalType: "uint256", name: "amount", type: "uint256" },
+        ],
+        name: "fundStateChainAccount",
+        outputs: [],
+        stateMutability: "nonpayable",
+        type: "function",
+    },
+    {
+        inputs: [],
+        name: "getCommunityGuardDisabled",
+        outputs: [{ internalType: "bool", name: "", type: "bool" }],
+        stateMutability: "view",
+        type: "function",
+    },
+    {
+        inputs: [],
+        name: "getCommunityKey",
+        outputs: [{ internalType: "address", name: "", type: "address" }],
+        stateMutability: "view",
+        type: "function",
+    },
+    {
+        inputs: [],
+        name: "getFLIP",
+        outputs: [{ internalType: "contract IFLIP", name: "", type: "address" }],
+        stateMutability: "view",
+        type: "function",
+    },
+    {
+        inputs: [],
+        name: "getGovernor",
+        outputs: [{ internalType: "address", name: "", type: "address" }],
+        stateMutability: "view",
+        type: "function",
+    },
+    {
+        inputs: [],
+        name: "getKeyManager",
+        outputs: [{ internalType: "contract IKeyManager", name: "", type: "address" }],
+        stateMutability: "view",
+        type: "function",
+    },
+    {
+        inputs: [],
+        name: "getLastSupplyUpdateBlockNumber",
+        outputs: [{ internalType: "uint256", name: "", type: "uint256" }],
+        stateMutability: "view",
+        type: "function",
+    },
+    {
+        inputs: [],
+        name: "getMinimumFunding",
+        outputs: [{ internalType: "uint256", name: "", type: "uint256" }],
+        stateMutability: "view",
+        type: "function",
+    },
+    {
+        inputs: [{ internalType: "bytes32", name: "nodeID", type: "bytes32" }],
+        name: "getPendingRedemption",
+        outputs: [
+            {
+                components: [
+                    { internalType: "uint256", name: "amount", type: "uint256" },
+                    { internalType: "address", name: "redeemAddress", type: "address" },
+                    { internalType: "uint48", name: "startTime", type: "uint48" },
+                    { internalType: "uint48", name: "expiryTime", type: "uint48" },
+                    { internalType: "address", name: "executor", type: "address" },
+                ],
+                internalType: "struct IStateChainGateway.Redemption",
+                name: "",
+                type: "tuple",
+            },
+        ],
+        stateMutability: "view",
+        type: "function",
+    },
+    {
+        inputs: [],
+        name: "getSuspendedState",
+        outputs: [{ internalType: "bool", name: "", type: "bool" }],
+        stateMutability: "view",
+        type: "function",
+    },
+    {
+        inputs: [],
+        name: "govUpdateFlipIssuer",
+        outputs: [],
+        stateMutability: "nonpayable",
+        type: "function",
+    },
+    { inputs: [], name: "govWithdraw", outputs: [], stateMutability: "nonpayable", type: "function" },
+    {
+        inputs: [
+            {
+                components: [
+                    { internalType: "uint256", name: "sig", type: "uint256" },
+                    { internalType: "uint256", name: "nonce", type: "uint256" },
+                    { internalType: "address", name: "kTimesGAddress", type: "address" },
+                ],
+                internalType: "struct IShared.SigData",
+                name: "sigData",
+                type: "tuple",
+            },
+            { internalType: "bytes32", name: "nodeID", type: "bytes32" },
+            { internalType: "uint256", name: "amount", type: "uint256" },
+            { internalType: "address", name: "redeemAddress", type: "address" },
+            { internalType: "uint48", name: "expiryTime", type: "uint48" },
+            { internalType: "address", name: "executor", type: "address" },
+        ],
+        name: "registerRedemption",
+        outputs: [],
+        stateMutability: "nonpayable",
+        type: "function",
+    },
+    { inputs: [], name: "resume", outputs: [], stateMutability: "nonpayable", type: "function" },
+    {
+        inputs: [{ internalType: "contract IFLIP", name: "flip", type: "address" }],
+        name: "setFlip",
+        outputs: [],
+        stateMutability: "nonpayable",
+        type: "function",
+    },
+    {
+        inputs: [{ internalType: "uint256", name: "newMinFunding", type: "uint256" }],
+        name: "setMinFunding",
+        outputs: [],
+        stateMutability: "nonpayable",
+        type: "function",
+    },
+    { inputs: [], name: "suspend", outputs: [], stateMutability: "nonpayable", type: "function" },
+    {
+        inputs: [
+            {
+                components: [
+                    { internalType: "uint256", name: "sig", type: "uint256" },
+                    { internalType: "uint256", name: "nonce", type: "uint256" },
+                    { internalType: "address", name: "kTimesGAddress", type: "address" },
+                ],
+                internalType: "struct IShared.SigData",
+                name: "sigData",
+                type: "tuple",
+            },
+            { internalType: "address", name: "newIssuer", type: "address" },
+            { internalType: "bool", name: "omitChecks", type: "bool" },
+        ],
+        name: "updateFlipIssuer",
+        outputs: [],
+        stateMutability: "nonpayable",
+        type: "function",
+    },
+    {
+        inputs: [
+            {
+                components: [
+                    { internalType: "uint256", name: "sig", type: "uint256" },
+                    { internalType: "uint256", name: "nonce", type: "uint256" },
+                    { internalType: "address", name: "kTimesGAddress", type: "address" },
+                ],
+                internalType: "struct IShared.SigData",
+                name: "sigData",
+                type: "tuple",
+            },
+            { internalType: "uint256", name: "newTotalSupply", type: "uint256" },
+            { internalType: "uint256", name: "stateChainBlockNumber", type: "uint256" },
+        ],
+        name: "updateFlipSupply",
+        outputs: [],
+        stateMutability: "nonpayable",
+        type: "function",
+    },
+    {
+        inputs: [
+            {
+                components: [
+                    { internalType: "uint256", name: "sig", type: "uint256" },
+                    { internalType: "uint256", name: "nonce", type: "uint256" },
+                    { internalType: "address", name: "kTimesGAddress", type: "address" },
+                ],
+                internalType: "struct IShared.SigData",
+                name: "sigData",
+                type: "tuple",
+            },
+            { internalType: "contract IKeyManager", name: "keyManager", type: "address" },
+            { internalType: "bool", name: "omitChecks", type: "bool" },
+        ],
+        name: "updateKeyManager",
+        outputs: [],
+        stateMutability: "nonpayable",
+        type: "function",
+    },
+];

package/lib/index.d.ts

@@ -0,0 +1 @@
+export {};

package/lib/index.js

@@ -0,0 +1,148 @@
+"use strict";
+/*
+       chainflip Integration
+                - Highlander
+                
+      Notes:
+      lol polkadot cant ts bro, https://substrate.stackexchange.com/questions/4542/typescript-errors-when-using-polkadot-api
+                
+ */
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const TAG = " | chainflip | ";
+const { uuid } = require('uuidv4');
+const log = require('@pioneer-platform/loggerdog')();
+let { caipToNetworkId, shortListSymbolToCaip, ChainToNetworkId } = require("@pioneer-platform/pioneer-caip");
+const { createMemo, parseMemo } = require('@pioneer-platform/pioneer-coins');
+const axios = require('axios');
+let networkSupport = [
+    ChainToNetworkId["BTC"],
+    ChainToNetworkId["ETH"],
+];
+module.exports = {
+    init: function (settings) {
+        return true;
+    },
+    networkSupport: function () {
+        return networkSupport;
+    },
+    getQuote: function (quote) {
+        return get_quote(quote);
+    },
+};
+const get_quote = function (quote) {
+    return __awaiter(this, void 0, void 0, function* () {
+        let tag = TAG + " | get_quote | ";
+        try {
+            let output = {};
+            output.steps = 1;
+            output.memoless = true;
+            output.complete = true;
+            output.meta = {
+                quoteMode: "CHANGELLY"
+            };
+            output.complete = true;
+            if (!quote.sellAsset)
+                throw new Error("missing sellAsset");
+            if (!quote.buyAsset)
+                throw new Error("missing buyAsset");
+            if (!quote.sellAmount)
+                throw new Error("missing sellAmount");
+            if (!quote.recipientAddress)
+                throw new Error("missing recipientAddress");
+            if (!quote.slippage)
+                throw new Error("missing slippage");
+            // let providerUrl = "wss://rpc.polkadot.io"
+            // const provider = new WsProvider(providerUrl);
+            // const api = await ApiPromise.create({ provider });
+            //https://chainflip-swap.chainflip.io/quote?amount=100000000&srcChain=Bitcoin&srcAsset=BTC&destChain=Ethereum&destAsset=ETH
+            //get quote
+            const responseQuote = yield axios.get('https://chainflip-swap.chainflip.io/quote', {
+                params: {
+                    amount: 100000000,
+                    srcChain: 'Bitcoin',
+                    srcAsset: 'BTC',
+                    destChain: 'Ethereum',
+                    destAsset: 'ETH'
+                }
+            });
+            // console.log(responseQuote.data); // Handle the response data as needed
+            //https://chainflip-swap.chainflip.io/trpc/openSwapDepositChannel?batch=1
+            const url = 'https://chainflip-swap.chainflip.io/trpc/openSwapDepositChannel?batch=1';
+            const data = {
+                "0": {
+                    "json": {
+                        "srcChain": "Ethereum",
+                        "destChain": "Bitcoin",
+                        "srcAsset": "ETH",
+                        "destAsset": "BTC",
+                        "amount": "20427368230548824399",
+                        "quote": responseQuote.data,
+                        "destAddress": "bc1qu3ghkz8788ysk7gqcvke5l0mr7skhgvpuk6dk4"
+                    }
+                }
+            };
+            const headers = {
+                'Accept': '*/*',
+                'Accept-Encoding': 'gzip, deflate, br, zstd',
+                'Accept-Language': 'en-US,en;q=0.9',
+                'Content-Type': 'application/json',
+                'Origin': 'https://swap.chainflip.io',
+                'Referer': 'https://swap.chainflip.io/',
+                'Sec-Ch-Ua': '"Google Chrome";v="123", "Not:A-Brand";v="8", "Chromium";v="123"',
+                'Sec-Ch-Ua-Mobile': '?0',
+                'Sec-Ch-Ua-Platform': '"macOS"',
+                'Sec-Fetch-Dest': 'empty',
+                'Sec-Fetch-Mode': 'cors',
+                'Sec-Fetch-Site': 'same-site',
+                'User-Agent': 'Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/123.0.0.0 Safari/537.36'
+            };
+            const response = yield axios.post(url, data, { headers });
+            // console.log(response); // Log the response data
+            // console.log(response.data); // Log the response data
+            // console.log(JSON.stringify(response.data)); // Log the response data
+            let result = response.data[0].result.data.json;
+            log.info(tag, "result: ", result);
+            output.id = result.id;
+            output.source = 'chainflip';
+            output.estimatedExpiryTime = result.estimatedExpiryTime;
+            output.amountOut = responseQuote.data.egressAmount;
+            console.log("caipToNetworkId(ChainToNetworkId[\"BTC\"]): ", caipToNetworkId(ChainToNetworkId["BTC"]));
+            console.log("caipToNetworkId(quote.sellAsset): ", caipToNetworkId(quote.sellAsset));
+            if (caipToNetworkId(quote.sellAsset) == caipToNetworkId(ChainToNetworkId["BTC"])) {
+                // Convert from satoshis to BTC
+                output.amountOut /= 1e8;
+            }
+            else if (caipToNetworkId(quote.sellAsset) == caipToNetworkId(ChainToNetworkId["ETH"])) {
+                // Convert from wei to ETH
+                output.amountOut /= 1e18;
+            }
+            else {
+                throw Error("Chain not supported!");
+            }
+            let tx = {
+                type: "transfer",
+                chain: caipToNetworkId(quote.sellAsset),
+                txParams: {
+                    address: result.depositAddress,
+                    amount: quote.sellAmount
+                }
+            };
+            output.txs = [tx];
+            output.raw = data;
+            return output;
+        }
+        catch (e) {
+            console.error(tag, "e: ", e);
+            throw e;
+        }
+    });
+};

package/lib/plugin.d.ts

@@ -0,0 +1,42 @@
+import { AssetValue, type BaseWallet } from "@swapkit/helpers";
+export declare function confirmSwap({ buyAsset, sellAsset, recipient, brokerEndpoint, }: {
+    buyAsset: AssetValue;
+    sellAsset: AssetValue;
+    recipient: string;
+    brokerEndpoint: string;
+}): Promise<{
+    channelId: string;
+    depositAddress: string;
+    chain: string;
+}>;
+export declare const ChainflipPlugin: {
+    readonly chainflip: {
+        readonly plugin: ({ wallets, config: { brokerEndpoint }, }: {
+            wallets: BaseWallet<{
+                [key: string]: NotWorth;
+            }>;
+            config: {
+                brokerEndpoint: string;
+            };
+        }) => {
+            swap: ({ recipient, ...rest }: SwapParams<"chainflip">) => Promise<string>;
+        };
+    };
+};
+/**
+ * @deprecated Use import { ChainflipPlugin } from "@swapkit/chainflip" instead
+ */
+export declare const ChainflipProvider: {
+    readonly chainflip: {
+        readonly plugin: ({ wallets, config: { brokerEndpoint }, }: {
+            wallets: BaseWallet<{
+                [key: string]: NotWorth;
+            }>;
+            config: {
+                brokerEndpoint: string;
+            };
+        }) => {
+            swap: ({ recipient, ...rest }: SwapParams<"chainflip">) => Promise<string>;
+        };
+    };
+};

package/lib/plugin.js

@@ -0,0 +1,83 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __rest = (this && this.__rest) || function (s, e) {
+    var t = {};
+    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
+        t[p] = s[p];
+    if (s != null && typeof Object.getOwnPropertySymbols === "function")
+        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
+            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
+                t[p[i]] = s[p[i]];
+        }
+    return t;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ChainflipProvider = exports.ChainflipPlugin = exports.confirmSwap = void 0;
+const helpers_1 = require("@swapkit/helpers");
+function confirmSwap({ buyAsset, sellAsset, recipient, brokerEndpoint, }) {
+    return __awaiter(this, void 0, void 0, function* () {
+        try {
+            const response = yield fetch(brokerEndpoint, {
+                method: "POST",
+                headers: { "Content-Type": "application/json" },
+                body: JSON.stringify({
+                    buyAsset: buyAsset.toString(),
+                    sellAsset: sellAsset.toString(),
+                    destinationAddress: recipient,
+                }),
+            }).then((res) => res.json());
+            return response;
+        }
+        catch (error) {
+            throw new helpers_1.SwapKitError("chainflip_channel_error", error);
+        }
+    });
+}
+exports.confirmSwap = confirmSwap;
+const plugin = ({ wallets, config: { brokerEndpoint }, }) => {
+    function swap(_a) {
+        var _b, _c;
+        var { recipient } = _a, rest = __rest(_a, ["recipient"]);
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!("route" in rest && ((_b = rest.route) === null || _b === void 0 ? void 0 : _b.buyAsset) && brokerEndpoint)) {
+                throw new helpers_1.SwapKitError("core_swap_invalid_params");
+            }
+            const { buyAsset: buyString, sellAsset: sellString, sellAmount } = rest.route;
+            if (!(sellString && buyString)) {
+                throw new helpers_1.SwapKitError("core_swap_asset_not_recognized");
+            }
+            const sellAsset = yield helpers_1.AssetValue.fromString(sellString);
+            if (!(wallets === null || wallets === void 0 ? void 0 : wallets[sellAsset.chain])) {
+                throw new helpers_1.SwapKitError("core_wallet_connection_not_found");
+            }
+            const buyAsset = yield helpers_1.AssetValue.fromString(buyString);
+            const assetValue = sellAsset.set(sellAmount);
+            const { depositAddress } = yield confirmSwap({
+                brokerEndpoint,
+                buyAsset,
+                recipient,
+                sellAsset,
+            });
+            const tx = yield wallets[sellAsset.chain].transfer({
+                assetValue,
+                from: (_c = wallets[sellAsset.chain]) === null || _c === void 0 ? void 0 : _c.address,
+                recipient: depositAddress,
+            });
+            return tx;
+        });
+    }
+    return { swap };
+};
+exports.ChainflipPlugin = { chainflip: { plugin } };
+/**
+ * @deprecated Use import { ChainflipPlugin } from "@swapkit/chainflip" instead
+ */
+exports.ChainflipProvider = exports.ChainflipPlugin;

package/lib/types.d.ts

@@ -0,0 +1,17 @@
+import type { AssetValue } from "@swapkit/helpers";
+export type WithdrawFeeResponse = {
+    egressId: string;
+    egressAsset: string;
+    egressAmount: string;
+    egressFee: string;
+    destinationAddress: string;
+};
+export type SwapDepositResponse = {
+    depositChannelId: string;
+    depositAddress: string;
+    srcChainExpiryBlock: number;
+    sellAsset: AssetValue;
+    buyAsset: AssetValue;
+    recipient: string;
+    brokerCommissionBPS: number;
+};

package/lib/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/package.json

@@ -0,0 +1,37 @@
+{
+  "name": "@pioneer-platform/chainflip-client",
+  "version": "0.0.2",
+  "main": "./lib/index.js",
+  "types": "./lib/index.d.ts",
+  "dependencies": {
+    "@pioneer-platform/loggerdog": "^8.3.1",
+    "@pioneer-platform/maya-network": "^8.3.7",
+    "@pioneer-platform/pioneer-caip": "^9.2.23",
+    "@pioneer-platform/pioneer-coins": "^9.2.13",
+    "@polkadot/api": "^10.13.1",
+    "axios": "^1.3.4",
+    "dotenv": "^8.2.0",
+    "ethers": "^6.12.0",
+    "uuidv4": "^6.2.13",
+    "web3": "1.10.3"
+  },
+  "scripts": {
+    "npm": "npm i",
+    "test": "npm run build && node __tests__/test-module.js",
+    "build": "tsc -p .",
+    "prepublish": "npm run build",
+    "refresh": "rm -rf ./node_modules ./package-lock.json && npm install"
+  },
+  "devDependencies": {
+    "@types/jest": "^25.2.3",
+    "@types/node": "^13.13.21",
+    "@types/source-map-support": "^0.5.3",
+    "jest": "^26.4.2",
+    "onchange": "^7.0.2",
+    "serve": "^11.3.2",
+    "ts-jest": "^29.0.5",
+    "typescript": "^5.0.2"
+  },
+  "gitHead": "a76012f6693a12181c4744e53e977a9eaeef0ed3",
+  "peerDependencies": {}
+}

package/tsconfig.json

@@ -0,0 +1,14 @@
+{
+  "compilerOptions": {
+    "target": "es2015",
+    "skipLibCheck": true,
+    "module": "commonjs",
+    "lib": ["es6", "es2015", "dom"],
+    "declaration": true,
+    "outDir": "lib",
+    "rootDir": "src",
+    "strict": true,
+    "types": ["node"],
+    "esModuleInterop": true
+  }
+}