@affluent-org/sdk 0.0.1

package/dist/contracts/core/pool/type.d.ts

@@ -0,0 +1,136 @@
+import { Address, Cell, Slice } from "@ton/ton";
+import { Maybe } from "../../../contracts/common/type";
+import { JumpIRMConfig } from "../../../contracts/irm/jump-irm/type";
+import { RedstonOracleConfig } from "../../oracle/redstone-oracle/type";
+import { RedstoneOnchainOracleConfig } from "../../oracle/redstone-onchain-oracle/type";
+export type LiquidatePayload = {
+    opCode: number;
+    repayAsset: Address;
+    seizeAsset: Address;
+    borrower: Address;
+    response: Address;
+    jettonForwardTonAmount: bigint;
+    jettonForwardPayload?: Cell | null;
+    oracleParams: Cell;
+    forwardPayload?: Slice;
+};
+export type TransferInPayload = {
+    opCode: number;
+    asset: Address;
+    recipient: Address;
+    response: Address;
+    jettonForwardTonAmount: bigint;
+    jettonForwardPayload?: Cell | null;
+    forwardPayload?: Slice;
+};
+export type TransferOutMsgBody = {
+    type: "Pool.Op.TransferOut";
+    opCode: number;
+    queryId: bigint;
+    asset: Address;
+    isShare: boolean;
+    amount: bigint;
+    recipient: Address;
+    response: Address;
+    jettonForwardTonAmount: bigint;
+    jettonForwardPayload?: Cell | null;
+    oracleParams?: Maybe<Cell>;
+    forwardPayload?: Slice;
+};
+export type LiquidateParams = Omit<LiquidatePayload, "opCode">;
+export type TransferInParams = Omit<TransferInPayload, "opCode">;
+export type TransferOutMsgParams = Omit<TransferOutMsgBody, "opCode" | "queryId" | "type"> & {
+    queryId?: bigint;
+};
+export type AssetState = {
+    address: Address;
+    wallet: Maybe<Address>;
+    irm: Maybe<Address>;
+    irmConfig: Cell | JumpIRMConfig;
+    riskFactor: bigint;
+    liquidationIncentiveRate: bigint;
+    isCollateral: boolean;
+    isBorrowable: boolean;
+    lastUpdatedTime: bigint;
+    storedInterestRate: bigint;
+    collectedProtocolFee: bigint;
+    cash: bigint;
+    totalSupplyAmount: bigint;
+    totalBorrowAmount: bigint;
+    totalSupplyShare: bigint;
+    totalBorrowShare: bigint;
+};
+export type PoolState = {
+    address: Address;
+    id: bigint;
+    owner: Maybe<Address>;
+    feeConfigurer: Maybe<Address>;
+    protocolFeeRate: bigint;
+    oracle: Maybe<Address>;
+    oracleConfigRaw: Cell;
+    oracleConfig: Cell | RedstoneOnchainOracleConfig | RedstonOracleConfig;
+    maxLoanLeverageRatio: bigint;
+    maxLoanVarRatio: bigint;
+    liquidateLeverageRatio: bigint;
+    liquidateVarRatio: bigint;
+    maxLiquidateCloseRatio: bigint;
+    minLiquidateCloseRatio: bigint;
+    assets: Record<string, AssetState>;
+    minimumGasFee: PoolGasFee;
+};
+export type PoolGasFee = {
+    supply: bigint;
+    withdraw: bigint;
+    borrow: bigint;
+    repay: bigint;
+    liquidate: bigint;
+    accountStatusUpdate: bigint;
+    jettonTransfer: bigint;
+    oracleCalculate: bigint;
+    interestRateUpdate: bigint;
+};
+export type BaseActionNotificationMsgBody = {
+    opCode: number;
+    queryId: bigint;
+    actionOpCode: number;
+    errorCode: number;
+    forwardPayload?: Slice;
+};
+export type SuccessActionNotificationMsgBody = BaseActionNotificationMsgBody & {
+    asset: Address;
+    amount: bigint;
+    share: bigint;
+};
+export type SuccessRepayActionNotificationMsgBody = SuccessActionNotificationMsgBody & {
+    overRepaidAmount: bigint;
+};
+export type SuccessLiquidateActionNotificationMsgBody = BaseActionNotificationMsgBody & {
+    repayAsset: Address;
+    seizeAsset: Address;
+    repayAmount: bigint;
+    repayShare: bigint;
+    seizeShare: bigint;
+};
+export type FailTransferInActionNotificationMsgBody = BaseActionNotificationMsgBody & {
+    sender: Address;
+    asset: Address;
+    amount: bigint;
+    recipient: Address;
+    response: Address;
+};
+export type FailLiquidateActionNotificationMsgBody = BaseActionNotificationMsgBody & {
+    sender: Address;
+    amount: bigint;
+    repayAsset: Address;
+    seizeAsset: Address;
+    borrower: Address;
+    response: Address;
+};
+export type FailTransferOutActionNotificationMsgBody = BaseActionNotificationMsgBody & {
+    asset: Address;
+    isShare: boolean;
+    value: bigint;
+    recipient: Address;
+    response: Address;
+};
+export type ActionNotificationMsgBody = SuccessActionNotificationMsgBody | SuccessRepayActionNotificationMsgBody | SuccessLiquidateActionNotificationMsgBody | FailTransferInActionNotificationMsgBody | FailLiquidateActionNotificationMsgBody | FailTransferOutActionNotificationMsgBody | null;

package/dist/contracts/core/pool/type.js

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

package/dist/contracts/dedust-farm/MockDedustFarm.d.ts

@@ -0,0 +1,41 @@
+import { Address, Cell, Contract, ContractProvider, Sender } from "@ton/core";
+export type DedustFarmConfig = {
+    owner: Address;
+};
+export declare function dedustFarmConfigToCell(config: DedustFarmConfig): Cell;
+export declare const Opcodes: {
+    setPrice: number;
+    setLPWallet: number;
+};
+export declare class MockDedustFarm implements Contract {
+    readonly address: Address;
+    readonly init?: {
+        code: Cell;
+        data: Cell;
+    } | undefined;
+    constructor(address: Address, init?: {
+        code: Cell;
+        data: Cell;
+    } | undefined);
+    static createFromAddress(address: Address): MockDedustFarm;
+    static createFromConfig(config: DedustFarmConfig, code: Cell, workchain?: number): MockDedustFarm;
+    sendDeploy(provider: ContractProvider, via: Sender, value: bigint): Promise<void>;
+    sendSetLPAddr(provider: ContractProvider, via: Sender, value: bigint, opts: {
+        queryID?: bigint;
+        reward: Address;
+    }): Promise<void>;
+    sendSetPrice(provider: ContractProvider, via: Sender, opts: {
+        value: bigint;
+        assetId: bigint;
+        price: bigint;
+        queryID?: number;
+    }): Promise<void>;
+    getState(provider: ContractProvider): Promise<import("@ton/core").ContractState>;
+    getFarmData(provider: ContractProvider): Promise<{
+        index: bigint;
+        owner: Address | null;
+        lpToken: Address | null;
+        rewardToken: Address | null;
+    }>;
+    getFarmData2(provider: ContractProvider): Promise<import("@ton/core").TupleReader>;
+}

package/dist/contracts/dedust-farm/MockDedustFarm.js

@@ -0,0 +1,79 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MockDedustFarm = exports.Opcodes = void 0;
+exports.dedustFarmConfigToCell = dedustFarmConfigToCell;
+const core_1 = require("@ton/core");
+function dedustFarmConfigToCell(config) {
+    return (0, core_1.beginCell)().storeAddress(config.owner).storeAddress(null).endCell();
+}
+exports.Opcodes = {
+    setPrice: 0xf990365,
+    setLPWallet: 0xd29c540a,
+};
+class MockDedustFarm {
+    address;
+    init;
+    constructor(address, init) {
+        this.address = address;
+        this.init = init;
+    }
+    static createFromAddress(address) {
+        return new MockDedustFarm(address);
+    }
+    static createFromConfig(config, code, workchain = 0) {
+        const data = dedustFarmConfigToCell(config);
+        const init = { code, data };
+        return new MockDedustFarm((0, core_1.contractAddress)(workchain, init), init);
+    }
+    async sendDeploy(provider, via, value) {
+        await provider.internal(via, {
+            value,
+            sendMode: core_1.SendMode.PAY_GAS_SEPARATELY,
+            body: (0, core_1.beginCell)().endCell(),
+        });
+    }
+    async sendSetLPAddr(provider, via, value, opts) {
+        await provider.internal(via, {
+            value,
+            sendMode: core_1.SendMode.PAY_GAS_SEPARATELY,
+            body: (0, core_1.beginCell)()
+                .storeUint(exports.Opcodes.setLPWallet, 32)
+                .storeUint(opts.queryID ?? 0, 64)
+                .storeAddress(opts.reward)
+                .endCell(),
+        });
+    }
+    async sendSetPrice(provider, via, opts) {
+        await provider.internal(via, {
+            value: opts.value,
+            sendMode: core_1.SendMode.PAY_GAS_SEPARATELY,
+            body: (0, core_1.beginCell)()
+                .storeUint(exports.Opcodes.setPrice, 32)
+                .storeUint(opts.queryID ?? 0, 64)
+                .storeUint(opts.assetId, 64)
+                .storeCoins(opts.price)
+                .endCell(),
+        });
+    }
+    async getState(provider) {
+        return await provider.getState();
+    }
+    async getFarmData(provider) {
+        const result = await provider.get("get_farm_data", []);
+        const index = result.stack.readBigNumber();
+        const owner = result.stack.readAddressOpt();
+        const lpToken = result.stack.readAddressOpt();
+        const rewardToken = result.stack.readAddressOpt();
+        return {
+            index,
+            owner,
+            lpToken,
+            rewardToken,
+        };
+    }
+    async getFarmData2(provider) {
+        const result = await provider.get("get_farm_data", []);
+        return result.stack;
+    }
+}
+exports.MockDedustFarm = MockDedustFarm;

package/dist/contracts/external/tonstaker.d.ts

@@ -0,0 +1,18 @@
+import { Address, Cell, Contract, ContractProvider } from "@ton/core";
+export declare class TonstakerPool implements Contract {
+    readonly address: Address;
+    readonly init?: {
+        code: Cell;
+        data: Cell;
+    } | undefined;
+    constructor(address: Address, init?: {
+        code: Cell;
+        data: Cell;
+    } | undefined);
+    static createFromAddress(address: Address): TonstakerPool;
+    getPoolState(provider: ContractProvider): Promise<{
+        index: bigint;
+        reserve: bigint;
+        totalSupply: bigint;
+    }>;
+}

package/dist/contracts/external/tonstaker.js

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TonstakerPool = void 0;
+class TonstakerPool {
+    address;
+    init;
+    constructor(address, init) {
+        this.address = address;
+        this.init = init;
+    }
+    static createFromAddress(address) {
+        return new TonstakerPool(address);
+    }
+    async getPoolState(provider) {
+        const { stack } = await provider.get("get_pool_state", []);
+        const index = stack.readBigNumber();
+        const reserve = stack.readBigNumber();
+        const totalSupply = stack.readBigNumber();
+        return {
+            index,
+            reserve,
+            totalSupply,
+        };
+    }
+}
+exports.TonstakerPool = TonstakerPool;

package/dist/contracts/factory/factory.d.ts

@@ -0,0 +1,24 @@
+import { Address, Cell, Contract, Builder, ContractProvider, Sender } from "@ton/core";
+import { FactoryState } from "./type";
+export declare class Factory implements Contract {
+    readonly address: Address;
+    readonly init?: {
+        code: Cell;
+        data: Cell;
+    } | undefined;
+    constructor(address: Address, init?: {
+        code: Cell;
+        data: Cell;
+    } | undefined);
+    static Opcodes: {
+        createPool: number;
+    };
+    static createFromAddress(address: Address): Factory;
+    sendCreatePool(provider: ContractProvider, via: Sender, opts: {
+        value: bigint;
+        queryID?: number;
+        body: Builder;
+    }): Promise<void>;
+    getPoolAddress(provider: ContractProvider, poolId: bigint): Promise<Address>;
+    getFactoryData(provider: ContractProvider): Promise<FactoryState>;
+}

package/dist/contracts/factory/factory.js

@@ -0,0 +1,58 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Factory = void 0;
+const core_1 = require("@ton/core");
+class Factory {
+    address;
+    init;
+    constructor(address, init) {
+        this.address = address;
+        this.init = init;
+    }
+    static Opcodes = {
+        createPool: 0xad85e6b3,
+    };
+    static createFromAddress(address) {
+        return new Factory(address);
+    }
+    async sendCreatePool(provider, via, opts) {
+        await provider.internal(via, {
+            value: opts.value,
+            sendMode: core_1.SendMode.PAY_GAS_SEPARATELY,
+            body: (0, core_1.beginCell)()
+                .storeUint(Factory.Opcodes.createPool, 32)
+                .storeUint(opts.queryID ?? 0, 64)
+                .storeBuilder(opts.body)
+                .endCell(),
+        });
+    }
+    async getPoolAddress(provider, poolId) {
+        const result = await provider.get("get_pool_address", [{ type: "int", value: poolId }]);
+        return result.stack.readAddress();
+    }
+    async getFactoryData(provider) {
+        const { stack } = await provider.get("get_factory_data", []);
+        const owner = stack.readAddressOpt();
+        const nextPoolIndex = stack.readBigNumber();
+        const feeConfigurer = stack.readAddressOpt();
+        const initProtocolFeeRate = stack.readNumber();
+        const _whitelistedIrms = stack.readCellOpt();
+        const _whitelistedOracles = stack.readCellOpt();
+        const whitelistedIrms = (_whitelistedIrms &&
+            core_1.Dictionary.loadDirect(core_1.Dictionary.Keys.Address(), core_1.Dictionary.Values.Int(1), _whitelistedIrms).keys()) ||
+            [];
+        const whitelistedOracles = (_whitelistedOracles &&
+            core_1.Dictionary.loadDirect(core_1.Dictionary.Keys.Address(), core_1.Dictionary.Values.Int(1), _whitelistedOracles).keys()) ||
+            [];
+        return {
+            address: this.address,
+            owner,
+            nextPoolIndex,
+            feeConfigurer,
+            initProtocolFeeRate,
+            whitelistedIrms,
+            whitelistedOracles,
+        };
+    }
+}
+exports.Factory = Factory;

package/dist/contracts/factory/type.d.ts

@@ -0,0 +1,11 @@
+import { Address } from "@ton/core";
+import { Maybe } from "../../contracts/common/type";
+export type FactoryState = {
+    address: Address;
+    owner: Maybe<Address>;
+    nextPoolIndex: bigint;
+    feeConfigurer: Maybe<Address>;
+    initProtocolFeeRate: number;
+    whitelistedIrms: Address[];
+    whitelistedOracles: Address[];
+};

package/dist/contracts/factory/type.js

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

package/dist/contracts/farm/distributor.d.ts

@@ -0,0 +1,43 @@
+import { Address, Cell, Contract, ContractProvider, Sender } from "@ton/core";
+export type DistributorInitData = {
+    owner: Address;
+    receiptCode: Cell;
+    content: Cell;
+};
+export declare function distributorInitDataToCell(config: DistributorInitData): Cell;
+export declare const Opcodes: {
+    setPrice: number;
+    setOwner: number;
+    setRewardRootHash: number;
+};
+export declare class Distributor implements Contract {
+    readonly address: Address;
+    readonly init?: {
+        code: Cell;
+        data: Cell;
+    } | undefined;
+    constructor(address: Address, init?: {
+        code: Cell;
+        data: Cell;
+    } | undefined);
+    static Op: {
+        ClaimNotification: number;
+        TransferReward: number;
+    };
+    static createFromAddress(address: Address): Distributor;
+    static createFromConfig(config: DistributorInitData, code: Cell, workchain?: number): Distributor;
+    sendDeploy(provider: ContractProvider, via: Sender, value: bigint): Promise<void>;
+    sendSetOwner(provider: ContractProvider, via: Sender, value: bigint, { queryId, newHash, }: {
+        queryId?: bigint;
+        newHash: bigint;
+    }): Promise<void>;
+    sendSetRewardRootHash(provider: ContractProvider, via: Sender, value: bigint, { queryId, newHash, }: {
+        queryId?: bigint;
+        newHash: bigint;
+    }): Promise<void>;
+    getState(provider: ContractProvider): Promise<import("@ton/core").ContractState>;
+    getDistributorData(provider: ContractProvider): Promise<{
+        owner: Address;
+        rewardRootHash: bigint;
+    }>;
+}

package/dist/contracts/farm/distributor.js

@@ -0,0 +1,83 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Distributor = exports.Opcodes = void 0;
+exports.distributorInitDataToCell = distributorInitDataToCell;
+const core_1 = require("@ton/core");
+function distributorInitDataToCell(config) {
+    return (0, core_1.beginCell)()
+        .storeAddress(config.owner)
+        .storeUint(0, 256)
+        .storeCoins(0)
+        .storeRef(config.receiptCode)
+        .storeRef(config.content)
+        .endCell();
+}
+exports.Opcodes = {
+    setPrice: 0xf990365,
+    setOwner: 0xa31c7c0,
+    setRewardRootHash: 0x2b6d4ce0,
+};
+class Distributor {
+    address;
+    init;
+    constructor(address, init) {
+        this.address = address;
+        this.init = init;
+    }
+    static Op = {
+        ClaimNotification: 0x62daa67f,
+        TransferReward: 0xc917f643,
+    };
+    static createFromAddress(address) {
+        return new Distributor(address);
+    }
+    static createFromConfig(config, code, workchain = 0) {
+        const data = distributorInitDataToCell(config);
+        const init = { code, data };
+        return new Distributor((0, core_1.contractAddress)(workchain, init), init);
+    }
+    async sendDeploy(provider, via, value) {
+        await provider.internal(via, {
+            value,
+            sendMode: core_1.SendMode.PAY_GAS_SEPARATELY,
+            body: (0, core_1.beginCell)().endCell(),
+        });
+    }
+    async sendSetOwner(provider, via, value, { queryId, newHash, }) {
+        await provider.internal(via, {
+            value,
+            sendMode: core_1.SendMode.PAY_GAS_SEPARATELY,
+            body: (0, core_1.beginCell)()
+                .storeUint(exports.Opcodes.setRewardRootHash, 32)
+                .storeUint(queryId ?? 0, 64)
+                .storeUint(newHash, 256)
+                .endCell(),
+        });
+    }
+    async sendSetRewardRootHash(provider, via, value, { queryId, newHash, }) {
+        await provider.internal(via, {
+            value,
+            sendMode: core_1.SendMode.PAY_GAS_SEPARATELY,
+            body: (0, core_1.beginCell)()
+                .storeUint(exports.Opcodes.setRewardRootHash, 32)
+                .storeUint(queryId ?? 0, 64)
+                .storeUint(newHash, 256)
+                .endCell(),
+        });
+    }
+    async getState(provider) {
+        return await provider.getState();
+    }
+    async getDistributorData(provider) {
+        const result = await provider.get("get_distributor_data", []);
+        const owner = result.stack.readAddress();
+        const rewardRootHash = result.stack.readBigNumber();
+        // const cash = result.stack.readBigNumber();
+        return {
+            owner,
+            rewardRootHash,
+            // cash,
+        };
+    }
+}
+exports.Distributor = Distributor;

package/dist/contracts/farm/receipt.d.ts

@@ -0,0 +1,40 @@
+import { Address, Cell, Contract, ContractProvider, Sender } from "@ton/core";
+export type ReceiptInitData = {
+    owner: Address;
+    distributor: Address;
+};
+export declare function receiptInitDataToCell(config: ReceiptInitData): Cell;
+export declare const Opcodes: {
+    claim: number;
+};
+export declare class Receipt implements Contract {
+    readonly address: Address;
+    readonly init?: {
+        code: Cell;
+        data: Cell;
+    } | undefined;
+    constructor(address: Address, init?: {
+        code: Cell;
+        data: Cell;
+    } | undefined);
+    static Op: {
+        Claim: number;
+    };
+    static createFromAddress(address: Address): Receipt;
+    static createFromConfig(config: ReceiptInitData, code: Cell, workchain?: number): Receipt;
+    sendDeploy(provider: ContractProvider, via: Sender, value: bigint): Promise<void>;
+    sendClaim(provider: ContractProvider, via: Sender, value: bigint, { queryId, rewardProofCell, receipient, response, forwardTonAmount, notificationPayload, }: {
+        queryId?: bigint;
+        rewardProofCell: Cell;
+        response: Address;
+        receipient: Address;
+        forwardTonAmount?: bigint;
+        notificationPayload?: Cell;
+    }): Promise<void>;
+    getState(provider: ContractProvider): Promise<import("@ton/core").ContractState>;
+    getReceiptData(provider: ContractProvider): Promise<{
+        owner: Address;
+        distributor: Address;
+        claimed: bigint;
+    }>;
+}

package/dist/contracts/farm/receipt.js

@@ -0,0 +1,68 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Receipt = exports.Opcodes = void 0;
+exports.receiptInitDataToCell = receiptInitDataToCell;
+const core_1 = require("@ton/core");
+function receiptInitDataToCell(config) {
+    return (0, core_1.beginCell)().storeAddress(config.owner).storeAddress(config.distributor).storeCoins(0).endCell();
+}
+exports.Opcodes = {
+    claim: 0x13a3ca6,
+};
+class Receipt {
+    address;
+    init;
+    constructor(address, init) {
+        this.address = address;
+        this.init = init;
+    }
+    static Op = {
+        Claim: 0x13a3ca6,
+    };
+    static createFromAddress(address) {
+        return new Receipt(address);
+    }
+    static createFromConfig(config, code, workchain = 0) {
+        const data = receiptInitDataToCell(config);
+        const init = { code, data };
+        return new Receipt((0, core_1.contractAddress)(workchain, init), init);
+    }
+    async sendDeploy(provider, via, value) {
+        await provider.internal(via, {
+            value,
+            sendMode: core_1.SendMode.PAY_GAS_SEPARATELY,
+            body: (0, core_1.beginCell)().endCell(),
+        });
+    }
+    async sendClaim(provider, via, value, { queryId, rewardProofCell, receipient, response, forwardTonAmount = 0n, notificationPayload, }) {
+        let body = (0, core_1.beginCell)()
+            .storeUint(exports.Opcodes.claim, 32)
+            .storeUint(queryId ?? 0, 64)
+            .storeRef(rewardProofCell)
+            .storeAddress(response)
+            .storeAddress(receipient)
+            .storeCoins(forwardTonAmount)
+            .storeMaybeRef(notificationPayload)
+            .endCell();
+        await provider.internal(via, {
+            value,
+            sendMode: core_1.SendMode.PAY_GAS_SEPARATELY,
+            body: body,
+        });
+    }
+    async getState(provider) {
+        return await provider.getState();
+    }
+    async getReceiptData(provider) {
+        const result = await provider.get("get_receipt_data", []);
+        const owner = result.stack.readAddress();
+        const distributor = result.stack.readAddress();
+        const claimed = result.stack.readBigNumber();
+        return {
+            owner,
+            distributor,
+            claimed,
+        };
+    }
+}
+exports.Receipt = Receipt;

package/dist/contracts/irm/jump-irm/serializer.d.ts

@@ -0,0 +1,4 @@
+import { Cell } from "@ton/core";
+import { JumpIRMConfig } from "./type";
+export declare function serializeJumpIrmConfig(params: JumpIRMConfig): Cell;
+export declare function parseJumpIrmConfig(cell: Cell): JumpIRMConfig;

package/dist/contracts/irm/jump-irm/serializer.js

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.serializeJumpIrmConfig = serializeJumpIrmConfig;
+exports.parseJumpIrmConfig = parseJumpIrmConfig;
+const core_1 = require("@ton/core");
+function serializeJumpIrmConfig(params) {
+    return (0, core_1.beginCell)()
+        .storeCoins(params.baseRate)
+        .storeUint(params.kinkLow, 14)
+        .storeUint(params.kinkHigh, 14)
+        .storeCoins(params.slopeLow)
+        .storeCoins(params.slopeMedium)
+        .storeCoins(params.slopeHigh)
+        .endCell();
+}
+function parseJumpIrmConfig(cell) {
+    const ds = cell.beginParse();
+    return {
+        baseRate: ds.loadCoins(),
+        kinkLow: ds.loadUint(14),
+        kinkHigh: ds.loadUint(14),
+        slopeLow: ds.loadCoins(),
+        slopeMedium: ds.loadCoins(),
+        slopeHigh: ds.loadCoins(),
+    };
+}

package/dist/contracts/irm/jump-irm/type.d.ts

@@ -0,0 +1,8 @@
+export type JumpIRMConfig = {
+    baseRate: bigint;
+    kinkLow: number;
+    kinkHigh: number;
+    slopeLow: bigint;
+    slopeMedium: bigint;
+    slopeHigh: bigint;
+};