@affluent-org/sdk 0.0.1

package/dist/contracts/liquid_token/stonfi/LFStonfiJettonWallet.js

@@ -0,0 +1,288 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LFStonfiJettonWallet = exports.Opcodes = void 0;
+exports.jettonWalletConfigToCell = jettonWalletConfigToCell;
+const core_1 = require("@ton/core");
+function jettonWalletConfigToCell(config) {
+    return (0, core_1.beginCell)()
+        .storeCoins(0)
+        .storeCoins(0)
+        .storeAddress(config.owner)
+        .storeUint(0, 4)
+        .storeRef((0, core_1.beginCell)().storeAddress(config.minter).storeAddress(config.lockedAsset).storeAddress(config.pool).endCell())
+        .endCell();
+}
+exports.Opcodes = {
+    Mint: 21,
+    InternalTransfer: 0x178d4519,
+    Transfer: 0xf8a7ea5,
+    Burn: 0x595f07bc,
+};
+class LFStonfiJettonWallet {
+    address;
+    init;
+    constructor(address, init) {
+        this.address = address;
+        this.init = init;
+    }
+    static Op = {
+        Mint: 21,
+        InternalTransfer: 0x178d4519,
+        Transfer: 0xf8a7ea5,
+        Burn: 0x595f07bc,
+        Initialize: 0xbe5a7595,
+        Seize: 0x7df57cb6,
+        SeizeInternal: 0x64486eca,
+        SeizeFail: 0x4cf20f42,
+        Farm: 0xb7a336e0,
+        Unfarm: 0x2f641bf0,
+        ConnectPoolAccount: 0x8d989d7d,
+        TransferNotification: 0x7362d09c,
+        SyncLockedAssetCash: 0x918b3e28,
+        ClaimRewards: 0x78d9f109,
+        WithdrawTons: 0x6d8e5e3c,
+        WithdrawJettons: 0x768a50b2,
+    };
+    static Error = {
+        UnknownOp: 0xffff,
+        WrongWorkchain: 333,
+        // Jetton Wallet Errors
+        UnauthorizedTransfer: 705,
+        NotEnoughJettons: 706,
+        UnauthorizedIncomingTransfer: 707,
+        MalformedForwardPayload: 708,
+        NotEnoughTons: 709,
+        BurnFeeNotMatched: 707,
+        UnknownAction: 0xffff,
+        UnknownActionBounced: 0xfff0,
+        // Jetton Minter Errors
+        DiscoveryFeeNotMatched: 75,
+        UnauthorizedMintRequest: 73,
+        UnauthorizedBurnRequest: 74,
+        UnauthorizedChangeAdminRequest: 76,
+        UnauthorizedChangeContentRequest: 77,
+        // Liquid Farm Errors
+        InvalidWalletAddress: 1000,
+        Unauthorized: 1001,
+        NotEnoughBalance: 1002,
+        NotEnoughLockedAssetBalance: 1003,
+        EnoughLockedAssetBalance: 1004,
+        NotEnoughLockedAssetCash: 1005,
+        SyncInProcess: 1006,
+        InvalidExpectCash: 1007,
+    };
+    static createFromAddress(address) {
+        return new LFStonfiJettonWallet(address);
+    }
+    static createFromConfig(config, code, workchain = 0) {
+        const data = jettonWalletConfigToCell(config);
+        const init = { code, data };
+        return new LFStonfiJettonWallet((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 sendInitialize(provider, via, value) {
+        await provider.internal(via, {
+            value,
+            sendMode: core_1.SendMode.PAY_GAS_SEPARATELY,
+            body: (0, core_1.beginCell)().storeUint(LFStonfiJettonWallet.Op.Initialize, 32).storeUint(0, 64).endCell(),
+        });
+    }
+    async sendConnectPoolAccount(provider, via, value) {
+        await provider.internal(via, {
+            value,
+            sendMode: core_1.SendMode.PAY_GAS_SEPARATELY,
+            body: (0, core_1.beginCell)().storeUint(LFStonfiJettonWallet.Op.ConnectPoolAccount, 32).storeUint(0, 64).endCell(),
+        });
+    }
+    async sendFarm(provider, via, value, opts) {
+        await provider.internal(via, {
+            value,
+            sendMode: core_1.SendMode.PAY_GAS_SEPARATELY,
+            body: (0, core_1.beginCell)()
+                .storeUint(LFStonfiJettonWallet.Op.Farm, 32)
+                .storeUint(opts.queryId ?? 0, 64)
+                .storeCoins(opts.amount)
+                .storeAddress(opts.response)
+                .storeCoins(opts.forwardTonAmount)
+                .endCell(),
+        });
+    }
+    async sendUnfarm(provider, via, value, opts) {
+        await provider.internal(via, {
+            value,
+            sendMode: core_1.SendMode.PAY_GAS_SEPARATELY,
+            body: (0, core_1.beginCell)()
+                .storeUint(LFStonfiJettonWallet.Op.Unfarm, 32)
+                .storeUint(opts.queryId ?? 0, 64)
+                .storeAddress(opts.nftAddress)
+                .endCell(),
+        });
+    }
+    async sendSyncLockedAssetCash(provider, via, value, opts) {
+        await provider.internal(via, {
+            value,
+            sendMode: core_1.SendMode.PAY_GAS_SEPARATELY,
+            body: (0, core_1.beginCell)()
+                .storeUint(LFStonfiJettonWallet.Op.SyncLockedAssetCash, 32)
+                .storeUint(opts.queryId ?? 0, 64)
+                .endCell(),
+        });
+    }
+    async sendTransferNotification(provider, via, opts) {
+        await provider.internal(via, {
+            value: opts.value,
+            sendMode: core_1.SendMode.PAY_GAS_SEPARATELY,
+            body: (0, core_1.beginCell)()
+                .storeUint(LFStonfiJettonWallet.Op.TransferNotification, 32) // opcode
+                .storeUint(opts.queryId ?? 0, 64) // query id
+                .storeCoins(opts.amount) //
+                .storeAddress(opts.fromAddress)
+                .endCell(),
+        });
+    }
+    async sendTransfer(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.Transfer, 32) // opcode
+                .storeUint(opts.queryId ?? 0, 64) // query id
+                .storeCoins(opts.amount)
+                .storeAddress(opts.recipient) //
+                .storeAddress(opts.response || opts.recipient)
+                .storeDict(null)
+                .storeCoins(opts.notificationGas ? opts.notificationGas : (0, core_1.toNano)(0.05)) // forward-ton-amount 이게 없으면 transfer_notification 호출 안될수도.
+                .storeMaybeRef(opts.additional)
+                .endCell(),
+        });
+    }
+    async sendBurn(provider, via, opts) {
+        await provider.internal(via, {
+            value: opts.value,
+            sendMode: core_1.SendMode.PAY_GAS_SEPARATELY,
+            body: (0, core_1.beginCell)()
+                .storeUint(opts.opcode ? opts.opcode : exports.Opcodes.Burn, 32) // opcode
+                .storeUint(opts.queryId ?? 0, 64) // query id
+                .storeCoins(opts.amount) //
+                .storeAddress(opts.recipientAddress)
+                .storeAddress(opts.responseAddress)
+                .endCell(),
+        });
+    }
+    async sendSeize(provider, via, opts) {
+        await provider.internal(via, {
+            value: opts.value,
+            sendMode: core_1.SendMode.PAY_GAS_SEPARATELY,
+            body: (0, core_1.beginCell)()
+                .storeUint(opts.opcode ? opts.opcode : LFStonfiJettonWallet.Op.Seize, 32) // opcode
+                .storeUint(opts.queryId ?? 0, 64) // query id
+                .storeCoins(opts.amount) //
+                .storeAddress(opts.targetAddress)
+                .storeAddress(opts.responseAddress)
+                .endCell(),
+        });
+    }
+    async sendClaimRewards(provider, via, opts) {
+        await provider.internal(via, {
+            value: opts.value,
+            sendMode: core_1.SendMode.PAY_GAS_SEPARATELY,
+            body: (0, core_1.beginCell)()
+                .storeUint(LFStonfiJettonWallet.Op.ClaimRewards, 32) // opcode
+                .storeUint(opts.queryId ?? 0, 64) // query id
+                .storeAddress(opts.nftAddress)
+                .storeBit(opts.claimAll) //
+                .storeUint(opts.poolIndex, 8)
+                .endCell(),
+        });
+    }
+    async sendWithdrawTons(provider, via, value, opts) {
+        await provider.internal(via, {
+            value: value,
+            sendMode: core_1.SendMode.PAY_GAS_SEPARATELY,
+            body: (0, core_1.beginCell)()
+                .storeUint(LFStonfiJettonWallet.Op.WithdrawTons, 32) // opcode
+                .storeUint(opts.queryId ?? 0, 64) // query id
+                .endCell(),
+        });
+    }
+    async sendWithdrawJettons(provider, via, value, opts) {
+        await provider.internal(via, {
+            value: value,
+            sendMode: core_1.SendMode.PAY_GAS_SEPARATELY,
+            body: (0, core_1.beginCell)()
+                .storeUint(LFStonfiJettonWallet.Op.WithdrawJettons, 32) // opcode
+                .storeUint(opts.queryId ?? 0, 64) // query id
+                .storeAddress(opts.wallet)
+                .storeCoins(opts.amount)
+                .storeBit(0)
+                .endCell(),
+        });
+    }
+    async getState(provider) {
+        return await provider.getState();
+    }
+    async getWalletData(provider) {
+        try {
+            const _result = await provider.get("get_wallet_data", []);
+            const balance = _result.stack.readBigNumber();
+            const owner = _result.stack.readAddress();
+            const jetton = _result.stack.readAddress();
+            return {
+                balance,
+                owner,
+                jetton,
+            };
+        }
+        catch (e) {
+            return {
+                balance: 0n,
+            };
+        }
+    }
+    async getLiquidFarmData(provider) {
+        try {
+            const _result = await provider.get("get_liquid_farm_data", []);
+            const balance = _result.stack.readBigNumber();
+            const lockedAssetBalance = _result.stack.readBigNumber();
+            const lockedAssetCash = _result.stack.readBigNumber();
+            const lockedAssetCashBeforeSync = _result.stack.readBigNumber();
+            const jettonAddress = _result.stack.readAddress();
+            const assetWalletAddress = _result.stack.readAddressOpt();
+            const poolAccountAddress = _result.stack.readAddressOpt();
+            const connectedWithPoolAccount = _result.stack.readBoolean();
+            const ownerAddress = _result.stack.readAddress();
+            const assetAddress = _result.stack.readAddress();
+            const poolAddress = _result.stack.readAddress();
+            return {
+                deployed: true,
+                balance,
+                lockedAssetBalance,
+                lockedAssetCash,
+                lockedAssetCashBeforeSync,
+                jettonAddress,
+                assetWalletAddress,
+                poolAccountAddress,
+                connectedWithPoolAccount,
+                ownerAddress,
+                assetAddress,
+                poolAddress,
+            };
+        }
+        catch (e) {
+            return {
+                deployed: false,
+                balance: 0n,
+                lockedAssetBalance: 0n,
+                lockedAssetCash: 0n,
+                lockedAssetCashBeforeSync: 0n,
+            };
+        }
+    }
+}
+exports.LFStonfiJettonWallet = LFStonfiJettonWallet;

package/dist/contracts/oracle/composite-onchain-oracle/index.d.ts

@@ -0,0 +1,108 @@
+import { Address, Cell, Contract, ContractProvider, Sender, Slice } from "@ton/core";
+export type CompositeOnchainOracleConfig = {
+    owner: Address;
+    dataAggregatorCode: Cell;
+};
+export declare function compositeOnchainOracleConfigToCell(config: CompositeOnchainOracleConfig): Cell;
+export declare class CompositeOnchainOracle implements Contract {
+    readonly address: Address;
+    readonly init?: {
+        code: Cell;
+        data: Cell;
+    } | undefined;
+    constructor(address: Address, init?: {
+        code: Cell;
+        data: Cell;
+    } | undefined);
+    static AssetType: {
+        currency: number;
+        synthetic1: number;
+        synthetic2: number;
+        vault: number;
+    };
+    static SourceType: {
+        internal: number;
+        tonstakers: number;
+        stonfi: number;
+        dedust: number;
+        storm: number;
+        tradoor: number;
+    };
+    static Op: {
+        ProvideOraclePrice: number;
+        TakeOraclePrice: number;
+    };
+    static OnchainSynthetic1AssetMetadata: {
+        new (params: {
+            sourceType: number;
+            sourceAddress: Address;
+            assetAddress: Address;
+            presetReserve?: bigint;
+            presetTotalSupply?: bigint;
+        }): {
+            sourceType: number;
+            sourceAddress: Address;
+            assetAddress: Address;
+            presetReserve: bigint;
+            presetTotalSupply: bigint;
+            toCell(): Cell;
+        };
+    };
+    static OnchainSynthetic2AssetMetadata: {
+        new (params: {
+            sourceType: number;
+            sourceAddress: Address;
+            assetAddress0: Address;
+            assetAddress1: Address;
+            presetReserve0?: bigint;
+            presetReserve1?: bigint;
+            presetTotalSupply?: bigint;
+        }): {
+            sourceType: number;
+            sourceAddress: Address;
+            assetAddress0: Address;
+            assetAddress1: Address;
+            presetReserve0: bigint;
+            presetReserve1: bigint;
+            presetTotalSupply: bigint;
+            toCell(): Cell;
+        };
+    };
+    static RedstoneNativeAssetMetadata: {
+        new (params: {
+            assetAddress: Address;
+            assetDecimals: number;
+        }): {
+            assetAddress: Address;
+            assetDecimals: number;
+            toCell(): Cell;
+        };
+    };
+    static RedstoneSynthetic1AssetMetadata: {
+        new (params: {
+            assetAddress: Address;
+            underlyingAssetAddress: Address;
+            assetDecimals: number;
+        }): {
+            assetAddress: Address;
+            underlyingAssetAddress: Address;
+            assetDecimals: number;
+            toCell(): Cell;
+        };
+    };
+    static createFromAddress(address: Address): CompositeOnchainOracle;
+    static createFromConfig(config: CompositeOnchainOracleConfig, code: Cell, workchain?: number): CompositeOnchainOracle;
+    sendDeploy(provider: ContractProvider, via: Sender, value: bigint): Promise<void>;
+    static createAddressToTupleCell(whitelists: Address[]): Cell;
+    sendProvideOraclePrice(provider: ContractProvider, via: Sender, opts: {
+        value: bigint;
+        oracleConfig: Cell;
+        oracleParams: Cell;
+        forwardPayload?: Slice;
+        queryID?: bigint;
+    }): Promise<void>;
+    getState(provider: ContractProvider): Promise<import("@ton/core").ContractState>;
+    getOwner(provider: ContractProvider): Promise<{
+        owner: Address | null;
+    }>;
+}

package/dist/contracts/oracle/composite-onchain-oracle/index.js

@@ -0,0 +1,185 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CompositeOnchainOracle = void 0;
+exports.compositeOnchainOracleConfigToCell = compositeOnchainOracleConfigToCell;
+const core_1 = require("@ton/core");
+function compositeOnchainOracleConfigToCell(config) {
+    return (0, core_1.beginCell)().storeCoins(0).storeAddress(config.owner).storeRef(config.dataAggregatorCode).endCell();
+}
+class CompositeOnchainOracle {
+    address;
+    init;
+    constructor(address, init) {
+        this.address = address;
+        this.init = init;
+    }
+    static AssetType = {
+        currency: 0,
+        synthetic1: 1,
+        synthetic2: 2,
+        vault: 10,
+    };
+    static SourceType = {
+        internal: 0,
+        tonstakers: 1,
+        stonfi: 2,
+        dedust: 3,
+        storm: 4,
+        tradoor: 5,
+    };
+    static Op = {
+        ProvideOraclePrice: 0x262964ae,
+        TakeOraclePrice: 0xba2968fa,
+    };
+    static OnchainSynthetic1AssetMetadata = class {
+        sourceType;
+        sourceAddress;
+        assetAddress;
+        presetReserve;
+        presetTotalSupply;
+        constructor(params) {
+            this.sourceType = params.sourceType;
+            this.sourceAddress = params.sourceAddress;
+            this.assetAddress = params.assetAddress;
+            this.presetReserve = params.presetReserve ?? 0n;
+            this.presetTotalSupply = params.presetTotalSupply ?? 0n;
+        }
+        toCell() {
+            return (0, core_1.beginCell)()
+                .storeUint(this.sourceType, 8)
+                .storeAddress(this.sourceAddress)
+                .storeUint(CompositeOnchainOracle.AssetType.synthetic1, 8)
+                .storeAddress(this.assetAddress)
+                .storeCoins(this.presetReserve)
+                .storeCoins(this.presetTotalSupply)
+                .endCell();
+        }
+    };
+    static OnchainSynthetic2AssetMetadata = class {
+        sourceType;
+        sourceAddress;
+        assetAddress0;
+        assetAddress1;
+        presetReserve0;
+        presetReserve1;
+        presetTotalSupply;
+        constructor(params) {
+            this.sourceType = params.sourceType;
+            this.sourceAddress = params.sourceAddress;
+            this.assetAddress0 = params.assetAddress0;
+            this.assetAddress1 = params.assetAddress1;
+            this.presetReserve0 = params.presetReserve0 ?? 0n;
+            this.presetReserve1 = params.presetReserve1 ?? 0n;
+            this.presetTotalSupply = params.presetTotalSupply ?? 0n;
+        }
+        toCell() {
+            return (0, core_1.beginCell)()
+                .storeUint(this.sourceType, 8)
+                .storeAddress(this.sourceAddress)
+                .storeUint(CompositeOnchainOracle.AssetType.synthetic2, 8)
+                .storeAddress(this.assetAddress0)
+                .storeAddress(this.assetAddress1)
+                .storeCoins(this.presetReserve0)
+                .storeCoins(this.presetReserve1)
+                .storeCoins(this.presetTotalSupply)
+                .endCell();
+        }
+    };
+    static RedstoneNativeAssetMetadata = class {
+        assetAddress;
+        assetDecimals;
+        constructor(params) {
+            this.assetAddress = params.assetAddress;
+            this.assetDecimals = params.assetDecimals;
+        }
+        toCell() {
+            return (0, core_1.beginCell)()
+                .storeUint(CompositeOnchainOracle.AssetType.currency, 8)
+                .storeAddress(this.assetAddress)
+                .storeCoins(this.assetDecimals)
+                .endCell();
+        }
+    };
+    static RedstoneSynthetic1AssetMetadata = class {
+        assetAddress;
+        underlyingAssetAddress;
+        assetDecimals;
+        constructor(params) {
+            this.assetAddress = params.assetAddress;
+            this.underlyingAssetAddress = params.underlyingAssetAddress;
+            this.assetDecimals = params.assetDecimals;
+        }
+        toCell() {
+            return (0, core_1.beginCell)()
+                .storeUint(CompositeOnchainOracle.AssetType.synthetic1, 8)
+                .storeAddress(this.assetAddress)
+                .storeUint(CompositeOnchainOracle.AssetType.synthetic1, 8)
+                .storeAddress(this.underlyingAssetAddress)
+                .storeCoins(this.assetDecimals)
+                .endCell();
+        }
+    };
+    static createFromAddress(address) {
+        return new CompositeOnchainOracle(address);
+    }
+    static createFromConfig(config, code, workchain = 0) {
+        const data = compositeOnchainOracleConfigToCell(config);
+        const init = { code, data };
+        return new CompositeOnchainOracle((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(),
+        });
+    }
+    static createAddressToTupleCell(whitelists) {
+        if (whitelists.length === 0) {
+            return (0, core_1.beginCell)().storeUint(0, 2).endCell();
+        }
+        // 13982176438608211n
+        // 14502560648720
+        const chunkedWhitelists = [];
+        for (let i = 0; i < whitelists.length; i += 3) {
+            chunkedWhitelists.push(whitelists.slice(i, i + 3));
+        }
+        const cells = chunkedWhitelists.map((chunk) => {
+            let cell = (0, core_1.beginCell)();
+            cell = cell.storeUint(chunk.length, 2);
+            chunk.forEach((address) => {
+                cell = cell.storeAddress(address);
+            });
+            return cell;
+        });
+        const finalCell = cells.reduce((acc, cur) => {
+            return acc ? cur.storeRef(acc) : cur;
+        }, null);
+        return finalCell?.endCell() || (0, core_1.beginCell)().storeUint(0, 2).endCell();
+    }
+    async sendProvideOraclePrice(provider, via, opts) {
+        let body = (0, core_1.beginCell)()
+            .storeUint(CompositeOnchainOracle.Op.ProvideOraclePrice, 32)
+            .storeUint(opts.queryID ?? 0, 64)
+            .storeRef((0, core_1.beginCell)().storeRef(opts.oracleConfig).storeRef(opts.oracleParams).endCell());
+        if (opts.forwardPayload) {
+            body = body.storeSlice(opts.forwardPayload);
+        }
+        await provider.internal(via, {
+            value: opts.value,
+            sendMode: core_1.SendMode.PAY_GAS_SEPARATELY,
+            body: body.endCell(),
+        });
+    }
+    async getState(provider) {
+        return await provider.getState();
+    }
+    async getOwner(provider) {
+        const result = await provider.get("get_owner", []);
+        const owner = result.stack.readAddressOpt();
+        return {
+            owner,
+        };
+    }
+}
+exports.CompositeOnchainOracle = CompositeOnchainOracle;

package/dist/contracts/oracle/parser.d.ts

@@ -0,0 +1,7 @@
+import { Cell } from "@ton/core";
+export declare function parseOracleConfig(cell: Cell): Cell | import("./redstone-onchain-oracle/type").RedstoneOnchainOracleConfig | import("./redstone-oracle/type").RedstonOracleConfig;
+export declare function parseOracleParams(cell: Cell): {
+    dataFeedIds: import("@ton/core").TupleItem[];
+    prices: Record<string, string[]>;
+    requestAssetCell: Cell;
+};

package/dist/contracts/oracle/parser.js

@@ -0,0 +1,77 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseOracleConfig = parseOracleConfig;
+exports.parseOracleParams = parseOracleParams;
+const core_1 = require("@ton/core");
+const serializer_1 = require("./redstone-onchain-oracle/serializer");
+const serializer_2 = require("./redstone-oracle/serializer");
+const redstone_parser_1 = require("./redstone-parser");
+function parseOracleConfig(cell) {
+    try {
+        return (0, serializer_1.parseRedstoneOnchainOracleConfig)(cell);
+    }
+    catch (e) { }
+    try {
+        return (0, serializer_2.parseRedstoneOracleConfig)(cell);
+    }
+    catch (e) { }
+    return cell;
+}
+function parseOracleParams(cell) {
+    const cs = cell.beginParse();
+    const dataFeedIdsCell = cs.loadRef();
+    const payloadRef = cs.loadRef();
+    const requestAssetCell = cs.loadRef();
+    const dataFeedIds = (0, core_1.parseTuple)(dataFeedIdsCell);
+    // const payloadRef = oracleParamsCs.loadRef();
+    const prices = {};
+    try {
+        const payloadCs = payloadRef.beginParse();
+        const dataPackagesDictRef = payloadCs.loadRef();
+        const slice = () => ({
+            serialize: (src, builder) => { },
+            parse: (src) => {
+                return src;
+            },
+        });
+        // Parse data packages dictionary (key length is 16 bits)
+        const dataPackagesDict = dataPackagesDictRef.beginParse().loadDictDirect(core_1.Dictionary.Keys.Uint(16), slice());
+        // Parse each data package to extract price only
+        for (const [, packageCs] of dataPackagesDict) {
+            // console.log(dataPackageCell);
+            try {
+                // const packageCs = dataPackageCell.beginParse();
+                // Read signature
+                const signatureR = packageCs.loadUintBig(256);
+                const signatureS = packageCs.loadUintBig(256);
+                const signatureV = packageCs.loadUint(8);
+                const dataRef = packageCs.loadRef();
+                // Convert to hex format expected by parseDataPackageHex
+                const dataCs = dataRef.beginParse();
+                const dataHex = dataCs.loadBuffer(dataCs.remainingBits / 8).toString("hex");
+                const signatureHex = signatureR.toString(16).padStart(64, "0") +
+                    signatureS.toString(16).padStart(64, "0") +
+                    signatureV.toString(16).padStart(2, "0");
+                // parseDataPackageHex expects: data + signature
+                const parsed = (0, redstone_parser_1.parseDataPackageHex)(dataHex + signatureHex);
+                if (!prices[parsed.feedId.toString()]) {
+                    prices[parsed.feedId.toString()] = [];
+                }
+                prices[parsed.feedId.toString()].push(parsed.price.toString());
+            }
+            catch (e) {
+                console.log(e);
+                // Skip failed package parsing
+            }
+        }
+    }
+    catch (e) {
+        console.log("parse Prices error");
+        console.log(e);
+    }
+    return {
+        dataFeedIds,
+        prices,
+        requestAssetCell,
+    };
+}