@affluent-org/sdk 0.0.1

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

@@ -0,0 +1,379 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Pool = void 0;
+exports.shareToAmount = shareToAmount;
+exports.positionShareToAmount = positionShareToAmount;
+const core_1 = require("@ton/core");
+const serializer_1 = require("./serializer");
+const serializer_2 = require("../../../contracts/irm/jump-irm/serializer");
+const parser_1 = require("../../oracle/parser");
+/**
+ * Convert pool share to actual amount
+ *
+ * @param share - Share amount
+ * @param totalAmount - Total amount in pool
+ * @param totalShare - Total shares in pool
+ * @returns Actual amount
+ */
+function shareToAmount(share, totalAmount, totalShare) {
+    if (share === 0n || totalShare === 0n)
+        return 0n;
+    return (share * totalAmount) / totalShare;
+}
+/**
+ * Convert pool share position to actual amounts
+ *
+ * @param position - Share-based position (supply/borrow shares)
+ * @param assetState - Pool asset state with total shares and amounts
+ * @returns Actual amounts (supply/borrow)
+ */
+function positionShareToAmount(position, assetState) {
+    return {
+        supply: shareToAmount(position.supply, assetState.totalSupplyAmount, assetState.totalSupplyShare),
+        borrow: shareToAmount(position.borrow, assetState.totalBorrowAmount, assetState.totalBorrowShare),
+    };
+}
+class Pool {
+    address;
+    init;
+    constructor(address, init) {
+        this.address = address;
+        this.init = init;
+    }
+    static Op = {
+        supply: 0x480074d8,
+        withdraw: 0xcb03bfaf,
+        borrow: 0xcfc248e4,
+        repay: 0xee555a2c,
+        liquidate: 0xcc52bae3,
+        actionNotification: 0xa1b21e8b,
+        Supply: 0x480074d8,
+        Withdraw: 0xcb03bfaf,
+        Borrow: 0xcfc248e4,
+        Repay: 0xee555a2c,
+        Liquidate: 0xcc52bae3,
+        ActionNotification: 0xa1b21e8b,
+        ProvideAccountStatusAndLock: 0xbf281c87,
+        TakeAsset: 0x5c3d8ba8,
+        UpdateAccountStatus: 0x1c5ee1c3,
+        ProcessBorrowActionResult: 0x72097fe2,
+        ExecuteAction: 0x2be12d37,
+        SetIrmConfig: 0xfd5c44b6,
+        SetOwner: 0xa31c7c0,
+        SetFeeConfigurer: 0x8f357657,
+    };
+    static ErrorCodes = {
+        unauthorized: 1000,
+        invalidAsset: 1001,
+        invalidWallet: 1002,
+        invalidAddress: 1003,
+        alreadyInitialized: 1004,
+        notEnoughCash: 1005,
+        notEnoughShare: 1006,
+        notEnoughLiquidity: 1007,
+        notFoundPrice: 1008,
+        notFoundAccount: 1009,
+        enoughLiquidity: 1010,
+        notEnoughProtocolFee: 1011,
+        notBorrowableAsset: 1012,
+        alreadyExistAsset: 1015,
+        lockedAccount: 1016,
+        notEnoughGas: 1017,
+        actionTimeout: 1018,
+        seizeAssetIsRepayAsset: 1019,
+        unknownOp: 0xffff,
+    };
+    static Gas = {
+        baseFee: (0, core_1.toNano)(0.02),
+        forwardFee: (0, core_1.toNano)(0.02),
+        LiquidateionNotificationFee: (0, core_1.toNano)(0.05),
+    };
+    static createFromAddress(address) {
+        return new Pool(address);
+    }
+    static createSupplyPayload(params) {
+        return (0, serializer_1.serializeTransferInPayload)({
+            ...params,
+            opCode: Pool.Op.supply,
+        });
+    }
+    static createRepayPayload(params) {
+        return (0, serializer_1.serializeTransferInPayload)({
+            ...params,
+            opCode: Pool.Op.repay,
+        });
+    }
+    static createLiquidatePayload(params) {
+        return (0, serializer_1.serializeLiquidatePayload)({
+            ...params,
+            opCode: Pool.Op.liquidate,
+        });
+    }
+    static createWithdrawMsgBody(params) {
+        let msgBody = (0, serializer_1.serializeTransferOutMsgBody)({
+            ...params,
+            queryId: params.queryId ?? 0n,
+            opCode: Pool.Op.withdraw,
+        });
+        return msgBody;
+    }
+    static createBorrowMsgBody(params) {
+        let msgBody = (0, serializer_1.serializeTransferOutMsgBody)({
+            ...params,
+            queryId: params.queryId ?? 0n,
+            opCode: Pool.Op.borrow,
+        });
+        return msgBody;
+    }
+    async sendSetOwner(provider, via, value, opts) {
+        await provider.internal(via, {
+            value: value,
+            sendMode: core_1.SendMode.PAY_GAS_SEPARATELY,
+            body: Pool.createSetOwnerMsgBody(opts),
+        });
+    }
+    async sendWithdraw(provider, via, value, params) {
+        let msgBody = Pool.createWithdrawMsgBody(params);
+        await provider.internal(via, {
+            value: value,
+            sendMode: core_1.SendMode.PAY_GAS_SEPARATELY,
+            body: msgBody,
+        });
+        return msgBody;
+    }
+    async sendBorrow(provider, via, value, params) {
+        let msgBody = Pool.createBorrowMsgBody(params);
+        await provider.internal(via, {
+            value: value,
+            sendMode: core_1.SendMode.PAY_GAS_SEPARATELY,
+            body: msgBody,
+        });
+        return msgBody;
+    }
+    static createSetIrmConfigMsgBody = (params) => {
+        return (0, core_1.beginCell)()
+            .storeUint(Pool.Op.SetIrmConfig, 32)
+            .storeUint(params.queryId ?? 0, 64)
+            .storeAddress(params.asset)
+            .storeRef(params.irmConfig)
+            .endCell();
+    };
+    static createSetOwnerMsgBody(opts) {
+        return (0, core_1.beginCell)()
+            .storeUint(Pool.Op.SetOwner, 32)
+            .storeUint(opts.queryID ?? 0, 64)
+            .storeAddress(opts.newOwner)
+            .endCell();
+    }
+    static parseSetOwnerMsgBody(cell) {
+        const slice = cell.beginParse();
+        const op = slice.loadUint(32);
+        const queryID = slice.loadUint(64);
+        const newOwner = slice.loadAddress();
+        return { op, queryID, newOwner };
+    }
+    static createSetFeeConfigurerMsgBody = (params) => {
+        return (0, core_1.beginCell)()
+            .storeUint(Pool.Op.SetFeeConfigurer, 32)
+            .storeUint(params.queryId ?? 0, 64)
+            .storeAddress(params.feeConfigurer)
+            .endCell();
+    };
+    static calculateGasFee(actionOp, baseFee, forwardFee, forwardTonAmount, useInternalOracle, useOracle, gas) {
+        if (actionOp === Pool.Op.Supply) {
+            let totalFee = baseFee;
+            totalFee += forwardFee;
+            totalFee += gas.supply;
+            totalFee += gas.accountStatusUpdate;
+            totalFee += gas.jettonTransfer;
+            totalFee += gas.interestRateUpdate;
+            totalFee += forwardTonAmount;
+            return totalFee;
+        }
+        else if (actionOp === Pool.Op.Withdraw) {
+            const forwardCount = useInternalOracle ? 3n : 5n;
+            let totalFee = baseFee;
+            totalFee += forwardFee * forwardCount;
+            totalFee += gas.withdraw;
+            totalFee += gas.accountStatusUpdate;
+            totalFee += gas.jettonTransfer;
+            totalFee += gas.interestRateUpdate;
+            totalFee += forwardTonAmount;
+            if (useOracle) {
+                totalFee += gas.oracleCalculate;
+            }
+            return totalFee;
+        }
+        else if (actionOp === Pool.Op.Borrow) {
+            const forwardCount = useInternalOracle ? 3n : 5n;
+            let totalFee = baseFee;
+            totalFee += forwardFee * forwardCount;
+            totalFee += gas.borrow;
+            totalFee += gas.accountStatusUpdate;
+            totalFee += gas.jettonTransfer;
+            totalFee += gas.interestRateUpdate;
+            totalFee += forwardTonAmount;
+            totalFee += gas.oracleCalculate;
+            return totalFee;
+        }
+        else if (actionOp === Pool.Op.Repay) {
+            const forwardCount = 3n;
+            let totalFee = baseFee;
+            totalFee += forwardFee * forwardCount;
+            totalFee += gas.repay;
+            totalFee += gas.accountStatusUpdate;
+            totalFee += gas.jettonTransfer;
+            totalFee += gas.interestRateUpdate;
+            totalFee += forwardTonAmount;
+            return totalFee;
+        }
+        else if (actionOp === Pool.Op.Liquidate) {
+            const forwardCount = useInternalOracle ? 3n : 5n;
+            let totalFee = baseFee;
+            totalFee += forwardFee * forwardCount;
+            totalFee += gas.liquidate;
+            totalFee += gas.accountStatusUpdate * 2n;
+            totalFee += gas.jettonTransfer;
+            totalFee += gas.interestRateUpdate * 2n;
+            totalFee += forwardTonAmount;
+            totalFee += gas.oracleCalculate;
+            totalFee += Pool.Gas.LiquidateionNotificationFee;
+            return totalFee;
+        }
+        throw "invalid opcode";
+    }
+    async getState(provider) {
+        return await provider.getState();
+    }
+    static simulateAccrueInterest(poolState, time) {
+        const currentTime = BigInt(time ?? BigInt(Math.floor(Date.now() / 1000)));
+        const newAssets = {};
+        Object.entries(poolState.assets).forEach(([assetAddress, assetInfo]) => {
+            if (assetInfo.totalBorrowShare === 0n) {
+                newAssets[assetAddress] = assetInfo;
+            }
+            else {
+                const timeDelta = currentTime - assetInfo.lastUpdatedTime;
+                const interest = (timeDelta * assetInfo.totalBorrowAmount * assetInfo.storedInterestRate) / 10n ** 36n;
+                const protocolFee = (interest * poolState.protocolFeeRate) / 10000n;
+                newAssets[assetAddress] = {
+                    ...assetInfo,
+                    totalBorrowAmount: assetInfo.totalBorrowAmount + interest,
+                    totalSupplyAmount: assetInfo.totalSupplyAmount + interest - protocolFee,
+                    collectedProtocolFee: assetInfo.collectedProtocolFee + protocolFee,
+                    lastUpdatedTime: currentTime,
+                };
+            }
+        });
+        return {
+            ...poolState,
+            assets: newAssets,
+        };
+    }
+    async getPoolData(provider) {
+        const state = await provider.getState();
+        if (state.state.type !== "active")
+            throw "not active";
+        if (!state.state.data)
+            throw "not active";
+        const data = core_1.Cell.fromBoc(state.state.data)[0].beginParse();
+        return {
+            address: this.address,
+            ...Pool.parsePoolData(data),
+        };
+    }
+    static parsePoolData(data) {
+        const initialized = data.loadBit();
+        const id = data.loadCoins();
+        const owner = data.loadMaybeAddress();
+        const feeConfigurer = data.loadMaybeAddress();
+        const protocolFeeRate = data.loadUintBig(14);
+        const oracle = data.loadMaybeAddress();
+        const oracleConfigRaw = data.loadRef();
+        const oracleConfig = (0, parser_1.parseOracleConfig)(oracleConfigRaw);
+        const maxLoanLeverageRatio = data.loadUintBig(20);
+        const maxLoanVarRatio = data.loadUintBig(14);
+        const liquidateLeverageRatio = data.loadUintBig(20);
+        const liquidateVarRatio = data.loadUintBig(14);
+        const minLiquidateCloseRatio = data.loadUintBig(14);
+        const maxLiquidateCloseRatio = data.loadUintBig(14);
+        const gasCell = (0, serializer_1.parseGasCell)(data.loadRef());
+        const assetsDict = data.loadDict(core_1.Dictionary.Keys.Address(), Pool.Dictionary.Values.Asset());
+        const assets = assetsDict.keys().reduce((acc, cur) => {
+            acc[cur.toString()] = {
+                address: cur.toString(),
+                ...assetsDict.get(cur),
+            };
+            return acc;
+        }, {});
+        return {
+            id,
+            owner,
+            feeConfigurer,
+            protocolFeeRate,
+            oracle,
+            oracleConfig,
+            maxLoanLeverageRatio,
+            maxLoanVarRatio,
+            liquidateLeverageRatio,
+            liquidateVarRatio,
+            minLiquidateCloseRatio,
+            maxLiquidateCloseRatio,
+            assets,
+            minimumGasFee: gasCell,
+            oracleConfigRaw: oracleConfigRaw,
+        };
+    }
+    async getAccountAddress(provider, owner) {
+        const result = await provider.get("get_account_address", [
+            {
+                type: "slice",
+                cell: (0, core_1.beginCell)().storeAddress(owner).endCell(),
+            },
+        ]);
+        return result.stack.readAddress();
+    }
+    static Dictionary = {
+        Values: {
+            Asset: () => ({
+                serialize: (src, builder) => { },
+                parse: (src) => {
+                    const lastUpdatedTime = src.loadUintBig(40);
+                    const storedInterestRate = src.loadCoins();
+                    const collectedProtocolFee = src.loadCoins();
+                    const cash = src.loadCoins();
+                    const totalSupplyAmount = src.loadCoins();
+                    const totalBorrowAmount = src.loadCoins();
+                    const totalSupplyShare = src.loadCoins();
+                    const totalBorrowShare = src.loadCoins();
+                    const config = src.loadRef().beginParse();
+                    const wallet = config.loadMaybeAddress();
+                    const irm = config.loadMaybeAddress();
+                    const irmConfig = irm ? config.loadRef() : (0, serializer_2.parseJumpIrmConfig)(config.loadRef());
+                    const riskFactor = config.loadUintBig(14);
+                    const liquidationIncentiveRate = config.loadUintBig(14);
+                    const isCollateral = config.loadBit();
+                    const isBorrowable = config.loadBit();
+                    return {
+                        wallet,
+                        irm,
+                        irmConfig,
+                        riskFactor,
+                        liquidationIncentiveRate,
+                        isCollateral,
+                        isBorrowable,
+                        lastUpdatedTime,
+                        storedInterestRate,
+                        collectedProtocolFee,
+                        cash,
+                        totalSupplyAmount,
+                        totalBorrowAmount,
+                        totalSupplyShare,
+                        totalBorrowShare,
+                    };
+                },
+            }),
+        },
+    };
+}
+exports.Pool = Pool;

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

@@ -0,0 +1,15 @@
+import { Cell } from "@ton/core";
+import { FailTransferOutActionNotificationMsgBody, FailTransferInActionNotificationMsgBody, FailLiquidateActionNotificationMsgBody, LiquidatePayload, SuccessActionNotificationMsgBody, SuccessLiquidateActionNotificationMsgBody, SuccessRepayActionNotificationMsgBody, TransferInPayload, TransferOutMsgBody, PoolGasFee } from "./type";
+export declare function serializeTransferInPayload(params: TransferInPayload): Cell;
+export declare function parseTransferInPayload(cell: Cell): TransferInPayload;
+export declare function serializeLiquidatePayload(params: LiquidatePayload): Cell;
+export declare function parseLiquidatePayload(cell: Cell): LiquidatePayload;
+export declare function serializeTransferOutMsgBody(params: Omit<TransferOutMsgBody, "type">): Cell;
+export declare function parseTransferOutMsgBody(cell: Cell): TransferOutMsgBody;
+export declare function parseGasCell(cell: Cell): PoolGasFee;
+export declare function parseSuccessActionNotificationMsgBody(cell: Cell): SuccessActionNotificationMsgBody;
+export declare function parseSuccessRepayActionNotificationMsgBody(cell: Cell): SuccessRepayActionNotificationMsgBody;
+export declare function parseSuccessLiquidationActionNotificationMsgBody(cell: Cell): SuccessLiquidateActionNotificationMsgBody;
+export declare function parseFailTransferOutActionNotificationMsgBody(cell: Cell): FailTransferOutActionNotificationMsgBody;
+export declare function parseFailTransferInActionNotificationMsgBody(cell: Cell): FailTransferInActionNotificationMsgBody;
+export declare function parseFailLiquidateActionNotificationMsgBody(cell: Cell): FailLiquidateActionNotificationMsgBody;

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

@@ -0,0 +1,307 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.serializeTransferInPayload = serializeTransferInPayload;
+exports.parseTransferInPayload = parseTransferInPayload;
+exports.serializeLiquidatePayload = serializeLiquidatePayload;
+exports.parseLiquidatePayload = parseLiquidatePayload;
+exports.serializeTransferOutMsgBody = serializeTransferOutMsgBody;
+exports.parseTransferOutMsgBody = parseTransferOutMsgBody;
+exports.parseGasCell = parseGasCell;
+exports.parseSuccessActionNotificationMsgBody = parseSuccessActionNotificationMsgBody;
+exports.parseSuccessRepayActionNotificationMsgBody = parseSuccessRepayActionNotificationMsgBody;
+exports.parseSuccessLiquidationActionNotificationMsgBody = parseSuccessLiquidationActionNotificationMsgBody;
+exports.parseFailTransferOutActionNotificationMsgBody = parseFailTransferOutActionNotificationMsgBody;
+exports.parseFailTransferInActionNotificationMsgBody = parseFailTransferInActionNotificationMsgBody;
+exports.parseFailLiquidateActionNotificationMsgBody = parseFailLiquidateActionNotificationMsgBody;
+const core_1 = require("@ton/core");
+function serializeTransferInPayload(params) {
+    let cell = (0, core_1.beginCell)()
+        .storeAddress(params.recipient)
+        .storeUint(params.opCode, 32)
+        .storeAddress(params.asset)
+        .storeAddress(params.response)
+        .storeCoins(params.jettonForwardTonAmount)
+        .storeMaybeRef(params.jettonForwardPayload);
+    if (params.forwardPayload) {
+        cell = cell.storeSlice(params.forwardPayload);
+    }
+    return cell.endCell();
+}
+function parseTransferInPayload(cell) {
+    const ds = cell.beginParse();
+    const recipient = ds.loadAddress();
+    const opCode = ds.loadUint(32);
+    const asset = ds.loadAddress();
+    const response = ds.loadAddress();
+    const jettonForwardTonAmount = ds.loadCoins();
+    const jettonForwardPayload = ds.loadMaybeRef();
+    const forwardPayload = ds;
+    return {
+        opCode,
+        recipient,
+        asset,
+        response,
+        jettonForwardTonAmount,
+        jettonForwardPayload,
+        forwardPayload,
+    };
+}
+function serializeLiquidatePayload(params) {
+    let subCell = (0, core_1.beginCell)().storeAddress(params.seizeAsset);
+    if (params.forwardPayload) {
+        subCell = subCell.storeSlice(params.forwardPayload);
+    }
+    return (0, core_1.beginCell)()
+        .storeAddress(params.borrower)
+        .storeUint(params.opCode, 32)
+        .storeAddress(params.repayAsset)
+        .storeAddress(params.response)
+        .storeCoins(params.jettonForwardTonAmount)
+        .storeMaybeRef(params.jettonForwardPayload)
+        .storeRef(params.oracleParams)
+        .storeRef(subCell.endCell())
+        .endCell();
+}
+function parseLiquidatePayload(cell) {
+    const ds = cell.beginParse();
+    const borrower = ds.loadAddress();
+    const opCode = ds.loadUint(32);
+    const repayAsset = ds.loadAddress();
+    const response = ds.loadAddress();
+    const jettonForwardTonAmount = ds.loadCoins();
+    const jettonForwardPayload = ds.loadMaybeRef();
+    const oracleParams = ds.loadRef();
+    const subSlice = ds.loadRef().beginParse();
+    const seizeAsset = subSlice.loadAddress();
+    const forwardPayload = subSlice;
+    return {
+        opCode,
+        borrower,
+        repayAsset,
+        response,
+        jettonForwardTonAmount,
+        jettonForwardPayload,
+        oracleParams,
+        seizeAsset,
+        forwardPayload,
+    };
+}
+function serializeTransferOutMsgBody(params) {
+    let cell = (0, core_1.beginCell)()
+        .storeUint(params.opCode, 32)
+        .storeUint(params.queryId, 64)
+        .storeMaybeRef(params.oracleParams)
+        .storeAddress(params.asset)
+        .storeUint(params.isShare ? 1 : 0, 1)
+        .storeCoins(params.amount)
+        .storeAddress(params.recipient)
+        .storeAddress(params.response)
+        .storeCoins(params.jettonForwardTonAmount)
+        .storeMaybeRef(params.jettonForwardPayload);
+    if (params.forwardPayload) {
+        cell = cell.storeSlice(params.forwardPayload);
+    }
+    return cell.endCell();
+}
+function parseTransferOutMsgBody(cell) {
+    const ds = cell.beginParse();
+    const opCode = ds.loadUint(32);
+    const queryId = ds.loadUintBig(64);
+    const oracleParams = ds.loadMaybeRef();
+    const asset = ds.loadAddress();
+    const isShare = ds.loadBit();
+    const amount = ds.loadCoins();
+    const recipient = ds.loadAddress();
+    const response = ds.loadAddress();
+    const jettonForwardTonAmount = ds.loadCoins();
+    const jettonForwardPayload = ds.loadMaybeRef();
+    const forwardPayload = ds;
+    return {
+        type: "Pool.Op.TransferOut",
+        opCode,
+        queryId,
+        oracleParams,
+        asset,
+        isShare,
+        amount,
+        recipient,
+        jettonForwardTonAmount,
+        jettonForwardPayload,
+        response,
+        forwardPayload,
+    };
+}
+function parseGasCell(cell) {
+    const gasSlice = cell.beginParse();
+    const supply = gasSlice.loadCoins();
+    const withdraw = gasSlice.loadCoins();
+    const borrow = gasSlice.loadCoins();
+    const repay = gasSlice.loadCoins();
+    const liquidate = gasSlice.loadCoins();
+    const accountStatusUpdate = gasSlice.loadCoins();
+    const jettonTransfer = gasSlice.loadCoins();
+    const oracleCalculate = gasSlice.loadCoins();
+    const interestRateUpdate = gasSlice.loadCoins();
+    const minimumGasFee = {};
+    minimumGasFee["supply"] = supply;
+    minimumGasFee["withdraw"] = withdraw;
+    minimumGasFee["borrow"] = borrow;
+    minimumGasFee["repay"] = repay;
+    minimumGasFee["liquidate"] = liquidate;
+    minimumGasFee["accountStatusUpdate"] = accountStatusUpdate;
+    minimumGasFee["jettonTransfer"] = jettonTransfer;
+    minimumGasFee["oracleCalculate"] = oracleCalculate;
+    minimumGasFee["interestRateUpdate"] = interestRateUpdate;
+    return minimumGasFee;
+}
+function parseSuccessActionNotificationMsgBody(cell) {
+    const ds = cell.beginParse();
+    const opCode = ds.loadUint(32);
+    const queryId = ds.loadUintBig(64);
+    const actionOpCode = ds.loadUint(32);
+    const errorCode = ds.loadUint(16);
+    const asset = ds.loadAddress();
+    const amount = ds.loadCoins();
+    const share = ds.loadCoins();
+    return {
+        opCode,
+        queryId,
+        actionOpCode,
+        errorCode,
+        asset,
+        amount,
+        share,
+        forwardPayload: ds,
+    };
+}
+function parseSuccessRepayActionNotificationMsgBody(cell) {
+    const ds = cell.beginParse();
+    const opCode = ds.loadUint(32);
+    const queryId = ds.loadUintBig(64);
+    const actionOpCode = ds.loadUint(32);
+    const errorCode = ds.loadUint(16);
+    const asset = ds.loadAddress();
+    const amount = ds.loadCoins();
+    const share = ds.loadCoins();
+    const overRepaidAmount = ds.loadCoins();
+    return {
+        opCode,
+        queryId,
+        actionOpCode,
+        errorCode,
+        asset,
+        amount,
+        share,
+        overRepaidAmount,
+        forwardPayload: ds,
+    };
+}
+function parseSuccessLiquidationActionNotificationMsgBody(cell) {
+    const ds = cell.beginParse();
+    const opCode = ds.loadUint(32);
+    const queryId = ds.loadUintBig(64);
+    const actionOpCode = ds.loadUint(32);
+    const errorCode = ds.loadUint(16);
+    const repayAsset = ds.loadAddress();
+    const seizeAsset = ds.loadAddress();
+    const repayAmount = ds.loadCoins();
+    const repayShare = ds.loadCoins();
+    const seizeShare = ds.loadCoins();
+    return {
+        opCode,
+        queryId,
+        actionOpCode,
+        errorCode,
+        repayAsset,
+        seizeAsset,
+        repayAmount,
+        repayShare,
+        seizeShare,
+        forwardPayload: ds,
+    };
+}
+function parseFailTransferOutActionNotificationMsgBody(cell) {
+    const ds = cell.beginParse();
+    const opCode = ds.loadUint(32);
+    const queryId = ds.loadUintBig(64);
+    const actionOpCode = ds.loadUint(32);
+    const errorCode = ds.loadUint(16);
+    const requestDs = ds.loadRef().beginParse();
+    const asset = requestDs.loadAddress();
+    const isShare = requestDs.loadBoolean();
+    const value = requestDs.loadCoins();
+    const recipient = requestDs.loadAddress();
+    const response = requestDs.loadAddress();
+    return {
+        opCode,
+        queryId,
+        actionOpCode,
+        errorCode,
+        asset,
+        isShare,
+        value,
+        recipient,
+        response,
+        forwardPayload: requestDs,
+    };
+}
+function parseFailTransferInActionNotificationMsgBody(cell) {
+    const ds = cell.beginParse();
+    const opCode = ds.loadUint(32);
+    const queryId = ds.loadUintBig(64);
+    const actionOpCode = ds.loadUint(32);
+    const errorCode = ds.loadUint(16);
+    const amount = ds.loadCoins();
+    const sender = ds.loadAddress();
+    const forwardDS = ds.loadRef().beginParse();
+    const recipient = forwardDS.loadAddress();
+    const subOp = forwardDS.loadUint(32);
+    const asset = forwardDS.loadAddress();
+    const response = forwardDS.loadAddress();
+    return {
+        opCode,
+        queryId,
+        actionOpCode: subOp,
+        errorCode,
+        sender,
+        amount,
+        recipient,
+        asset,
+        response,
+        forwardPayload: forwardDS,
+    };
+}
+function parseFailLiquidateActionNotificationMsgBody(cell) {
+    const ds = cell.beginParse();
+    const opCode = ds.loadUint(32);
+    const queryId = ds.loadUintBig(64);
+    const actionOpCode = ds.loadUint(32);
+    const errorCode = ds.loadUint(16);
+    const amount = ds.loadCoins();
+    const sender = ds.loadAddress();
+    const forwardDS = ds.loadRef().beginParse();
+    const borrower = forwardDS.loadAddress();
+    const subOp = forwardDS.loadUint(32);
+    const repayAsset = forwardDS.loadAddress();
+    const response = forwardDS.loadAddress();
+    if (forwardDS.remainingRefs >= 2) {
+        for (let i = 0; i < forwardDS.remainingRefs; i++) {
+            forwardDS.loadRef();
+        }
+    }
+    const liquidationDs = forwardDS.loadRef().beginParse();
+    const seizeAsset = liquidationDs.loadAddress();
+    return {
+        opCode,
+        queryId,
+        actionOpCode: subOp,
+        errorCode,
+        sender,
+        amount,
+        borrower,
+        response,
+        repayAsset,
+        seizeAsset,
+        forwardPayload: liquidationDs,
+    };
+}