@affluent-org/sdk 0.0.1

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

@@ -0,0 +1,56 @@
+import { Address, Cell, Contract, ContractProvider, Sender, Slice } from "@ton/core";
+import { RedstoneOnchainOracleConfig } from "./type";
+export type InitRedstoneOnchainOracleConfig = {
+    owner: Address;
+    reserveAggregatorCode: Cell;
+};
+export declare function redstonOnchainOracleConfigToCell(config: InitRedstoneOnchainOracleConfig): Cell;
+export declare class RedstoneOnchainOracle 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;
+    };
+    static SourceType: {
+        internal: number;
+        tonstakers: number;
+        stonfi: number;
+        dedust: number;
+        storm: number;
+        tradoor: number;
+    };
+    static Op: {
+        ProvideOraclePrice: number;
+        TakeOraclePrice: number;
+    };
+    static createFromAddress(address: Address): RedstoneOnchainOracle;
+    static createFromConfig(config: InitRedstoneOnchainOracleConfig, code: Cell, workchain?: number): RedstoneOnchainOracle;
+    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;
+    }>;
+    static getOracleRequestParams(assets: string[] | Address[], config: RedstoneOnchainOracleConfig): {
+        feedIds: bigint[];
+        redstoneAssetNames: any[];
+        requestAssets: Address[];
+        redstoneAssets: Address[];
+    };
+}

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

@@ -0,0 +1,159 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RedstoneOnchainOracle = void 0;
+exports.redstonOnchainOracleConfigToCell = redstonOnchainOracleConfigToCell;
+const core_1 = require("@ton/core");
+const NAME_MAP = {
+    "5525326": "TON",
+    "1431520340": "USDT",
+    "39287100404874731933245616043935197839692": "stTON_FUNDAMENTAL",
+    "39626053543799885480836086844306685706572": "tsTON_FUNDAMENTAL",
+    "1431520357": "USDe",
+    "10144271057007612894112390016889590732046668": "tsUSDe_FUNDAMENTAL",
+    "5783893": "XAU",
+    "4346947": "BTC",
+    "495352759397": "sUSDe",
+};
+function redstonOnchainOracleConfigToCell(config) {
+    return (0, core_1.beginCell)().storeCoins(0).storeAddress(config.owner).storeRef(config.reserveAggregatorCode).endCell();
+}
+class RedstoneOnchainOracle {
+    address;
+    init;
+    constructor(address, init) {
+        this.address = address;
+        this.init = init;
+    }
+    static AssetType = {
+        currency: 0,
+        synthetic1: 1,
+        synthetic2: 2,
+    };
+    static SourceType = {
+        internal: 0,
+        tonstakers: 1,
+        stonfi: 2,
+        dedust: 3,
+        storm: 4,
+        tradoor: 5,
+    };
+    static Op = {
+        ProvideOraclePrice: 0x262964ae,
+        TakeOraclePrice: 0xba2968fa,
+    };
+    static createFromAddress(address) {
+        return new RedstoneOnchainOracle(address);
+    }
+    static createFromConfig(config, code, workchain = 0) {
+        const data = redstonOnchainOracleConfigToCell(config);
+        const init = { code, data };
+        return new RedstoneOnchainOracle((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();
+        }
+        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(RedstoneOnchainOracle.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,
+        };
+    }
+    static getOracleRequestParams(assets, config) {
+        const redstoneFeedIds = [];
+        const _redstoneAssets = new Set();
+        const _requestAssets = [];
+        const redstoneAssetsMap = Object.entries(config.redstoneAssetInfo).reduce((acc, [feedId, info]) => {
+            return { ...acc, [info.address.toString()]: feedId };
+        }, {});
+        while (assets.length != 0) {
+            const newAssets = [];
+            for (let asset of assets) {
+                asset = asset.toString();
+                if (!config.assetOnchainDataInfo[asset] && !redstoneAssetsMap[asset]) {
+                    continue;
+                }
+                if (redstoneAssetsMap[asset]) {
+                    redstoneFeedIds.push(redstoneAssetsMap[asset]);
+                    _redstoneAssets.add(asset);
+                    const assetInfo = Object.values(config.redstoneAssetInfo).find((item) => item.address.equals(core_1.Address.parse(asset)));
+                    if (assetInfo.assetType === RedstoneOnchainOracle.AssetType.currency) {
+                    }
+                    else if (assetInfo.assetType === RedstoneOnchainOracle.AssetType.synthetic1 &&
+                        "underlyingAddress" in assetInfo) {
+                        newAssets.push(assetInfo.underlyingAddress);
+                    }
+                    else if (assetInfo.assetType === RedstoneOnchainOracle.AssetType.synthetic2 &&
+                        "underlying0Address" in assetInfo) {
+                        newAssets.push(assetInfo.underlying0Address);
+                        newAssets.push(assetInfo.underlying1Address);
+                    }
+                }
+                else {
+                    _requestAssets.push(asset);
+                    const assetInfo = config.assetOnchainDataInfo[asset];
+                    if (assetInfo.assetType === RedstoneOnchainOracle.AssetType.currency) {
+                    }
+                    else if (assetInfo.assetType === RedstoneOnchainOracle.AssetType.synthetic1 &&
+                        "underlyingAddress" in assetInfo) {
+                        newAssets.push(assetInfo.underlyingAddress);
+                    }
+                    else if (assetInfo.assetType === RedstoneOnchainOracle.AssetType.synthetic2 &&
+                        "underlying0Address" in assetInfo) {
+                        newAssets.push(assetInfo.underlying0Address);
+                        newAssets.push(assetInfo.underlying1Address);
+                    }
+                }
+            }
+            assets = newAssets;
+        }
+        const feedIds = [...new Set(redstoneFeedIds)].map((item) => BigInt(item));
+        const redstoneAssetNames = [...new Set(redstoneFeedIds)].map((item) => NAME_MAP[item]);
+        const requestAssets = [...new Set(_requestAssets)].map((item) => core_1.Address.parse(item));
+        const redstoneAssets = [...new Set(_redstoneAssets)].map((item) => core_1.Address.parse(item));
+        return { feedIds, redstoneAssetNames, requestAssets, redstoneAssets };
+    }
+}
+exports.RedstoneOnchainOracle = RedstoneOnchainOracle;

package/dist/contracts/oracle/redstone-onchain-oracle/serializer.d.ts

@@ -0,0 +1,4 @@
+import { Cell } from "@ton/core";
+import { RedstoneOnchainOracleConfig } from "./type";
+export declare function parseRedstoneOnchainOracleConfig(cell: Cell): RedstoneOnchainOracleConfig;
+export declare function serializeRedstoneOnchainOracleConfig(config: RedstoneOnchainOracleConfig): Cell;

package/dist/contracts/oracle/redstone-onchain-oracle/serializer.js

@@ -0,0 +1,137 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseRedstoneOnchainOracleConfig = parseRedstoneOnchainOracleConfig;
+exports.serializeRedstoneOnchainOracleConfig = serializeRedstoneOnchainOracleConfig;
+const core_1 = require("@ton/core");
+const _1 = require(".");
+function parseRedstoneOnchainOracleConfig(cell) {
+    const ds = cell.beginParse();
+    const redstoneAssetInfoDict = ds.loadDict(core_1.Dictionary.Keys.BigUint(256), core_1.Dictionary.Values.Cell());
+    const threshold = ds.loadCoins();
+    const signerCell = ds.loadRef();
+    const signersTuple = threshold ? (0, core_1.parseTuple)(signerCell) : [];
+    const signers = signersTuple
+        .filter((item) => item.type === "int")
+        .map((item) => {
+        return item.value.toString(16);
+    });
+    const redstoneAssetInfo = {};
+    redstoneAssetInfoDict.keys().forEach((key) => {
+        const ds2 = redstoneAssetInfoDict.get(key)?.beginParse();
+        if (ds2) {
+            const assetType = ds2.loadUint(8);
+            if (assetType === 0) {
+                const address = ds2.loadAddress();
+                const precision = ds2.loadCoins();
+                redstoneAssetInfo[key.toString()] = { assetType, address, precision };
+            }
+            else if (assetType === 1) {
+                const address = ds2.loadAddress();
+                const underlyingAddress = ds2.loadAddress();
+                const precision = ds2.loadCoins();
+                redstoneAssetInfo[key.toString()] = { assetType, address, underlyingAddress, precision };
+            }
+        }
+    });
+    const onchainDataInfoDict = ds.loadDict(core_1.Dictionary.Keys.Address(), core_1.Dictionary.Values.Cell());
+    const assetOnchainDataInfo = {};
+    onchainDataInfoDict.keys().forEach((key) => {
+        const ds2 = onchainDataInfoDict.get(key)?.beginParse();
+        if (ds2) {
+            const data = {};
+            data.sourceType = ds2.loadUint(8);
+            data.sourceAddress = ds2.loadMaybeAddress();
+            data.assetType = ds2.loadUint(8);
+            if (data.assetType === _1.RedstoneOnchainOracle.AssetType.currency) {
+                try {
+                    data.price = ds2.loadCoins();
+                }
+                catch (e) { }
+            }
+            else if (data.assetType === _1.RedstoneOnchainOracle.AssetType.synthetic1) {
+                data.underlyingAddress = ds2.loadAddress();
+                try {
+                    data.underlyingReserve = ds2.loadCoins();
+                }
+                catch (e) { }
+                try {
+                    data.totalSupply = ds2.loadCoins();
+                }
+                catch (e) { }
+            }
+            else if (data.assetType === _1.RedstoneOnchainOracle.AssetType.synthetic2) {
+                data.underlying0Address = ds2.loadAddress();
+                data.underlying1Address = ds2.loadAddress();
+                try {
+                    data.underlying0Reserve = ds2.loadCoins();
+                }
+                catch (e) { }
+                try {
+                    data.underlying1Reserve = ds2.loadCoins();
+                }
+                catch (e) { }
+                try {
+                    data.totalSupply = ds2.loadCoins();
+                }
+                catch (e) { }
+            }
+            assetOnchainDataInfo[key.toString()] = data;
+        }
+    });
+    return {
+        signers: signers,
+        threshold,
+        redstoneAssetInfo,
+        assetOnchainDataInfo,
+    };
+}
+function serializeRedstoneOnchainOracleConfig(config) {
+    const redstoneAssetInfoDict = core_1.Dictionary.empty(core_1.Dictionary.Keys.BigUint(256), core_1.Dictionary.Values.Cell());
+    Object.entries(config.redstoneAssetInfo).forEach(([a, b]) => {
+        const key = BigInt(a);
+        if (b.assetType === 0) {
+            const value = (0, core_1.beginCell)().storeUint(b.assetType, 8).storeAddress(b.address).storeCoins(b.precision);
+            redstoneAssetInfoDict.set(key, value.endCell());
+        }
+        else if (b.assetType === 1) {
+            const value = (0, core_1.beginCell)()
+                .storeUint(b.assetType, 8)
+                .storeAddress(b.address)
+                .storeAddress(b.underlyingAddress)
+                .storeCoins(b.precision);
+            redstoneAssetInfoDict.set(key, value.endCell());
+        }
+    });
+    const assetOnchainDataInfoDict = core_1.Dictionary.empty(core_1.Dictionary.Keys.Address(), core_1.Dictionary.Values.Cell());
+    Object.entries(config.assetOnchainDataInfo).forEach(([a, b]) => {
+        const key = BigInt(a);
+        let value = (0, core_1.beginCell)().storeUint(b.sourceType, 8).storeAddress(b.sourceAddress).storeCoins(b.assetType);
+        if (b.assetType === _1.RedstoneOnchainOracle.AssetType.currency) {
+        }
+        else if (b.assetType === _1.RedstoneOnchainOracle.AssetType.synthetic1) {
+            value = value.storeAddress(b.underlyingAddress);
+            value = value.storeCoins(b.underlyingReserve);
+            value = value.storeCoins(b.totalSupply);
+        }
+        else if (b.assetType === _1.RedstoneOnchainOracle.AssetType.synthetic2) {
+            value = value
+                .storeAddress(b.underlying0Address)
+                .storeAddress(b.underlying1Address)
+                .storeCoins(b.underlying0Reserve)
+                .storeCoins(b.underlying1Reserve)
+                .storeCoins(b.totalSupply);
+        }
+    });
+    const tuple = new core_1.TupleBuilder();
+    for (let signer of config.signers) {
+        tuple.writeNumber(BigInt("0x" + signer));
+    }
+    const signers = (0, core_1.serializeTuple)(tuple.build());
+    const oracleConfig = (0, core_1.beginCell)()
+        .storeDict(redstoneAssetInfoDict)
+        .storeCoins(config.threshold)
+        .storeRef(signers)
+        .storeDict(assetOnchainDataInfoDict)
+        .endCell();
+    return oracleConfig;
+}

package/dist/contracts/oracle/redstone-onchain-oracle/type.d.ts

@@ -0,0 +1,57 @@
+import { Address } from "@ton/core";
+export type RedstoneOnchainOracleConfig = {
+    signers: string[];
+    threshold: bigint;
+    redstoneAssetInfo: Record<string, {
+        assetType: number;
+        address: Address;
+        precision: bigint;
+    }>;
+    assetOnchainDataInfo: OnchainDataInfo;
+};
+export declare enum OnchainDataSourceType {
+    Internal = 0,
+    Tonstakers = 1,
+    Stonfi = 2,
+    Dedust = 3,
+    Bemo = 4
+}
+export declare enum AssetType {
+    Native = 0,
+    SingleAsset = 1,
+    MultiAsset = 2,
+    VaultAsset = 10
+}
+export type OnchainDataInfoBase = {
+    sourceType: OnchainDataSourceType;
+    sourceAddress: Address;
+    assetType: AssetType;
+};
+export type OnchainDataInfoNative = OnchainDataInfoBase & {
+    assetType: AssetType.Native;
+};
+export type OnchainDataInfoSingleAsset = OnchainDataInfoBase & {
+    assetType: AssetType.SingleAsset;
+    underlyingAddress: Address;
+    underlyingReserve?: bigint;
+    totalSupply?: bigint;
+};
+export type OnchainDataInfoMultiAsset = OnchainDataInfoBase & {
+    assetType: AssetType.MultiAsset;
+    underlying0Address: Address;
+    underlying1Address: Address;
+    underlying0Reserve?: bigint;
+    underlying1Reserve?: bigint;
+    totalSupply?: bigint;
+};
+export type OnchainDataInfoInternal = OnchainDataInfoBase & {
+    price: bigint;
+};
+export type OnchainData = OnchainDataInfoNative | OnchainDataInfoSingleAsset | OnchainDataInfoMultiAsset;
+export type OnchainDataInfo = Record<string, OnchainData>;
+export type AssetPriceInfo = Record<string, AssetPrice>;
+export type AssetPrice = {
+    type: AssetType;
+    price: bigint;
+    timestamp?: number;
+};

package/dist/contracts/oracle/redstone-onchain-oracle/type.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AssetType = exports.OnchainDataSourceType = void 0;
+var OnchainDataSourceType;
+(function (OnchainDataSourceType) {
+    OnchainDataSourceType[OnchainDataSourceType["Internal"] = 0] = "Internal";
+    OnchainDataSourceType[OnchainDataSourceType["Tonstakers"] = 1] = "Tonstakers";
+    OnchainDataSourceType[OnchainDataSourceType["Stonfi"] = 2] = "Stonfi";
+    OnchainDataSourceType[OnchainDataSourceType["Dedust"] = 3] = "Dedust";
+    OnchainDataSourceType[OnchainDataSourceType["Bemo"] = 4] = "Bemo";
+})(OnchainDataSourceType || (exports.OnchainDataSourceType = OnchainDataSourceType = {}));
+var AssetType;
+(function (AssetType) {
+    AssetType[AssetType["Native"] = 0] = "Native";
+    AssetType[AssetType["SingleAsset"] = 1] = "SingleAsset";
+    AssetType[AssetType["MultiAsset"] = 2] = "MultiAsset";
+    AssetType[AssetType["VaultAsset"] = 10] = "VaultAsset";
+})(AssetType || (exports.AssetType = AssetType = {}));

package/dist/contracts/oracle/redstone-oracle/serializer.d.ts

@@ -0,0 +1,3 @@
+import { Cell } from "@ton/core";
+import { RedstonOracleConfig } from "./type";
+export declare function parseRedstoneOracleConfig(cell: Cell): RedstonOracleConfig;

package/dist/contracts/oracle/redstone-oracle/serializer.js

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseRedstoneOracleConfig = parseRedstoneOracleConfig;
+const core_1 = require("@ton/core");
+function parseRedstoneOracleConfig(cell) {
+    const ds = cell.beginParse();
+    const assetInfoDict = ds.loadDict(core_1.Dictionary.Keys.Uint(64), core_1.Dictionary.Values.Cell());
+    const threshold = ds.loadCoins();
+    const signerCell = ds.loadRef();
+    const signersTuple = threshold ? (0, core_1.parseTuple)(signerCell) : [];
+    const signers = signersTuple
+        .filter((item) => item.type === "int")
+        .map((item) => {
+        return item.value.toString(16);
+    });
+    const assetInfo = {};
+    assetInfoDict.keys().forEach((key) => {
+        const ds2 = assetInfoDict.get(key)?.beginParse();
+        if (ds2) {
+            const address = ds2.loadAddress();
+            const precision = ds2.loadCoins();
+            assetInfo[key] = { address, precision };
+        }
+    });
+    return {
+        signers: signers,
+        threshold,
+        assetInfo,
+    };
+}

package/dist/contracts/oracle/redstone-oracle/type.d.ts

@@ -0,0 +1,9 @@
+import { Address } from "@ton/core";
+export type RedstonOracleConfig = {
+    signers: string[];
+    threshold: bigint;
+    assetInfo: Record<string, {
+        address: Address;
+        precision: bigint;
+    }>;
+};

package/dist/contracts/oracle/redstone-oracle/type.js

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

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

@@ -0,0 +1,9 @@
+/**
+ * Parse a Redstone data package from hex string
+ * Pure parsing function - no external dependencies beyond @ton/core and @redstone-finance/protocol
+ */
+export declare function parseDataPackageHex(dataPackageHex: string): {
+    timestamp: bigint;
+    price: bigint;
+    feedId: bigint;
+};

package/dist/contracts/oracle/redstone-parser.js

@@ -0,0 +1,58 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseDataPackageHex = parseDataPackageHex;
+const core_1 = require("@ton/core");
+const protocol_1 = require("@redstone-finance/protocol");
+const assert_1 = require("../../lib/assert");
+/**
+ * Parse a Redstone data package from hex string
+ * Pure parsing function - no external dependencies beyond @ton/core and @redstone-finance/protocol
+ */
+function parseDataPackageHex(dataPackageHex) {
+    const data = dataPackageHex.substring(0, dataPackageHex.length - 2 * protocol_1.consts.SIGNATURE_BS);
+    const signature = dataPackageHex.substring(dataPackageHex.length - 2 * protocol_1.consts.SIGNATURE_BS, dataPackageHex.length);
+    const v = BigInt("0x" + signature.substring(128, 130));
+    (0, assert_1.assert)([27, 28].map(BigInt).includes(v), `Wrong signature 'v' value (${v})`);
+    const dataCell = (0, core_1.beginCell)()
+        .storeBuffer(Buffer.from(stringToBytes("0x" + data)))
+        .endCell();
+    let skipLastBit = protocol_1.consts.DATA_POINTS_COUNT_BS * 8;
+    const dataPointsCount = dataCell
+        .asSlice()
+        .skip(dataCell.bits.length - skipLastBit)
+        .loadUintBig(protocol_1.consts.DATA_POINTS_COUNT_BS * 8);
+    skipLastBit += protocol_1.consts.DATA_POINT_VALUE_BYTE_SIZE_BS * 8;
+    const dataPointValueByteSize = dataCell
+        .asSlice()
+        .skip(dataCell.bits.length - skipLastBit)
+        .loadUintBig(protocol_1.consts.DATA_POINT_VALUE_BYTE_SIZE_BS * 8);
+    skipLastBit += protocol_1.consts.TIMESTAMP_BS * 8;
+    const timestamp = dataCell
+        .asSlice()
+        .skip(dataCell.bits.length - skipLastBit)
+        .loadUintBig(protocol_1.consts.TIMESTAMP_BS * 8);
+    skipLastBit += Number(dataPointValueByteSize) * 8;
+    const value = dataCell
+        .asSlice()
+        .skip(dataCell.bits.length - skipLastBit)
+        .loadUintBig(Number(dataPointValueByteSize) * 8);
+    let feedId = dataCell.asSlice().loadUintBig(protocol_1.consts.DATA_FEED_ID_BS * 8);
+    if (feedId != 0n) {
+        while (feedId == (feedId / 256n) * 256n) {
+            feedId = feedId / 256n;
+        }
+    }
+    return {
+        timestamp,
+        price: value,
+        feedId,
+    };
+}
+function stringToBytes(value) {
+    const hexArray = value
+        .slice(2)
+        .match(/.{1,2}/g)
+        ?.map((byte) => parseInt(byte, 16));
+    const buffer = Buffer.from(hexArray);
+    return buffer;
+}