@affluent-org/sdk 0.0.2 → 0.0.3

package/dist/utils/oracle/redstone/helper.js

@@ -0,0 +1,186 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RedstoneHelper = void 0;
+exports.storeMetadata = storeMetadata;
+exports.splitPayloadHex = splitPayloadHex;
+exports.stringToBytes = stringToBytes;
+exports.storeSignatureAndData = storeSignatureAndData;
+exports.parseDataPackageHex = parseDataPackageHex;
+const protocol_1 = require("@redstone-finance/protocol");
+const sdk_1 = require("@redstone-finance/sdk");
+const core_1 = require("@ton/core");
+const serializeDict_1 = require("@ton/core/dist/dict/serializeDict");
+const assert_1 = require("../../assert");
+function storeMetadata(metadataHex, builder) {
+    const maxUnsignedDataLength = Math.floor(builder.availableBits / 8 -
+        (protocol_1.consts.REDSTONE_MARKER_BS +
+            protocol_1.consts.DATA_PACKAGES_COUNT_BS +
+            protocol_1.consts.UNSIGNED_METADATA_BYTE_SIZE_BS));
+    (0, assert_1.assert)(builder.availableBits >= metadataHex.length * 8, `Not enough bits available for metadata in builder. Unsigned metadata for this payload must not be larger than ${maxUnsignedDataLength}.`);
+    builder.storeBuilder(createBuilderFromString(metadataHex));
+}
+function createBuilderFromString(value) {
+    return (0, core_1.beginCell)().storeBuffer(Buffer.from(stringToBytes(value.startsWith("0x") ? value : "0x" + value)));
+}
+class RedstoneHelper {
+    dataServiceId;
+    uniqueSignersCount;
+    constructor(type) {
+        this.dataServiceId =
+            type === "demo" ? "redstone-main-demo" : "redstone-primary-prod";
+        this.uniqueSignersCount = type === "demo" ? 1 : 5;
+    }
+    /////////////////////////////////////////////
+    /////////////// CREATE PAYLOAD //////////////
+    async createPayload(assets) {
+        const paramsProvider = new sdk_1.ContractParamsProvider({
+            dataServiceId: this.dataServiceId,
+            uniqueSignersCount: this.uniqueSignersCount,
+            dataPackagesIds: assets,
+        });
+        const payloadHex = await paramsProvider.getPayloadHex(false);
+        const { dataPackageChunks, metadata } = splitPayloadHex(payloadHex);
+        const payloadCell = (0, core_1.beginCell)();
+        const cells = new Map();
+        for (let i = 0; i < dataPackageChunks.length; i++) {
+            cells.set(BigInt(i), dataPackageChunks[i]);
+        }
+        const dataPackagesDict = (0, core_1.beginCell)();
+        const BASE_KEY_LEN = 16;
+        (0, serializeDict_1.serializeDict)(cells, BASE_KEY_LEN, storeSignatureAndData, dataPackagesDict);
+        payloadCell.storeRef(dataPackagesDict);
+        storeMetadata(metadata, payloadCell);
+        return payloadCell.endCell();
+    }
+    async getPrices(assets) {
+        const paramsProvider = new sdk_1.ContractParamsProvider({
+            dataServiceId: this.dataServiceId,
+            uniqueSignersCount: this.uniqueSignersCount,
+            dataPackagesIds: assets,
+        });
+        const payloadHex = await paramsProvider.getPayloadHex(false);
+        const { dataPackageChunks, metadata } = splitPayloadHex(payloadHex);
+        const result = [];
+        for (let i = 0; i < dataPackageChunks.length; i++) {
+            result.push({
+                name: assets[i],
+                ...parseDataPackageHex(dataPackageChunks[i]),
+            });
+        }
+        return result;
+    }
+    /////////////////////////////////////////////
+    ////////////// CREATE FEED_IDS //////////////
+    getHexlifiedFeedIds(assets) {
+        const paramsProvider = new sdk_1.ContractParamsProvider({
+            dataServiceId: this.dataServiceId,
+            uniqueSignersCount: this.uniqueSignersCount,
+            dataPackagesIds: assets,
+        });
+        return paramsProvider.getHexlifiedFeedIds();
+    }
+    getDataFeedIdTuples(assets) {
+        const dataFeedIdsTupleBuilder = new core_1.TupleBuilder();
+        this.getHexlifiedFeedIds(assets).forEach((item) => dataFeedIdsTupleBuilder.writeNumber(BigInt(item)));
+        return (0, core_1.serializeTuple)(dataFeedIdsTupleBuilder.build());
+    }
+}
+exports.RedstoneHelper = RedstoneHelper;
+function splitPayloadHex(payloadHex) {
+    //TODO: assert value size == 32;
+    const DATA_PACKAGE_BS = protocol_1.consts.DATA_FEED_ID_BS +
+        protocol_1.consts.DEFAULT_NUM_VALUE_BS +
+        protocol_1.consts.TIMESTAMP_BS +
+        protocol_1.consts.DATA_POINTS_COUNT_BS +
+        protocol_1.consts.DATA_POINT_VALUE_BYTE_SIZE_BS +
+        protocol_1.consts.SIGNATURE_BS;
+    const unsignedMetadataBS = new BigNumber("0x" +
+        payloadHex.substring(payloadHex.length -
+            2 *
+                (protocol_1.consts.REDSTONE_MARKER_BS + protocol_1.consts.UNSIGNED_METADATA_BYTE_SIZE_BS), payloadHex.length - 2 * protocol_1.consts.REDSTONE_MARKER_BS)).toNumber();
+    const metadataBS = protocol_1.consts.REDSTONE_MARKER_BS +
+        protocol_1.consts.UNSIGNED_METADATA_BYTE_SIZE_BS +
+        unsignedMetadataBS +
+        protocol_1.consts.DATA_PACKAGES_COUNT_BS;
+    const metadata = payloadHex.substring(payloadHex.length - 2 * metadataBS, payloadHex.length);
+    const dataPackageCount = new BigNumber("0x" + metadata.substring(0, protocol_1.consts.DATA_PACKAGES_COUNT_BS * 2)).toNumber();
+    if (payloadHex.length - 2 * metadataBS !=
+        2 * DATA_PACKAGE_BS * dataPackageCount) {
+        throw "Must be implemented for multi-datapoint packages";
+    }
+    const dataPackageChunks = [];
+    for (let i = 0; i < dataPackageCount; i++) {
+        dataPackageChunks.push(payloadHex.substring(i * 2 * DATA_PACKAGE_BS, (i + 1) * 2 * DATA_PACKAGE_BS));
+    }
+    return { dataPackageChunks, metadata };
+}
+function stringToBytes(value) {
+    const hexArray = value
+        .slice(2)
+        .match(/.{1,2}/g)
+        ?.map((byte) => parseInt(byte, 16));
+    const buffer = Buffer.from(hexArray);
+    return buffer;
+}
+function storeSignatureAndData(dataPackageHex, builder) {
+    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 signatureCell = (0, core_1.beginCell)()
+        .storeUint(BigInt("0x" + signature.substring(0, 64)), 256)
+        .storeUint(BigInt("0x" + signature.substring(64, 128)), 256)
+        .storeUint(v, 8)
+        .endCell();
+    console.assert(data.length / 2 <= 127, "Must be implemented for larger data");
+    const dataCell = (0, core_1.beginCell)()
+        .storeBuffer(Buffer.from(stringToBytes("0x" + data)))
+        .endCell();
+    builder.storeSlice(signatureCell.beginParse()).storeRef(dataCell);
+}
+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 signatureCell = (0, core_1.beginCell)()
+        .storeUint(BigInt("0x" + signature.substring(0, 64)), 256)
+        .storeUint(BigInt("0x" + signature.substring(64, 128)), 256)
+        .storeUint(v, 8)
+        .endCell();
+    console.assert(data.length / 2 <= 127, "Must be implemented for larger data");
+    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,
+    };
+}

package/dist/utils/tracer.d.ts

@@ -0,0 +1,13 @@
+import { Address, Transaction } from "@ton/core";
+import { TonClient } from "@ton/ton";
+export declare class Tracer {
+    client: TonClient;
+    constructor(client: TonClient);
+    traceActionNotificaitonTx(tx: Transaction): Promise<(import("..").SuccessActionNotificationMsgBody | import("..").SuccessLiquidateActionNotificationMsgBody | import("..").FailTransferInActionNotificationMsgBody | import("..").FailLiquidateActionNotificationMsgBody | import("..").FailTransferOutActionNotificationMsgBody)[]>;
+    traverseOutgoingTransactions(transaction: Transaction): Promise<Transaction[]>;
+    findOutgoingTransactions(transaction: Transaction): Promise<Transaction[]>;
+    findInternalTx(src: Address, dst: Address, createdLt: string): Promise<Transaction>;
+    getExternalTx(target: Address, lt: bigint): Promise<Transaction | undefined>;
+    getLastExternalTx(target: Address, limit: number, minTime: bigint): Promise<Transaction>;
+    waitLastExternalTx(target: Address, limit: number, minTime: bigint, timeout: number): Promise<Transaction>;
+}

package/dist/utils/tracer.js

@@ -0,0 +1,137 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Tracer = void 0;
+const pool_1 = require("../contracts/core/pool");
+const serializer_1 = require("../contracts/core/pool/serializer");
+const jetton_wallet_1 = require("../contracts/jetton/jetton-wallet");
+const sleep = (ms) => new Promise((r) => setTimeout(r, ms));
+class Tracer {
+    client;
+    constructor(client) {
+        this.client = client;
+    }
+    async traceActionNotificaitonTx(tx) {
+        const txs = await this.traverseOutgoingTransactions(tx);
+        return txs
+            .map((item) => item.inMessage && parseActionNotification(item.inMessage.body))
+            .filter((item) => !!item);
+    }
+    async traverseOutgoingTransactions(transaction) {
+        const txs = [];
+        const outTxs = await this.findOutgoingTransactions(transaction);
+        txs.push(...outTxs);
+        for (const out of outTxs) {
+            const _outTxs = await this.traverseOutgoingTransactions(out);
+            txs.push(..._outTxs);
+        }
+        return txs;
+    }
+    async findOutgoingTransactions(transaction) {
+        const outMessagesInfos = transaction.outMessages
+            .values()
+            .map((message) => message.info)
+            .filter((info) => info.type === "internal");
+        return Promise.all(outMessagesInfos.map((info) => {
+            return this.findInternalTx(info.src, info.dest, info.createdLt.toString());
+        }));
+    }
+    async findInternalTx(src, dst, createdLt) {
+        const startTime = Date.now();
+        while (true) {
+            if (Date.now() - startTime > 60 * 1000)
+                throw "timeout";
+            const txs = await this.client.getTransactions(dst, {
+                limit: 100,
+                lt: createdLt,
+                archival: true,
+            });
+            const tx = txs.find((item) => {
+                if (item.inMessage?.info.type === "internal" &&
+                    item.inMessage.info.src.equals(src) &&
+                    BigInt(createdLt) === item.inMessage.info.createdLt) {
+                    return true;
+                }
+            });
+            if (tx)
+                return tx;
+            await sleep(5000);
+        }
+    }
+    async getExternalTx(target, lt) {
+        const txs = await this.client.getTransactions(target, { limit: 20 });
+        const externalTx = txs.filter((item) => item.inMessage?.info.type === "external-in" && item.lt === lt)[0];
+        if (externalTx)
+            return externalTx;
+    }
+    async getLastExternalTx(target, limit, minTime) {
+        const txs = await this.client.getTransactions(target, { limit: limit });
+        const externalTx = txs.filter((item) => item.inMessage?.info.type === "external-in" && item.now >= minTime)[0];
+        return externalTx;
+    }
+    async waitLastExternalTx(target, limit, minTime, timeout) {
+        const startTime = Date.now();
+        while (true) {
+            try {
+                if (Date.now() - startTime > timeout * 1000)
+                    throw null;
+                const externalTx = await this.getLastExternalTx(target, limit, minTime);
+                if (externalTx)
+                    return externalTx;
+            }
+            catch (e) { }
+            await sleep(5000);
+        }
+    }
+}
+exports.Tracer = Tracer;
+function parseActionNotification(cell) {
+    const ds = cell.beginParse();
+    const opCode = ds.loadUint(32);
+    if (opCode !== pool_1.Pool.Op.actionNotification)
+        return null;
+    const queryId = ds.loadUint(64);
+    const actionOpCode = ds.loadUint(32);
+    const errorCode = ds.loadUint(16);
+    if (errorCode === 0) {
+        if (actionOpCode === pool_1.Pool.Op.supply) {
+            return (0, serializer_1.parseSuccessActionNotificationMsgBody)(cell);
+        }
+        else if (actionOpCode === pool_1.Pool.Op.withdraw) {
+            return (0, serializer_1.parseSuccessActionNotificationMsgBody)(cell);
+        }
+        else if (actionOpCode === pool_1.Pool.Op.borrow) {
+            return (0, serializer_1.parseSuccessActionNotificationMsgBody)(cell);
+        }
+        else if (actionOpCode === pool_1.Pool.Op.repay) {
+            return (0, serializer_1.parseSuccessRepayActionNotificationMsgBody)(cell);
+        }
+        else if (actionOpCode === pool_1.Pool.Op.liquidate) {
+            return (0, serializer_1.parseSuccessLiquidationActionNotificationMsgBody)(cell);
+        }
+    }
+    else {
+        if (actionOpCode === jetton_wallet_1.JettonWallet.Op.TransferNotification) {
+            ds.loadCoins();
+            ds.loadAddress();
+            const forwardDS = ds.loadRef().beginParse();
+            forwardDS.loadAddress();
+            const subOp = forwardDS.loadUint(32);
+            if (subOp === pool_1.Pool.Op.supply) {
+                return (0, serializer_1.parseFailTransferInActionNotificationMsgBody)(cell);
+            }
+            else if (subOp === pool_1.Pool.Op.repay) {
+                return (0, serializer_1.parseFailTransferInActionNotificationMsgBody)(cell);
+            }
+            else if (subOp === pool_1.Pool.Op.liquidate) {
+                return (0, serializer_1.parseFailLiquidateActionNotificationMsgBody)(cell);
+            }
+        }
+        else if (actionOpCode === pool_1.Pool.Op.withdraw) {
+            return (0, serializer_1.parseFailTransferOutActionNotificationMsgBody)(cell);
+        }
+        else if (actionOpCode === pool_1.Pool.Op.borrow) {
+            return (0, serializer_1.parseFailTransferOutActionNotificationMsgBody)(cell);
+        }
+    }
+    return null;
+}

package/dist/utils/tracker/index.d.ts

@@ -0,0 +1,5 @@
+import { Address } from "@ton/core";
+import { TonClient } from "@ton/ton";
+import { MatchedTxResult, TxStep } from "./type";
+export declare function findTx(client: TonClient, dst: Address, createdLt: string | undefined, match: TxStep): Promise<MatchedTxResult>;
+export declare function track(client: TonClient, dst: Address, createdLt: string | undefined, match: TxStep): Promise<MatchedTxResult>;

package/dist/utils/tracker/index.js

@@ -0,0 +1,118 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.findTx = findTx;
+exports.track = track;
+const parser_1 = require("../parser");
+const sleep = (ms) => new Promise((r) => setTimeout(r, ms));
+async function findTx(client, dst, createdLt = "0", match) {
+    const startTime = Date.now();
+    let findingTime = 0;
+    while (true) {
+        try {
+            if (Date.now() - startTime > 120000)
+                throw "timeout";
+            const txs = await client.getTransactions(dst, {
+                limit: 100,
+                lt: createdLt,
+                archival: true,
+            });
+            const tx = txs.find((item) => {
+                const messages = [...item.outMessages.values(), item.inMessage];
+                for (let message of messages) {
+                    try {
+                        if (!message || message.info.type !== "internal")
+                            continue;
+                        if (match.from && !match.from.equals(message.info.src))
+                            continue;
+                        if (match.to && !match.to.equals(message.info.dest))
+                            continue;
+                        if (match.value && match.value !== message.info.value.coins)
+                            continue;
+                        const ds = message.body.beginParse();
+                        const opcode = ds.loadUint(32);
+                        const queryId = ds.loadUintBig(64);
+                        if (match.opcode && match.opcode !== opcode)
+                            continue;
+                        if (match.queryId && match.queryId !== queryId)
+                            continue;
+                        if (match.body &&
+                            match.body.toBoc().toString() !== message.body.toBoc().toString())
+                            continue;
+                        return true;
+                    }
+                    catch (e) { }
+                }
+            });
+            if (tx) {
+                return {
+                    address: dst,
+                    lt: tx.lt,
+                    now: tx.now,
+                    hash: tx.hash().toString("base64"),
+                    prevTxHash: tx.prevTransactionHash,
+                    inMessage: (0, parser_1.parseTxInternalMessage)(tx.inMessage),
+                    outMessages: tx.outMessages.values().map(parser_1.parseTxInternalMessage),
+                };
+            }
+        }
+        catch (e) { }
+        await sleep(5000);
+        findingTime += 5000;
+        if (findingTime > 30_000 * 3) {
+            throw "findTx timeout";
+        }
+    }
+}
+async function track(client, dst, createdLt = "0", match) {
+    const startTime = Date.now();
+    let findingTime = 0;
+    while (true) {
+        if (Date.now() - startTime > 120000)
+            throw "timeout";
+        const txs = await client.getTransactions(dst, {
+            limit: 20,
+            lt: createdLt,
+            archival: true,
+        });
+        const tx = txs.find((item) => {
+            const messages = [...item.outMessages.values(), item.inMessage];
+            for (let message of messages) {
+                if (!message || message.info.type !== "internal")
+                    continue;
+                if (match.from && !match.from.equals(message.info.src))
+                    continue;
+                if (match.to && !match.to.equals(message.info.dest))
+                    continue;
+                if (match.value && match.value !== message.info.value.coins)
+                    continue;
+                const ds = message.body.beginParse();
+                const opcode = ds.loadUint(32);
+                const queryId = ds.loadUintBig(64);
+                if (match.opcode && match.opcode !== opcode)
+                    continue;
+                if (match.queryId && match.queryId !== queryId)
+                    continue;
+                if (match.body &&
+                    match.body.toBoc().toString() !== message.body.toBoc().toString())
+                    continue;
+                return true;
+            }
+        });
+        if (tx) {
+            return {
+                address: dst,
+                lt: tx.lt,
+                now: tx.now,
+                hash: tx.hash().toString("base64"),
+                prevTxHash: tx.prevTransactionHash,
+                inMessage: (0, parser_1.parseTxInternalMessage)(tx.inMessage),
+                outMessages: tx.outMessages.values().map(parser_1.parseTxInternalMessage),
+            };
+        }
+        await sleep(5000);
+        findingTime += 5000;
+        if (findingTime > 30000) {
+            console.log("findingTime", findingTime);
+        }
+    }
+}

package/dist/utils/tracker/query-id-generactor.d.ts

@@ -0,0 +1,2 @@
+import { Address, Cell } from "@ton/core";
+export declare function generateQueryId(sender: Address, body: Cell): bigint;

package/dist/utils/tracker/query-id-generactor.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateQueryId = generateQueryId;
+const core_1 = require("@ton/core");
+function generateQueryId(sender, body) {
+    const currentTime = Math.floor(Date.now() / 1000);
+    const _hash = (0, core_1.beginCell)()
+        .storeUint(currentTime, 40)
+        .storeAddress((sender))
+        .storeRef(body).endCell().hash();
+    return (0, core_1.beginCell)().storeBuffer(_hash, 32).asSlice().loadUintBig(64);
+}

package/dist/utils/tracker/type.d.ts

@@ -0,0 +1,34 @@
+import { Address, Cell } from "@ton/core";
+import { ActionNotificationMsgBody, FailLiquidateActionNotificationMsgBody, FailTransferInActionNotificationMsgBody, FailTransferOutActionNotificationMsgBody, SuccessActionNotificationMsgBody, SuccessLiquidateActionNotificationMsgBody } from "../../contracts/core/pool/type";
+import { TxMsgBody } from "../parser";
+export type TxStep = {
+    description: string;
+    from?: Address;
+    to?: Address;
+    opcode?: number;
+    queryId?: bigint;
+    value?: bigint;
+    body?: Cell;
+    matchedTx?: MatchedTxResult | MatchedTxResult[];
+    actionNotificationResult?: ActionNotificationMsgBody | ActionNotificationMsgBody[];
+};
+export type MatchedTxResult = {
+    address: Address;
+    lt: bigint;
+    now: number;
+    hash: string;
+    prevTxHash: bigint;
+    inMessage?: TxMessage | null;
+    outMessages: (TxMessage | null | undefined)[];
+};
+export type TxCallBackFn = (step: TxStep) => void;
+export type ActionMsgBody = SuccessActionNotificationMsgBody | SuccessLiquidateActionNotificationMsgBody | FailTransferInActionNotificationMsgBody | FailLiquidateActionNotificationMsgBody | FailTransferOutActionNotificationMsgBody | null;
+export type TxMessage = {
+    src: Address;
+    dst: Address;
+    value: bigint;
+    createdAt: number;
+    createdLt: bigint;
+    body: Cell;
+    parsedBody?: TxMsgBody;
+};

package/dist/utils/tracker/type.js

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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@affluent-org/sdk",
-  "version": "0.0.2",
+  "version": "0.0.3",
   "description": "affluent-sdk",
   "main": "dist/index.js",
   "scripts": {