rainbow-swap-sdk 1.0.0

package/dist/dexes/abstract/calculated-swap-route.interface.d.ts

@@ -0,0 +1,5 @@
+import { SwapRouteType } from '../../enums/swap-route-type.enum';
+export interface AbstractCalculatedSwapRoute<T extends SwapRouteType> {
+    type: T;
+    tonRoughFee: string;
+}

package/dist/dexes/abstract/calculated-swap-route.interface.js

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

package/dist/dexes/dedust/calculated-swap-route.interface.d.ts

@@ -0,0 +1,6 @@
+import { SwapRouteType } from '../../enums/swap-route-type.enum';
+import { RouteStepWithCalculation } from '../../interfaces/route-step-with-calculation.interface';
+import { AbstractCalculatedSwapRoute } from '../abstract/calculated-swap-route.interface';
+export interface DeDustCalculatedSwapRoute extends AbstractCalculatedSwapRoute<SwapRouteType.DeDust> {
+    route: RouteStepWithCalculation[];
+}

package/dist/dexes/dedust/calculated-swap-route.interface.js

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

package/dist/dexes/dedust/sdk.d.ts

@@ -0,0 +1,14 @@
+import { Address, Cell } from '@ton/core';
+export declare const DEDUST_FACTORY_ADDRESS = "EQBfBWT7X2BHg9tXAxzhz2aKiNTU1tpt5NsiK0uSDW_YAJ67";
+export interface SwapStep {
+    poolAddress: Address;
+    limit?: bigint;
+    next?: SwapStep;
+}
+export interface SwapParams {
+    deadline?: number;
+    recipientAddress?: Address | null;
+    referralAddress?: Address | null;
+    fulfillPayload?: Cell | null;
+    rejectPayload?: Cell | null;
+}

package/dist/dexes/dedust/sdk.js

@@ -0,0 +1,4 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DEDUST_FACTORY_ADDRESS = void 0;
+exports.DEDUST_FACTORY_ADDRESS = 'EQBfBWT7X2BHg9tXAxzhz2aKiNTU1tpt5NsiK0uSDW_YAJ67';

package/dist/dexes/dedust/transfer-params-pack.utils.d.ts

@@ -0,0 +1,16 @@
+import { Address, Cell } from '@ton/core';
+import { SwapParams, SwapStep } from './sdk';
+export declare const packTonSwap: (params: {
+    queryId: number;
+    inputAmount: bigint;
+    poolAddress: Address;
+    minOutputAmount: bigint;
+    nextSwapStep?: SwapStep;
+    swapParams?: SwapParams;
+}) => Cell;
+export declare const packJettonSwap: (params: {
+    poolAddress: Address;
+    minOutputAmount: bigint;
+    nextSwapStep?: SwapStep;
+    swapParams?: SwapParams;
+}) => Cell;

package/dist/dexes/dedust/transfer-params-pack.utils.js

@@ -0,0 +1,48 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.packJettonSwap = exports.packTonSwap = void 0;
+const shared_1 = require("@rnw-community/shared");
+const core_1 = require("@ton/core");
+var Operation;
+(function (Operation) {
+    Operation[Operation["TON_SWAP"] = 3926267997] = "TON_SWAP";
+    Operation[Operation["JETTON_SWAP"] = 3818968194] = "JETTON_SWAP";
+})(Operation || (Operation = {}));
+const packTonSwap = (params) => (0, core_1.beginCell)()
+    .storeUint(Operation.TON_SWAP, 32)
+    .storeUint(params.queryId, 64)
+    .storeCoins(params.inputAmount)
+    .storeAddress(params.poolAddress)
+    .storeUint(0, 1)
+    .storeCoins(params.minOutputAmount)
+    .storeMaybeRef(packNextSwapStep(params.nextSwapStep))
+    .storeRef(packSwapParams(params.swapParams))
+    .endCell();
+exports.packTonSwap = packTonSwap;
+const packJettonSwap = (params) => (0, core_1.beginCell)()
+    .storeUint(Operation.JETTON_SWAP, 32)
+    .storeAddress(params.poolAddress)
+    .storeUint(0, 1) // reserved
+    .storeCoins(params.minOutputAmount)
+    .storeMaybeRef(packNextSwapStep(params.nextSwapStep))
+    .storeRef(packSwapParams(params.swapParams))
+    .endCell();
+exports.packJettonSwap = packJettonSwap;
+const packNextSwapStep = (step) => {
+    if (!(0, shared_1.isDefined)(step)) {
+        return null;
+    }
+    return (0, core_1.beginCell)()
+        .storeAddress(step.poolAddress)
+        .storeUint(0, 1) // reserved
+        .storeCoins(step.limit ?? 0n)
+        .storeMaybeRef(packNextSwapStep(step.next))
+        .endCell();
+};
+const packSwapParams = (params = {}) => (0, core_1.beginCell)()
+    .storeUint(params.deadline ?? 0, 32)
+    .storeAddress(params.recipientAddress ?? null)
+    .storeAddress(params.referralAddress ?? null)
+    .storeMaybeRef(params.fulfillPayload)
+    .storeMaybeRef(params.rejectPayload)
+    .endCell();

package/dist/dexes/dedust/transfer-params.utils.d.ts

@@ -0,0 +1,7 @@
+import { Address } from '@ton/core';
+import { RouteStepWithCalculation } from '../../interfaces/route-step-with-calculation.interface';
+export declare const dedust_getTransferParams: (route: RouteStepWithCalculation[], queryId: number, gasAmount: bigint, senderAddress: Address, receiverAddress: Address, responseDestination: Address, slippageTolerance: string) => Promise<{
+    to: Address;
+    value: bigint;
+    body: import("@ton/core").Cell;
+}>;

package/dist/dexes/dedust/transfer-params.utils.js

@@ -0,0 +1,70 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.dedust_getTransferParams = void 0;
+const core_1 = require("@ton/core");
+const transfer_params_pack_utils_1 = require("./transfer-params-pack.utils");
+const vault_utils_1 = require("./vault.utils");
+const globals_1 = require("../../globals");
+const jetton_utils_1 = require("../../utils/jetton.utils");
+const slippage_tolerance_utils_1 = require("../shared/slippage-tolerance.utils");
+const createNextSwapStepPayload = (remainingRoute, slippageTolerance) => {
+    if (remainingRoute.length === 0) {
+        return undefined;
+    }
+    const routeStep = remainingRoute[0];
+    const poolAddress = core_1.Address.parse(routeStep.dexPairAddress);
+    const limit = (0, slippage_tolerance_utils_1.applySlippageTolerance)(routeStep.outputAssetAmount, slippageTolerance);
+    const next = createNextSwapStepPayload(remainingRoute.slice(1), slippageTolerance);
+    return {
+        poolAddress,
+        limit,
+        next
+    };
+};
+const dedust_getTransferParams = async (route, queryId, gasAmount, senderAddress, receiverAddress, responseDestination, slippageTolerance) => {
+    if (route.length === 0) {
+        throw new Error('Empty route');
+    }
+    const firstRouteStep = route[0];
+    const vaultAddress = await (0, vault_utils_1.dedust_getVaultAddress)(firstRouteStep.inputAssetAddress);
+    const poolAddress = core_1.Address.parse(firstRouteStep.dexPairAddress);
+    const minOutputAmount = (0, slippage_tolerance_utils_1.applySlippageTolerance)(firstRouteStep.outputAssetAmount, slippageTolerance);
+    const nextSwapStep = createNextSwapStepPayload(route.slice(1), slippageTolerance);
+    const swapParams = { recipientAddress: receiverAddress };
+    if (firstRouteStep.inputAssetAddress === globals_1.TON) {
+        return {
+            to: vaultAddress,
+            value: gasAmount + BigInt(firstRouteStep.inputAssetAmount),
+            body: (0, transfer_params_pack_utils_1.packTonSwap)({
+                queryId,
+                inputAmount: BigInt(firstRouteStep.inputAssetAmount),
+                poolAddress,
+                minOutputAmount,
+                nextSwapStep,
+                swapParams
+            })
+        };
+    }
+    else {
+        const inputJettonWalletAddress = await (0, jetton_utils_1.getJettonWalletAddress)(firstRouteStep.inputAssetAddress, senderAddress);
+        const jettonSwapPayload = (0, transfer_params_pack_utils_1.packJettonSwap)({
+            poolAddress,
+            minOutputAmount,
+            nextSwapStep,
+            swapParams
+        });
+        return {
+            to: inputJettonWalletAddress,
+            value: gasAmount + globals_1.JETTON_TRANSFER_GAS_AMOUNT,
+            body: (0, jetton_utils_1.getJettonTransferBody)({
+                queryId,
+                amount: BigInt(firstRouteStep.inputAssetAmount),
+                destination: vaultAddress,
+                responseDestination: responseDestination,
+                forwardTonAmount: gasAmount,
+                forwardPayload: jettonSwapPayload
+            })
+        };
+    }
+};
+exports.dedust_getTransferParams = dedust_getTransferParams;

package/dist/dexes/dedust/vault.utils.d.ts

@@ -0,0 +1,2 @@
+import { Address } from '@ton/core';
+export declare const dedust_getVaultAddress: (inputAssetAddress: string) => Promise<Address>;

package/dist/dexes/dedust/vault.utils.js

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.dedust_getVaultAddress = void 0;
+const core_1 = require("@ton/core");
+const sdk_1 = require("./sdk");
+const globals_1 = require("../../globals");
+var AssetType;
+(function (AssetType) {
+    AssetType[AssetType["TON"] = 0] = "TON";
+    AssetType[AssetType["JETTON"] = 1] = "JETTON";
+})(AssetType || (AssetType = {}));
+const getAssetCell = (assetAddress) => {
+    if (assetAddress === globals_1.TON) {
+        return (0, core_1.beginCell)().storeUint(AssetType.TON, 4).endCell();
+    }
+    const jettonAddress = core_1.Address.parse(assetAddress);
+    return (0, core_1.beginCell)()
+        .storeUint(AssetType.JETTON, 4)
+        .storeInt(jettonAddress.workChain, 8)
+        .storeBuffer(jettonAddress.hash)
+        .endCell();
+};
+const dedust_getVaultAddress = async (inputAssetAddress) => {
+    const assetCell = getAssetCell(inputAssetAddress);
+    const vaultAddressResponse = await globals_1.TON_CLIENT.runMethod(core_1.Address.parse(sdk_1.DEDUST_FACTORY_ADDRESS), 'get_vault_address', [{ type: 'slice', cell: assetCell }]);
+    return vaultAddressResponse.stack.readAddress();
+};
+exports.dedust_getVaultAddress = dedust_getVaultAddress;

package/dist/dexes/rainbow/calculated-swap-route.interface.d.ts

@@ -0,0 +1,7 @@
+import { SwapRouteType } from '../../enums/swap-route-type.enum';
+import { RouteStepWithCalculation } from '../../interfaces/route-step-with-calculation.interface';
+import { AbstractCalculatedSwapRoute } from '../abstract/calculated-swap-route.interface';
+export interface RainbowCalculatedSwapRoute extends AbstractCalculatedSwapRoute<SwapRouteType.Rainbow> {
+    firstChunk: RouteStepWithCalculation[];
+    secondChunk: RouteStepWithCalculation[];
+}

package/dist/dexes/rainbow/calculated-swap-route.interface.js

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

package/dist/dexes/rainbow/rainbow-wallet.contract.d.ts

@@ -0,0 +1,21 @@
+import { Address, Cell, Contract } from '@ton/core';
+export declare enum RainbowWalletOperation {
+    MAKE_A_SWAP = 430800,
+    WITHDRAW_TON = 430801,
+    WITHDRAW_JETTON = 430802
+}
+export declare class RainbowWalletContract implements Contract {
+    readonly address: Address;
+    readonly init?: {
+        code: Cell;
+        data: Cell;
+    } | undefined;
+    constructor(address: Address, init?: {
+        code: Cell;
+        data: Cell;
+    } | undefined);
+    static create: (args: {
+        workchain: number;
+        ownerAddress: Address;
+    }) => RainbowWalletContract;
+}

package/dist/dexes/rainbow/rainbow-wallet.contract.js

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RainbowWalletContract = exports.RainbowWalletOperation = void 0;
+const core_1 = require("@ton/core");
+const boc_utils_1 = require("../../utils/boc.utils");
+const CODE_BOC = 'te6ccgECEAEAAvsAART/APSkE/S88sgLAQIBYgIDAgLOBAUCAVgODwIBIAYHABlPhCyPhBzxb0AMntVIAu07aLt+zIhxwCRW+DwAQHTH9M/IoIQ1TJ227qOHzBsEgHIyx/LP8lxgBjIywX4Qc8WcPoCy2rMyYBA+wDgIoQfuo4fMGwSAcjLH8s/yXGAGMjLBfhBzxZw+gLLaszJgED7AOAD0NMDMfpAMPhBIccF4w+BImDy8IAgJAB07UTQ+kAB+GH0BAH4YtGAB/jAhgggGktC6jjkxAfpA1PpA1DCBAUvIUAPPFhXLP8nQBND4QkUDBfQS+GLwAnGAGMjLBVjPFnD6AstqzMmAQPsA2zHgIYIIBpLRuo4rMQH6ADCCENUydtvIyx8Syz/JcYAYyMsF+EHPFlAD+gISy2rMyYBA+wDbMeABgggGktIKAsgighBzYtCcuo7MMgL6APpA+EEixwWOPWwx9AQw0PpA1PpA1DCBAUvIUAPPFhXLP8nQBND4QkUDBfQS+GLwAnGAGMjLBVjPFnD6AstqzMmAQPsA2zHgMOAwMiCCEEdPhs+64wJbCwwAjLqOQQH6QPoAMG1tghAPin6lyMsfFcs/WPoC+EHPFvhBzxYT9ABw+gIS9ADJcYAYyMsFUAPPFnD6AhLLaszJgED7ANsx4FsBroEBS8hYzxZSQMs/ydD4QlRhMfQKb6GOO18DbW2CEA+KfqXIyx8Vyz9Y+gL4Qc8W+EHPFhP0AHD6AhL0AMlxgBjIywVQA88WcPoCEstqzMmAQPsA4w3bMQ0APgEByMsfyz/JcYAYyMsF+EHPFnD6AstqzMmAQPsA2zEA1jQD+kBAUwLTANQw0CHAAI4UMYIQD4p+pcjLHxLLP1j6AgHPFsmOIgHAAY4TghDqBhhdyMsfEss/WPoCAc8WyeBfA4EiYfLwyMnicYAYyMsFUAXPFnD6AhTLahPMyYBA+wD4Qlj0WTD4YvACABG6Xk8AH4QfhCgAL7tBPwAYEBS8hQA88Wyz/J0PhCWPQKb6GA==';
+var RainbowWalletOperation;
+(function (RainbowWalletOperation) {
+    RainbowWalletOperation[RainbowWalletOperation["MAKE_A_SWAP"] = 430800] = "MAKE_A_SWAP";
+    RainbowWalletOperation[RainbowWalletOperation["WITHDRAW_TON"] = 430801] = "WITHDRAW_TON";
+    RainbowWalletOperation[RainbowWalletOperation["WITHDRAW_JETTON"] = 430802] = "WITHDRAW_JETTON";
+})(RainbowWalletOperation || (exports.RainbowWalletOperation = RainbowWalletOperation = {}));
+const storageToCell = (storage) => (0, core_1.beginCell)()
+    .storeAddress(storage.ownerAddress)
+    .storeDict(storage.effectsDict)
+    .endCell();
+class RainbowWalletContract {
+    constructor(address, init) {
+        this.address = address;
+        this.init = init;
+    }
+}
+exports.RainbowWalletContract = RainbowWalletContract;
+RainbowWalletContract.create = (args) => {
+    const code = (0, boc_utils_1.bocToCell)(CODE_BOC);
+    const data = storageToCell({
+        ownerAddress: args.ownerAddress,
+        effectsDict: core_1.Dictionary.empty()
+    });
+    const init = { code, data };
+    return new RainbowWalletContract((0, core_1.contractAddress)(args.workchain, init), init);
+};

package/dist/dexes/rainbow/transfer-params-pack.utils.d.ts

@@ -0,0 +1,29 @@
+import { Address, Cell } from '@ton/core';
+import { RouteStepWithCalculation } from '../../interfaces/route-step-with-calculation.interface';
+export declare const packTonSwap: (params: {
+    queryId: number;
+    destination: Address;
+    body: Cell;
+    jettonSenderAddressToListen: Address;
+    jettonReceiveEffect: Cell;
+}) => Cell;
+export declare const packJettonSwap: (params: {
+    destination: Address;
+    body: Cell;
+    jettonSenderAddressToListen: Address;
+    jettonReceiveEffect: Cell;
+}) => Cell;
+export declare enum EffectType {
+    JettonTransfer = 0,
+    DedustTonSwap = 1
+}
+export declare const packJettonReceiveEffect: (params: {
+    destination: Address;
+    effectType: EffectType;
+    fullBody: Cell;
+}) => Cell;
+export declare const getDexTransferParams: (route: RouteStepWithCalculation[], queryId: number, gasAmount: bigint, senderAddress: Address, receiverAddress: Address, responseDestination: Address, slippageTolerance: string) => Promise<{
+    to: Address;
+    value: bigint;
+    body: Cell;
+}>;

package/dist/dexes/rainbow/transfer-params-pack.utils.js

@@ -0,0 +1,55 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getDexTransferParams = exports.packJettonReceiveEffect = exports.EffectType = exports.packJettonSwap = exports.packTonSwap = void 0;
+const core_1 = require("@ton/core");
+const rainbow_wallet_contract_1 = require("./rainbow-wallet.contract");
+const dex_type_enum_1 = require("../../enums/dex-type.enum");
+const transfer_params_utils_1 = require("../dedust/transfer-params.utils");
+const transfer_params_utils_2 = require("../ston/transfer-params.utils");
+const packTonSwap = (params) => (0, core_1.beginCell)()
+    .storeUint(rainbow_wallet_contract_1.RainbowWalletOperation.MAKE_A_SWAP, 32)
+    .storeUint(params.queryId, 64)
+    .storeAddress(params.destination)
+    .storeRef(params.body)
+    .storeAddress(params.jettonSenderAddressToListen)
+    .storeRef(params.jettonReceiveEffect)
+    .endCell();
+exports.packTonSwap = packTonSwap;
+const packJettonSwap = (params) => (0, core_1.beginCell)()
+    .storeAddress(params.destination)
+    .storeRef(params.body)
+    .storeAddress(params.jettonSenderAddressToListen)
+    .storeRef(params.jettonReceiveEffect)
+    .endCell();
+exports.packJettonSwap = packJettonSwap;
+var EffectType;
+(function (EffectType) {
+    EffectType[EffectType["JettonTransfer"] = 0] = "JettonTransfer";
+    EffectType[EffectType["DedustTonSwap"] = 1] = "DedustTonSwap";
+})(EffectType || (exports.EffectType = EffectType = {}));
+const packJettonReceiveEffect = (params) => {
+    const slice = params.fullBody.beginParse();
+    slice.loadUint(32); // op
+    slice.loadUint(64); // queryId
+    slice.loadCoins(); // amount
+    return (0, core_1.beginCell)()
+        .storeAddress(params.destination)
+        .storeUint(params.effectType, 1)
+        .storeRef(slice.asCell())
+        .endCell();
+};
+exports.packJettonReceiveEffect = packJettonReceiveEffect;
+const getDexTransferParams = (route, queryId, gasAmount, senderAddress, receiverAddress, responseDestination, slippageTolerance) => {
+    const dexType = route[0].dexType;
+    if (dexType === dex_type_enum_1.DexTypeEnum.DeDust) {
+        return (0, transfer_params_utils_1.dedust_getTransferParams)(route, queryId, gasAmount, senderAddress, receiverAddress, responseDestination, slippageTolerance);
+    }
+    if (dexType === dex_type_enum_1.DexTypeEnum.Ston) {
+        if (route.length !== 1) {
+            throw new Error(`Not supported Ston route.length ${route.length}`);
+        }
+        return (0, transfer_params_utils_2.ston_getTransferParams)(route[0], queryId, gasAmount, senderAddress, receiverAddress, responseDestination, slippageTolerance);
+    }
+    throw new Error(`Not supported dexType ${dexType}`);
+};
+exports.getDexTransferParams = getDexTransferParams;

package/dist/dexes/rainbow/transfer-params.utils.d.ts

@@ -0,0 +1,4 @@
+import { Address } from '@ton/core';
+import { RouteStepWithCalculation } from '../../interfaces/route-step-with-calculation.interface';
+import { TransferParams } from '../../interfaces/transfer-params.interface';
+export declare const rainbow_getTransferParams: (firstChunk: RouteStepWithCalculation[], secondChunk: RouteStepWithCalculation[], queryId: number, gasAmount: bigint, senderAddress: Address, slippageTolerance: string) => Promise<TransferParams>;

package/dist/dexes/rainbow/transfer-params.utils.js

@@ -0,0 +1,73 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.rainbow_getTransferParams = void 0;
+const rainbow_wallet_contract_1 = require("./rainbow-wallet.contract");
+const transfer_params_pack_utils_1 = require("./transfer-params-pack.utils");
+const dex_type_enum_1 = require("../../enums/dex-type.enum");
+const globals_1 = require("../../globals");
+const jetton_utils_1 = require("../../utils/jetton.utils");
+const vault_utils_1 = require("../dedust/vault.utils");
+const sdk_1 = require("../ston/sdk");
+const rainbow_getTransferParams = async (firstChunk, secondChunk, queryId, gasAmount, senderAddress, slippageTolerance) => {
+    const rainbowWallet = rainbow_wallet_contract_1.RainbowWalletContract.create({
+        workchain: globals_1.WORKCHAIN,
+        ownerAddress: senderAddress
+    });
+    const inputAssetAddress = firstChunk[0].inputAssetAddress;
+    const secondChunk_transferParams = await (0, transfer_params_pack_utils_1.getDexTransferParams)(secondChunk, queryId, gasAmount, rainbowWallet.address, senderAddress, senderAddress, slippageTolerance);
+    const jettonSenderAddressToListen = firstChunk[0].dexType === dex_type_enum_1.DexTypeEnum.Ston
+        ? sdk_1.STON_ROUTER_ADDRESS
+        : await (0, vault_utils_1.dedust_getVaultAddress)(firstChunk[firstChunk.length - 1].outputAssetAddress);
+    const jettonReceiveEffectType = secondChunk[0].dexType === dex_type_enum_1.DexTypeEnum.DeDust &&
+        secondChunk[0].inputAssetAddress === globals_1.TON
+        ? transfer_params_pack_utils_1.EffectType.DedustTonSwap
+        : transfer_params_pack_utils_1.EffectType.JettonTransfer;
+    const jettonReceiveEffectGasAmount = jettonReceiveEffectType === transfer_params_pack_utils_1.EffectType.DedustTonSwap
+        ? 2n * globals_1.JETTON_TRANSFER_GAS_AMOUNT
+        : 3n * globals_1.JETTON_TRANSFER_GAS_AMOUNT;
+    const jettonReceiveEffect = (0, transfer_params_pack_utils_1.packJettonReceiveEffect)({
+        effectType: jettonReceiveEffectType,
+        destination: secondChunk_transferParams.to,
+        fullBody: secondChunk_transferParams.body
+    });
+    const tweakedSlippageTolerance = firstChunk[0].dexType === dex_type_enum_1.DexTypeEnum.Ston &&
+        firstChunk[0].inputAssetAmount !== globals_1.TON
+        ? '100' // We could not handle Ston.fi returned jettons
+        : slippageTolerance;
+    const firstChunk_transferParams = await (0, transfer_params_pack_utils_1.getDexTransferParams)(firstChunk, queryId, gasAmount + jettonReceiveEffectGasAmount, rainbowWallet.address, rainbowWallet.address, senderAddress, tweakedSlippageTolerance);
+    if (inputAssetAddress === globals_1.TON) {
+        return {
+            to: rainbowWallet.address,
+            value: firstChunk_transferParams.value,
+            body: (0, transfer_params_pack_utils_1.packTonSwap)({
+                queryId,
+                destination: firstChunk_transferParams.to,
+                body: firstChunk_transferParams.body,
+                jettonSenderAddressToListen,
+                jettonReceiveEffect
+            })
+        };
+    }
+    else {
+        const inputJettonWalletAddress = await (0, jetton_utils_1.getJettonWalletAddress)(inputAssetAddress, senderAddress);
+        const jettonSwapPayload = (0, transfer_params_pack_utils_1.packJettonSwap)({
+            destination: firstChunk_transferParams.to,
+            body: firstChunk_transferParams.body,
+            jettonSenderAddressToListen,
+            jettonReceiveEffect
+        });
+        return {
+            to: inputJettonWalletAddress,
+            value: firstChunk_transferParams.value + globals_1.JETTON_TRANSFER_GAS_AMOUNT,
+            body: (0, jetton_utils_1.getJettonTransferBody)({
+                queryId,
+                amount: BigInt(firstChunk[0].inputAssetAmount),
+                destination: rainbowWallet.address,
+                responseDestination: senderAddress,
+                forwardTonAmount: firstChunk_transferParams.value,
+                forwardPayload: jettonSwapPayload
+            })
+        };
+    }
+};
+exports.rainbow_getTransferParams = rainbow_getTransferParams;

package/dist/dexes/shared/slippage-tolerance.utils.d.ts

@@ -0,0 +1 @@
+export declare const applySlippageTolerance: (amount: string, slippageTolerance: string) => bigint;

package/dist/dexes/shared/slippage-tolerance.utils.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.applySlippageTolerance = void 0;
+const applySlippageTolerance = (amount, slippageTolerance) => {
+    const decimals = slippageTolerance.split('.')[1]?.length || 0;
+    const multiplier = BigInt(10 ** decimals);
+    return ((BigInt(amount) *
+        BigInt(Math.floor((100 - parseFloat(slippageTolerance)) * Number(multiplier)))) /
+        (BigInt(100) * multiplier));
+};
+exports.applySlippageTolerance = applySlippageTolerance;

package/dist/dexes/shared/transfer-params.utils.d.ts

@@ -0,0 +1,9 @@
+import { Address } from '@ton/core';
+import { TransferParams } from '../../interfaces/transfer-params.interface';
+import { CalculatedSwapRoute } from '../../types/calculated-swap-route.type';
+export declare const getSwapRouteTransferParams: (swapRoute: CalculatedSwapRoute, senderAddress: Address, slippageTolerance: string) => Promise<{
+    to: Address;
+    value: bigint;
+    body: import("@ton/core").Cell;
+}> | Promise<TransferParams>;
+export declare const getRainbowWalletActivationTransferParams: (senderAddress: Address) => TransferParams;

package/dist/dexes/shared/transfer-params.utils.js

@@ -0,0 +1,34 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getRainbowWalletActivationTransferParams = exports.getSwapRouteTransferParams = void 0;
+const core_1 = require("@ton/core");
+const swap_route_type_enum_1 = require("../../enums/swap-route-type.enum");
+const globals_1 = require("../../globals");
+const transfer_params_utils_1 = require("../../utils/transfer-params.utils");
+const transfer_params_utils_2 = require("../dedust/transfer-params.utils");
+const rainbow_wallet_contract_1 = require("../rainbow/rainbow-wallet.contract");
+const transfer_params_utils_3 = require("../rainbow/transfer-params.utils");
+const transfer_params_utils_4 = require("../ston/transfer-params.utils");
+const getSwapRouteTransferParams = (swapRoute, senderAddress, slippageTolerance) => {
+    const queryId = (0, transfer_params_utils_1.getQueryId)();
+    if (swapRoute.type === swap_route_type_enum_1.SwapRouteType.DeDust) {
+        return (0, transfer_params_utils_2.dedust_getTransferParams)(swapRoute.route, queryId, globals_1.GAS_AMOUNT, senderAddress, senderAddress, senderAddress, slippageTolerance);
+    }
+    if (swapRoute.type === swap_route_type_enum_1.SwapRouteType.Ston) {
+        return (0, transfer_params_utils_4.ston_getTransferParams)(swapRoute.routeStep, queryId, globals_1.GAS_AMOUNT, senderAddress, senderAddress, senderAddress, slippageTolerance);
+    }
+    return (0, transfer_params_utils_3.rainbow_getTransferParams)(swapRoute.firstChunk, swapRoute.secondChunk, queryId, globals_1.GAS_AMOUNT, senderAddress, slippageTolerance);
+};
+exports.getSwapRouteTransferParams = getSwapRouteTransferParams;
+const getRainbowWalletActivationTransferParams = (senderAddress) => {
+    const rainbowWallet = rainbow_wallet_contract_1.RainbowWalletContract.create({
+        workchain: globals_1.WORKCHAIN,
+        ownerAddress: senderAddress
+    });
+    return {
+        to: rainbowWallet.address,
+        value: (0, core_1.toNano)('0.01'),
+        init: rainbowWallet.init
+    };
+};
+exports.getRainbowWalletActivationTransferParams = getRainbowWalletActivationTransferParams;

package/dist/dexes/ston/calculated-swap-route.interface.d.ts

@@ -0,0 +1,6 @@
+import { SwapRouteType } from '../../enums/swap-route-type.enum';
+import { RouteStepWithCalculation } from '../../interfaces/route-step-with-calculation.interface';
+import { AbstractCalculatedSwapRoute } from '../abstract/calculated-swap-route.interface';
+export interface StonCalculatedSwapRoute extends AbstractCalculatedSwapRoute<SwapRouteType.Ston> {
+    routeStep: RouteStepWithCalculation;
+}

package/dist/dexes/ston/calculated-swap-route.interface.js

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

package/dist/dexes/ston/sdk.d.ts

@@ -0,0 +1,3 @@
+import { Address } from '@ton/core';
+export declare const STON_ROUTER_ADDRESS: Address;
+export declare const PROXY_TON_MASTER_ADDRESS = "EQCM3B12QK1e4yZSf8GtBRT0aLMNyEsBc_DhVfRRtOEffLez";

package/dist/dexes/ston/sdk.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PROXY_TON_MASTER_ADDRESS = exports.STON_ROUTER_ADDRESS = void 0;
+const core_1 = require("@ton/core");
+exports.STON_ROUTER_ADDRESS = core_1.Address.parse('EQB3ncyBUTjZUA5EnFKR5_EnOMI9V1tTEAAPaiU71gc4TiUt');
+exports.PROXY_TON_MASTER_ADDRESS = 'EQCM3B12QK1e4yZSf8GtBRT0aLMNyEsBc_DhVfRRtOEffLez';

package/dist/dexes/ston/transfer-params-pack.utils.d.ts

@@ -0,0 +1,8 @@
+import { Address } from '@ton/core';
+interface SwapParams {
+    outputJettonWalletAddress: Address;
+    minOutputAmount: bigint;
+    receiverAddress: Address;
+}
+export declare const packSwapParams: ({ outputJettonWalletAddress, minOutputAmount, receiverAddress }: SwapParams) => import("@ton/core").Cell;
+export {};

package/dist/dexes/ston/transfer-params-pack.utils.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.packSwapParams = void 0;
+const core_1 = require("@ton/core");
+var Operation;
+(function (Operation) {
+    Operation[Operation["SWAP"] = 630424929] = "SWAP";
+})(Operation || (Operation = {}));
+const packSwapParams = ({ outputJettonWalletAddress, minOutputAmount, receiverAddress }) => (0, core_1.beginCell)()
+    .storeUint(Operation.SWAP, 32)
+    .storeAddress(outputJettonWalletAddress)
+    .storeCoins(minOutputAmount)
+    .storeAddress(receiverAddress)
+    .storeUint(0, 1) // no referralAddress
+    .endCell();
+exports.packSwapParams = packSwapParams;

package/dist/dexes/ston/transfer-params.utils.d.ts

@@ -0,0 +1,7 @@
+import { Address } from '@ton/core';
+import { RouteStepWithCalculation } from '../../interfaces/route-step-with-calculation.interface';
+export declare const ston_getTransferParams: (routeStep: RouteStepWithCalculation, queryId: number, gasAmount: bigint, senderAddress: Address, receiverAddress: Address, responseDestination: Address, slippageTolerance: string) => Promise<{
+    to: Address;
+    value: bigint;
+    body: import("@ton/core").Cell;
+}>;

package/dist/dexes/ston/transfer-params.utils.js

@@ -0,0 +1,56 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ston_getTransferParams = void 0;
+const sdk_1 = require("./sdk");
+const transfer_params_pack_utils_1 = require("./transfer-params-pack.utils");
+const globals_1 = require("../../globals");
+const jetton_utils_1 = require("../../utils/jetton.utils");
+const slippage_tolerance_utils_1 = require("../shared/slippage-tolerance.utils");
+const ston_getTransferParams = async (routeStep, queryId, gasAmount, senderAddress, receiverAddress, responseDestination, slippageTolerance) => {
+    const minOutputAmount = (0, slippage_tolerance_utils_1.applySlippageTolerance)(routeStep.outputAssetAmount, slippageTolerance);
+    if (routeStep.inputAssetAddress === globals_1.TON) {
+        const stonRouterProxyTonWalletAddress = await (0, jetton_utils_1.getJettonWalletAddress)(sdk_1.PROXY_TON_MASTER_ADDRESS, sdk_1.STON_ROUTER_ADDRESS);
+        const stonRouterOutputJettonWalletAddress = await (0, jetton_utils_1.getJettonWalletAddress)(routeStep.outputAssetAddress, sdk_1.STON_ROUTER_ADDRESS);
+        const tonSwapPayload = (0, transfer_params_pack_utils_1.packSwapParams)({
+            outputJettonWalletAddress: stonRouterOutputJettonWalletAddress,
+            minOutputAmount,
+            receiverAddress
+        });
+        return {
+            to: stonRouterProxyTonWalletAddress,
+            value: gasAmount + BigInt(routeStep.inputAssetAmount),
+            body: (0, jetton_utils_1.getJettonTransferBody)({
+                queryId,
+                amount: BigInt(routeStep.inputAssetAmount),
+                destination: sdk_1.STON_ROUTER_ADDRESS,
+                responseDestination: responseDestination,
+                forwardTonAmount: gasAmount,
+                forwardPayload: tonSwapPayload
+            })
+        };
+    }
+    else {
+        const inputJettonWalletAddress = await (0, jetton_utils_1.getJettonWalletAddress)(routeStep.inputAssetAddress, senderAddress);
+        const outputJettonWalletAddress = await (0, jetton_utils_1.getJettonWalletAddress)(routeStep.outputAssetAddress === globals_1.TON
+            ? sdk_1.PROXY_TON_MASTER_ADDRESS
+            : routeStep.outputAssetAddress, sdk_1.STON_ROUTER_ADDRESS);
+        const jettonSwapPayload = (0, transfer_params_pack_utils_1.packSwapParams)({
+            outputJettonWalletAddress,
+            minOutputAmount,
+            receiverAddress
+        });
+        return {
+            to: inputJettonWalletAddress,
+            value: gasAmount + globals_1.JETTON_TRANSFER_GAS_AMOUNT,
+            body: (0, jetton_utils_1.getJettonTransferBody)({
+                queryId,
+                amount: BigInt(routeStep.inputAssetAmount),
+                destination: sdk_1.STON_ROUTER_ADDRESS,
+                responseDestination: responseDestination,
+                forwardTonAmount: gasAmount,
+                forwardPayload: jettonSwapPayload
+            })
+        };
+    }
+};
+exports.ston_getTransferParams = ston_getTransferParams;

package/dist/enums/dex-type.enum.d.ts

@@ -0,0 +1,5 @@
+export declare enum DexTypeEnum {
+    DeDust = "DeDust",
+    Ston = "Ston",
+    DeDustStable = "DeDustStable"
+}

package/dist/enums/dex-type.enum.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DexTypeEnum = void 0;
+var DexTypeEnum;
+(function (DexTypeEnum) {
+    DexTypeEnum["DeDust"] = "DeDust";
+    DexTypeEnum["Ston"] = "Ston";
+    DexTypeEnum["DeDustStable"] = "DeDustStable";
+})(DexTypeEnum || (exports.DexTypeEnum = DexTypeEnum = {}));

package/dist/enums/route-direction.enum.d.ts

@@ -0,0 +1,4 @@
+export declare enum RouteDirectionEnum {
+    Direct = "Direct",
+    Inverted = "Inverted"
+}

package/dist/enums/route-direction.enum.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RouteDirectionEnum = void 0;
+var RouteDirectionEnum;
+(function (RouteDirectionEnum) {
+    RouteDirectionEnum["Direct"] = "Direct";
+    RouteDirectionEnum["Inverted"] = "Inverted";
+})(RouteDirectionEnum || (exports.RouteDirectionEnum = RouteDirectionEnum = {}));

package/dist/enums/swap-route-type.enum.d.ts

@@ -0,0 +1,5 @@
+export declare enum SwapRouteType {
+    DeDust = "DeDust",
+    Ston = "Ston",
+    Rainbow = "Rainbow"
+}

package/dist/enums/swap-route-type.enum.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SwapRouteType = void 0;
+var SwapRouteType;
+(function (SwapRouteType) {
+    SwapRouteType["DeDust"] = "DeDust";
+    SwapRouteType["Ston"] = "Ston";
+    SwapRouteType["Rainbow"] = "Rainbow";
+})(SwapRouteType || (exports.SwapRouteType = SwapRouteType = {}));

package/dist/globals.d.ts

@@ -0,0 +1,7 @@
+import { TonClient } from '@ton/ton';
+export declare const TON = "ton";
+export declare const WORKCHAIN = 0;
+export declare const API: import("axios").AxiosInstance;
+export declare const TON_CLIENT: TonClient;
+export declare const GAS_AMOUNT: bigint;
+export declare const JETTON_TRANSFER_GAS_AMOUNT: bigint;

package/dist/globals.js

@@ -0,0 +1,19 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.JETTON_TRANSFER_GAS_AMOUNT = exports.GAS_AMOUNT = exports.TON_CLIENT = exports.API = exports.WORKCHAIN = exports.TON = void 0;
+const core_1 = require("@ton/core");
+const ton_1 = require("@ton/ton");
+const axios_1 = __importDefault(require("axios"));
+exports.TON = 'ton';
+exports.WORKCHAIN = 0;
+exports.API = axios_1.default.create({
+    baseURL: 'https://api.blackbot.technology/rainbow/api'
+});
+exports.TON_CLIENT = new ton_1.TonClient({
+    endpoint: `https://api.blackbot.technology/ton-http-api/jsonRPC`
+});
+exports.GAS_AMOUNT = (0, core_1.toNano)('0.255');
+exports.JETTON_TRANSFER_GAS_AMOUNT = (0, core_1.toNano)('0.065');

package/dist/index.d.ts

@@ -0,0 +1,3 @@
+export { getAssetsRecord, getBestRoute } from './utils/api.utils';
+export { getSwapMessages, getRainbowWalletActivationMessages } from './utils/message.utils';
+export { getIsRainbowWalletActive, getIsActivationRequired } from './utils/rainbow-wallet.utils';

package/dist/index.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getIsActivationRequired = exports.getIsRainbowWalletActive = exports.getRainbowWalletActivationMessages = exports.getSwapMessages = exports.getBestRoute = exports.getAssetsRecord = void 0;
+var api_utils_1 = require("./utils/api.utils");
+Object.defineProperty(exports, "getAssetsRecord", { enumerable: true, get: function () { return api_utils_1.getAssetsRecord; } });
+Object.defineProperty(exports, "getBestRoute", { enumerable: true, get: function () { return api_utils_1.getBestRoute; } });
+var message_utils_1 = require("./utils/message.utils");
+Object.defineProperty(exports, "getSwapMessages", { enumerable: true, get: function () { return message_utils_1.getSwapMessages; } });
+Object.defineProperty(exports, "getRainbowWalletActivationMessages", { enumerable: true, get: function () { return message_utils_1.getRainbowWalletActivationMessages; } });
+var rainbow_wallet_utils_1 = require("./utils/rainbow-wallet.utils");
+Object.defineProperty(exports, "getIsRainbowWalletActive", { enumerable: true, get: function () { return rainbow_wallet_utils_1.getIsRainbowWalletActive; } });
+Object.defineProperty(exports, "getIsActivationRequired", { enumerable: true, get: function () { return rainbow_wallet_utils_1.getIsActivationRequired; } });

package/dist/interfaces/message.interface.d.ts

@@ -0,0 +1,6 @@
+export interface Message {
+    address: string;
+    amount: string;
+    stateInit?: string;
+    payload?: string;
+}

package/dist/interfaces/message.interface.js

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

package/dist/interfaces/route-step-with-calculation.interface.d.ts

@@ -0,0 +1,5 @@
+import { RouteStep } from './route-step.interface';
+export interface RouteStepWithCalculation extends RouteStep {
+    inputAssetAmount: string;
+    outputAssetAmount: string;
+}

package/dist/interfaces/route-step-with-calculation.interface.js

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

package/dist/interfaces/route-step.interface.d.ts

@@ -0,0 +1,9 @@
+import { DexTypeEnum } from '../enums/dex-type.enum';
+import { RouteDirectionEnum } from '../enums/route-direction.enum';
+export interface RouteStep {
+    dexType: DexTypeEnum;
+    dexPairAddress: string;
+    inputAssetAddress: string;
+    outputAssetAddress: string;
+    routeDirection: RouteDirectionEnum;
+}

package/dist/interfaces/route-step.interface.js

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

package/dist/interfaces/transfer-params.interface.d.ts

@@ -0,0 +1,7 @@
+import { Address, Cell, StateInit } from '@ton/core';
+export interface TransferParams {
+    to: Address;
+    value: bigint;
+    init?: StateInit;
+    body?: Cell;
+}

package/dist/interfaces/transfer-params.interface.js

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

package/dist/types/asset.type.d.ts

@@ -0,0 +1,8 @@
+export type Asset = {
+    symbol: string;
+    name: string;
+    address: string;
+    image: string;
+    decimals: number;
+    exchangeRate: string;
+};

package/dist/types/asset.type.js

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

package/dist/types/assets-record-response.type.d.ts

@@ -0,0 +1,2 @@
+import { Asset } from './asset.type';
+export type AssetsRecordResponse = Record<string, Asset>;

package/dist/types/assets-record-response.type.js

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

package/dist/types/best-route-response.type.d.ts

@@ -0,0 +1,5 @@
+import { CalculatedSwapRoute } from './calculated-swap-route.type';
+export type BestRouteResponse = {
+    bestRoute: CalculatedSwapRoute[];
+    priceImprovement: number;
+};

package/dist/types/best-route-response.type.js

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

package/dist/types/calculated-swap-route.type.d.ts

@@ -0,0 +1,4 @@
+import { DeDustCalculatedSwapRoute } from '../dexes/dedust/calculated-swap-route.interface';
+import { RainbowCalculatedSwapRoute } from '../dexes/rainbow/calculated-swap-route.interface';
+import { StonCalculatedSwapRoute } from '../dexes/ston/calculated-swap-route.interface';
+export type CalculatedSwapRoute = DeDustCalculatedSwapRoute | StonCalculatedSwapRoute | RainbowCalculatedSwapRoute;

package/dist/types/calculated-swap-route.type.js

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

package/dist/utils/api.utils.d.ts

@@ -0,0 +1,8 @@
+import { AssetsRecordResponse } from '../types/assets-record-response.type';
+import { BestRouteResponse } from '../types/best-route-response.type';
+export declare const getAssetsRecord: () => Promise<import("axios").AxiosResponse<AssetsRecordResponse, any>>;
+export declare const getBestRoute: (params: {
+    inputAssetAmount: string;
+    inputAssetAddress: string;
+    outputAssetAddress: string;
+}) => Promise<import("axios").AxiosResponse<BestRouteResponse, any>>;

package/dist/utils/api.utils.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getBestRoute = exports.getAssetsRecord = void 0;
+const globals_1 = require("../globals");
+const getAssetsRecord = () => globals_1.API.get('/assets-record');
+exports.getAssetsRecord = getAssetsRecord;
+const getBestRoute = (params) => globals_1.API.get('/best-route', { params });
+exports.getBestRoute = getBestRoute;

package/dist/utils/boc.utils.d.ts

@@ -0,0 +1,2 @@
+import { Cell } from '@ton/core';
+export declare const bocToCell: (boc: string) => Cell;

package/dist/utils/boc.utils.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.bocToCell = void 0;
+const core_1 = require("@ton/core");
+const buffer_1 = require("buffer");
+const bocToCell = (boc) => core_1.Cell.fromBoc(buffer_1.Buffer.from(boc, 'base64'))[0];
+exports.bocToCell = bocToCell;

package/dist/utils/jetton.utils.d.ts

@@ -0,0 +1,11 @@
+import { Address, Cell } from '@ton/core';
+export declare const getJettonWalletAddress: (jettonMasterAddress: string, ownerAddress: Address) => Promise<Address>;
+export declare const getJettonTransferBody: (params: {
+    queryId?: number;
+    amount: bigint;
+    destination: Address;
+    responseDestination: Address;
+    customPayload?: Cell;
+    forwardTonAmount: bigint;
+    forwardPayload: Cell;
+}) => Cell;

package/dist/utils/jetton.utils.js

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getJettonTransferBody = exports.getJettonWalletAddress = void 0;
+const core_1 = require("@ton/core");
+const globals_1 = require("../globals");
+const getJettonWalletAddress = async (jettonMasterAddress, ownerAddress) => {
+    const walletAddressResponse = await globals_1.TON_CLIENT.runMethod(core_1.Address.parse(jettonMasterAddress), 'get_wallet_address', [
+        {
+            type: 'slice',
+            cell: (0, core_1.beginCell)().storeAddress(ownerAddress).endCell()
+        }
+    ]);
+    return walletAddressResponse.stack.readAddress();
+};
+exports.getJettonWalletAddress = getJettonWalletAddress;
+var Operation;
+(function (Operation) {
+    Operation[Operation["TRANSFER"] = 260734629] = "TRANSFER";
+})(Operation || (Operation = {}));
+const getJettonTransferBody = (params) => (0, core_1.beginCell)()
+    .storeUint(Operation.TRANSFER, 32)
+    .storeUint(params.queryId ?? 0, 64)
+    .storeCoins(params.amount)
+    .storeAddress(params.destination)
+    .storeAddress(params.responseDestination) // address where to return fee (diff between input fee and forwardAmount)
+    .storeMaybeRef(params.customPayload ?? null)
+    .storeCoins(params.forwardTonAmount)
+    .storeMaybeRef(params.forwardPayload)
+    .endCell();
+exports.getJettonTransferBody = getJettonTransferBody;

package/dist/utils/math.utils.d.ts

@@ -0,0 +1 @@
+export declare const randomIntFromInterval: (min: number, max: number) => number;

package/dist/utils/math.utils.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.randomIntFromInterval = void 0;
+const randomIntFromInterval = (min, max) => Math.floor(Math.random() * (max - min + 1) + min);
+exports.randomIntFromInterval = randomIntFromInterval;

package/dist/utils/message.utils.d.ts

@@ -0,0 +1,4 @@
+import { Message } from '../interfaces/message.interface';
+import { CalculatedSwapRoute } from '../types/calculated-swap-route.type';
+export declare const getSwapMessages: (senderAddress: string, bestRoute: CalculatedSwapRoute[], slippageTolerance: string) => Promise<Message[]>;
+export declare const getRainbowWalletActivationMessages: (senderAddress: string) => Message[];

package/dist/utils/message.utils.js

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getRainbowWalletActivationMessages = exports.getSwapMessages = void 0;
+const shared_1 = require("@rnw-community/shared");
+const core_1 = require("@ton/core");
+const transfer_params_utils_1 = require("../dexes/shared/transfer-params.utils");
+const transferParamsToMessages = (transferParamsArray) => transferParamsArray.map(transferParams => ({
+    address: transferParams.to.toRawString(),
+    amount: transferParams.value.toString(),
+    payload: (0, shared_1.isDefined)(transferParams.body)
+        ? transferParams.body.toBoc().toString('base64')
+        : undefined,
+    stateInit: (0, shared_1.isDefined)(transferParams.init)
+        ? (0, core_1.beginCell)()
+            .store((0, core_1.storeStateInit)(transferParams.init))
+            .endCell()
+            .toBoc()
+            .toString('base64')
+        : undefined
+}));
+const getSwapMessages = async (senderAddress, bestRoute, slippageTolerance) => {
+    const swapTransferParams = await Promise.all(bestRoute.map(swapRoute => (0, transfer_params_utils_1.getSwapRouteTransferParams)(swapRoute, core_1.Address.parse(senderAddress), slippageTolerance)));
+    return transferParamsToMessages(swapTransferParams);
+};
+exports.getSwapMessages = getSwapMessages;
+const getRainbowWalletActivationMessages = (senderAddress) => {
+    const activationTransferParams = [
+        (0, transfer_params_utils_1.getRainbowWalletActivationTransferParams)(core_1.Address.parse(senderAddress))
+    ];
+    return transferParamsToMessages(activationTransferParams);
+};
+exports.getRainbowWalletActivationMessages = getRainbowWalletActivationMessages;

package/dist/utils/rainbow-wallet.utils.d.ts

@@ -0,0 +1,3 @@
+import { CalculatedSwapRoute } from '../types/calculated-swap-route.type';
+export declare const getIsRainbowWalletActive: (ownerAddress: string) => Promise<boolean>;
+export declare const getIsActivationRequired: (senderAddress: string, bestRoute: CalculatedSwapRoute[]) => Promise<boolean>;

package/dist/utils/rainbow-wallet.utils.js

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getIsActivationRequired = exports.getIsRainbowWalletActive = void 0;
+const core_1 = require("@ton/core");
+const rainbow_wallet_contract_1 = require("../dexes/rainbow/rainbow-wallet.contract");
+const swap_route_type_enum_1 = require("../enums/swap-route-type.enum");
+const globals_1 = require("../globals");
+const getIsRainbowWalletActive = async (ownerAddress) => {
+    const rainbowWallet = rainbow_wallet_contract_1.RainbowWalletContract.create({
+        workchain: globals_1.WORKCHAIN,
+        ownerAddress: core_1.Address.parse(ownerAddress)
+    });
+    const contractProvider = globals_1.TON_CLIENT.provider(rainbowWallet.address);
+    const state = await contractProvider.getState();
+    return state.state.type === 'active';
+};
+exports.getIsRainbowWalletActive = getIsRainbowWalletActive;
+const getIsActivationRequired = async (senderAddress, bestRoute) => {
+    const isRainbowContractCalled = bestRoute.some(swapRoute => swapRoute.type === swap_route_type_enum_1.SwapRouteType.Rainbow);
+    if (isRainbowContractCalled) {
+        const isRainbowWalletActive = await (0, exports.getIsRainbowWalletActive)(senderAddress);
+        return !isRainbowWalletActive;
+    }
+    else {
+        return false;
+    }
+};
+exports.getIsActivationRequired = getIsActivationRequired;

package/dist/utils/transfer-params.utils.d.ts

@@ -0,0 +1 @@
+export declare const getQueryId: () => number;

package/dist/utils/transfer-params.utils.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getQueryId = void 0;
+const math_utils_1 = require("./math.utils");
+const getQueryId = () => (0, math_utils_1.randomIntFromInterval)(1, 10 ** 6);
+exports.getQueryId = getQueryId;

package/package.json

@@ -0,0 +1,35 @@
+{
+  "name": "rainbow-swap-sdk",
+  "version": "1.0.0",
+  "description": "An SDK for building applications on top of Rainbow Swap",
+  "repository": "https://github.com/0xblackbot/rainbow-swap-sdk.git",
+  "license": "Apache-2.0",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "ts": "tsc --pretty",
+    "lint": "eslint . --ext ts --report-unused-disable-directives --max-warnings 0",
+    "build": "tsc"
+  },
+  "dependencies": {
+    "@rnw-community/shared": "^0.73.0",
+    "@ton/core": "^0.56.3",
+    "@ton/ton": "^13.11.2",
+    "axios": "^1.7.2",
+    "buffer": "^6.0.3"
+  },
+  "devDependencies": {
+    "@typescript-eslint/eslint-plugin": "^7.16.0",
+    "@typescript-eslint/parser": "^7.16.0",
+    "eslint": "^8.57.0",
+    "eslint-config-prettier": "^9.1.0",
+    "eslint-plugin-import": "^2.29.1",
+    "eslint-plugin-prettier": "^5.1.3",
+    "prettier": "^3.2.5",
+    "ts-node": "^10.9.2",
+    "typescript": "^5.5.3"
+  }
+}