@affluent-org/sdk 0.0.2 → 0.0.3

package/dist/utils/_parse_temp/parseMsgBody.d.ts

@@ -0,0 +1,13 @@
+import { Cell } from '@ton/core';
+export interface ParsedMessage {
+    contractType: 'Pool' | 'ShareVault' | 'StrategyVault' | 'Unknown';
+    opName: string;
+    opCode: number;
+    data: any;
+}
+export declare function parseMsgBody(cell: Cell): ParsedMessage | null;
+export declare function getSupportedOpcodes(): {
+    contractType: string;
+    opName: string;
+    opCode: number;
+}[];

package/dist/utils/_parse_temp/parseMsgBody.js

@@ -0,0 +1,313 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseMsgBody = parseMsgBody;
+exports.getSupportedOpcodes = getSupportedOpcodes;
+const Pool_1 = require("./Pool");
+const ShareVault_1 = require("./ShareVault");
+const StrategyVault_1 = require("./StrategyVault");
+function parseMsgBody(cell) {
+    try {
+        const slice = cell.beginParse();
+        if (slice.remainingBits < 32) {
+            return null;
+        }
+        const opCode = slice.loadUint(32);
+        // Check Pool opcodes
+        const poolOpName = Pool_1.Pool.getOpName(opCode);
+        if (poolOpName !== `UnknownOp(${opCode.toString(16)})`) {
+            return parsePoolMessage(cell, opCode, poolOpName);
+        }
+        // Check ShareVault opcodes
+        const shareVaultOpName = ShareVault_1.ShareVault.getOpName(opCode);
+        if (shareVaultOpName !== `UnknownOp(${opCode.toString(16)})`) {
+            return parseShareVaultMessage(cell, opCode, shareVaultOpName);
+        }
+        // Check StrategyVault opcodes
+        const strategyVaultOpName = StrategyVault_1.StrategyVault.getOpName(opCode);
+        if (strategyVaultOpName !== `UnknownOp(${opCode.toString(16)})`) {
+            return parseStrategyVaultMessage(cell, opCode, strategyVaultOpName);
+        }
+        return null;
+    }
+    catch (error) {
+        return null;
+    }
+}
+function parsePoolMessage(cell, opCode, opName) {
+    let data;
+    try {
+        switch (opCode) {
+            case Pool_1.Pool.Op.SetOwner:
+                data = Pool_1.Pool.parseSetOwnerMsgBody(cell);
+                break;
+            case Pool_1.Pool.Op.SetFeeConfigurer:
+                data = Pool_1.Pool.parseSetFeeConfigurerMsgBody(cell);
+                break;
+            case Pool_1.Pool.Op.SetRiskFactor:
+                data = Pool_1.Pool.parseSetRiskFactorMsgBody(cell);
+                break;
+            case Pool_1.Pool.Op.SetOracle:
+                data = Pool_1.Pool.parseSetOracleMsgBody(cell);
+                break;
+            case Pool_1.Pool.Op.SetOracleConfig:
+                data = Pool_1.Pool.parseSetOracleConfigMsgBody(cell);
+                break;
+            case Pool_1.Pool.Op.SetGasFee:
+                data = Pool_1.Pool.parseSetGasFeeMsgBody(cell);
+                break;
+            case Pool_1.Pool.Op.SetProtocolFeeRate:
+                data = Pool_1.Pool.parseSetProtocolFeeRateMsgBody(cell);
+                break;
+            case Pool_1.Pool.Op.AddAsset:
+                data = Pool_1.Pool.parseAddAssetMsgBody(cell);
+                break;
+            case Pool_1.Pool.Op.SetIsBorrowable:
+                data = Pool_1.Pool.parseSetIsBorrowableMsgBody(cell);
+                break;
+            case Pool_1.Pool.Op.SetLiquidationIncentiveRate:
+                data = Pool_1.Pool.parseSetLiquidationIncentiveRateMsgBody(cell);
+                break;
+            case Pool_1.Pool.Op.SetMaxLoanLeverageRatio:
+                data = Pool_1.Pool.parseSetMaxLoanLeverageRatioMsgBody(cell);
+                break;
+            case Pool_1.Pool.Op.SetMaxLoanVarRatio:
+                data = Pool_1.Pool.parseSetMaxLoanVarRatioMsgBody(cell);
+                break;
+            case Pool_1.Pool.Op.SetLiquidateLeverageRatio:
+                data = Pool_1.Pool.parseSetLiquidateLeverageRatioMsgBody(cell);
+                break;
+            case Pool_1.Pool.Op.SetLiquidateVarRatio:
+                data = Pool_1.Pool.parseSetLiquidateVarRatioMsgBody(cell);
+                break;
+            case Pool_1.Pool.Op.SetLiquidateCloseRatio:
+                data = Pool_1.Pool.parseSetLiquidateCloseRatioMsgBody(cell);
+                break;
+            case Pool_1.Pool.Op.SetIrmConfig:
+                data = Pool_1.Pool.parseSetIrmConfigMsgBody(cell);
+                break;
+            case Pool_1.Pool.Op.SetWalletAddress:
+                data = Pool_1.Pool.parseSetWalletAddressMsgBody(cell);
+                break;
+            case Pool_1.Pool.Op.CollectFee:
+                data = Pool_1.Pool.parseCollectFeeMsgBody(cell);
+                break;
+            case Pool_1.Pool.Op.UpgradeCode:
+                data = Pool_1.Pool.parseUpgradeCodeMsgBody(cell);
+                break;
+            case Pool_1.Pool.Op.SetIsCollateral:
+                data = Pool_1.Pool.parseSetIsCollateralMsgBody(cell);
+                break;
+            case Pool_1.Pool.Op.SetNewAccountCode:
+                data = Pool_1.Pool.parseSetNewAccountCodeMsgBody(cell);
+                break;
+            case Pool_1.Pool.Op.SetVersion:
+                data = Pool_1.Pool.parseSetVersionMsgBody(cell);
+                break;
+            default:
+                return null;
+        }
+        return {
+            contractType: 'Pool',
+            opName,
+            opCode,
+            data
+        };
+    }
+    catch (error) {
+        return null;
+    }
+}
+function parseShareVaultMessage(cell, opCode, opName) {
+    let data;
+    try {
+        switch (opCode) {
+            case ShareVault_1.ShareVault.Op.RequestAssetWalletAddress:
+                data = ShareVault_1.ShareVault.parseRequestAssetWalletAddressMsgBody(cell);
+                break;
+            case ShareVault_1.ShareVault.Op.SetWhitelistPools:
+                data = ShareVault_1.ShareVault.parseSetWhitelistPoolsMsgBody(cell);
+                break;
+            case ShareVault_1.ShareVault.Op.SetTargetWeight:
+                data = ShareVault_1.ShareVault.parseSetTargetWeightMsgBody(cell);
+                break;
+            case ShareVault_1.ShareVault.Op.SupplyToPool:
+                data = ShareVault_1.ShareVault.parseSupplyToPoolMsgBody(cell);
+                break;
+            case ShareVault_1.ShareVault.Op.WithdrawFromPool:
+                data = ShareVault_1.ShareVault.parseWithdrawFromPoolMsgBody(cell);
+                break;
+            case ShareVault_1.ShareVault.Op.ChangeManager:
+                data = ShareVault_1.ShareVault.parseChangeManagerMsgBody(cell);
+                break;
+            case ShareVault_1.ShareVault.Op.ChangeAdmin:
+                data = ShareVault_1.ShareVault.parseChangeAdminMsgBody(cell);
+                break;
+            case ShareVault_1.ShareVault.Op.ActionNotification:
+                data = ShareVault_1.ShareVault.parseActionNotificationMsgBody(cell);
+                break;
+            case ShareVault_1.ShareVault.Op.TakeAggregatedPool:
+                data = ShareVault_1.ShareVault.parseTakeAggregatedPoolMsgBody(cell);
+                break;
+            case ShareVault_1.ShareVault.Op.UpgradeCode:
+                data = ShareVault_1.ShareVault.parseUpgradeCodeMsgBody(cell);
+                break;
+            case ShareVault_1.ShareVault.Op.SetGasFee:
+                data = ShareVault_1.ShareVault.parseSetGasFeeMsgBody(cell);
+                break;
+            default:
+                return null;
+        }
+        return {
+            contractType: 'ShareVault',
+            opName,
+            opCode,
+            data
+        };
+    }
+    catch (error) {
+        return null;
+    }
+}
+function parseStrategyVaultMessage(cell, opCode, opName) {
+    let data;
+    try {
+        switch (opCode) {
+            case StrategyVault_1.StrategyVault.Op.Initialize:
+                data = StrategyVault_1.StrategyVault.parseInitializeMsgBody(cell);
+                break;
+            case StrategyVault_1.StrategyVault.Op.ExecuteStrategy:
+                data = StrategyVault_1.StrategyVault.parseExecuteStrategyMsgBody(cell);
+                break;
+            case StrategyVault_1.StrategyVault.Op.LiquidateToFactorial:
+                data = StrategyVault_1.StrategyVault.parseLiquidateToFactorialMsgBody(cell);
+                break;
+            case StrategyVault_1.StrategyVault.Op.SupplyToFactorial:
+                data = StrategyVault_1.StrategyVault.parseSupplyToFactorialMsgBody(cell);
+                break;
+            case StrategyVault_1.StrategyVault.Op.WithdrawFromFactorial:
+                data = StrategyVault_1.StrategyVault.parseWithdrawFromFactorialMsgBody(cell);
+                break;
+            case StrategyVault_1.StrategyVault.Op.BorrowFromFactorial:
+                data = StrategyVault_1.StrategyVault.parseBorrowFromFactorialMsgBody(cell);
+                break;
+            case StrategyVault_1.StrategyVault.Op.RepayToFactorial:
+                data = StrategyVault_1.StrategyVault.parseRepayToFactorialMsgBody(cell);
+                break;
+            case StrategyVault_1.StrategyVault.Op.CreateRfq:
+                data = StrategyVault_1.StrategyVault.parseCreateRFQMsgBody(cell);
+                break;
+            case StrategyVault_1.StrategyVault.Op.CancelRfq:
+                data = StrategyVault_1.StrategyVault.parseCancelRFQMsgBody(cell);
+                break;
+            case StrategyVault_1.StrategyVault.Op.SetAssetConfig:
+                data = StrategyVault_1.StrategyVault.parseSetAssetConfigMsgBody(cell);
+                break;
+            case StrategyVault_1.StrategyVault.Op.SetFactorialPoolConfig:
+                data = StrategyVault_1.StrategyVault.parseSetFactorialPoolConfigMsgBody(cell);
+                break;
+            case StrategyVault_1.StrategyVault.Op.ClaimManagementFee:
+                data = StrategyVault_1.StrategyVault.parseClaimManagementFeeMsgBody(cell);
+                break;
+            case StrategyVault_1.StrategyVault.Op.ClaimProtocolFee:
+                data = StrategyVault_1.StrategyVault.parseClaimProtocolFeeMsgBody(cell);
+                break;
+            case StrategyVault_1.StrategyVault.Op.SetOwnerAddress:
+                data = StrategyVault_1.StrategyVault.parseSetOwnerAddressMsgBody(cell);
+                break;
+            case StrategyVault_1.StrategyVault.Op.SetManagementFeeRatePerYear:
+                data = StrategyVault_1.StrategyVault.parseSetManagementFeeRatePerYearMsgBody(cell);
+                break;
+            case StrategyVault_1.StrategyVault.Op.SetMaxLeverageRatio:
+                data = StrategyVault_1.StrategyVault.parseSetMaxLeverageRatioMsgBody(cell);
+                break;
+            case StrategyVault_1.StrategyVault.Op.SetRfqConfig:
+                data = StrategyVault_1.StrategyVault.parseSetRFQConfigMsgBody(cell);
+                break;
+            case StrategyVault_1.StrategyVault.Op.SetOracleConfig:
+                data = StrategyVault_1.StrategyVault.parseSetOracleConfigMsgBody(cell);
+                break;
+            case StrategyVault_1.StrategyVault.Op.SetWalletCode:
+                data = StrategyVault_1.StrategyVault.parseSetWalletCodeMsgBody(cell);
+                break;
+            case StrategyVault_1.StrategyVault.Op.SetDataAggregatorCode:
+                data = StrategyVault_1.StrategyVault.parseSetDataAggregatorCodeMsgBody(cell);
+                break;
+            case StrategyVault_1.StrategyVault.Op.SetRfqCode:
+                data = StrategyVault_1.StrategyVault.parseSetRFQCodeMsgBody(cell);
+                break;
+            case StrategyVault_1.StrategyVault.Op.SetContent:
+                data = StrategyVault_1.StrategyVault.parseSetContentMsgBody(cell);
+                break;
+            case StrategyVault_1.StrategyVault.Op.UpgradeCode:
+                data = StrategyVault_1.StrategyVault.parseUpgradeCodeMsgBody(cell);
+                break;
+            case StrategyVault_1.StrategyVault.Op.SetManagerAddress:
+                data = StrategyVault_1.StrategyVault.parseSetManagerAddressMsgBody(cell);
+                break;
+            case StrategyVault_1.StrategyVault.Op.SetPrivateVault:
+                data = StrategyVault_1.StrategyVault.parseSetPrivateVaultMsgBody(cell);
+                break;
+            case StrategyVault_1.StrategyVault.Op.SetDepositCloseTimestamp:
+                data = StrategyVault_1.StrategyVault.parseSetDepositCloseTimestampMsgBody(cell);
+                break;
+            case StrategyVault_1.StrategyVault.Op.SetWithdrawOpenTimestamp:
+                data = StrategyVault_1.StrategyVault.parseSetWithdrawOpenTimestampMsgBody(cell);
+                break;
+            case StrategyVault_1.StrategyVault.Op.SetWhitelistedMinters:
+                data = StrategyVault_1.StrategyVault.parseSetWhitelistedMintersMsgBody(cell);
+                break;
+            case StrategyVault_1.StrategyVault.Op.SetGasConfig:
+                data = StrategyVault_1.StrategyVault.parseSetGasConfigMsgBody(cell);
+                break;
+            case StrategyVault_1.StrategyVault.Op.ExecuteOwnerAction:
+                data = StrategyVault_1.StrategyVault.parseExecuteOwnerActionMsgBody(cell);
+                break;
+            case StrategyVault_1.StrategyVault.Op.RevertOwnerAction:
+                data = StrategyVault_1.StrategyVault.parseRevertOwnerActionMsgBody(cell);
+                break;
+            case StrategyVault_1.StrategyVault.Op.SetGuardianAddress:
+                data = StrategyVault_1.StrategyVault.parseSetGuardianAddressMsgBody(cell);
+                break;
+            case StrategyVault_1.StrategyVault.Op.SetTimelock:
+                data = StrategyVault_1.StrategyVault.parseSetTimelockMsgBody(cell);
+                break;
+            case StrategyVault_1.StrategyVault.Op.SetManagementFeeRecipientAddress:
+                data = StrategyVault_1.StrategyVault.parseSetManagementFeeRecipientAddressMsgBody(cell);
+                break;
+            case StrategyVault_1.StrategyVault.Op.SetProtocolFeeRatePerYear:
+                data = StrategyVault_1.StrategyVault.parseSetProtocolFeeRatePerYearMsgBody(cell);
+                break;
+            case StrategyVault_1.StrategyVault.Op.SetProtocolFeeManagerAddress:
+                data = StrategyVault_1.StrategyVault.parseSetProtocolFeeManagerAddressMsgBody(cell);
+                break;
+            default:
+                return null;
+        }
+        return {
+            contractType: 'StrategyVault',
+            opName,
+            opCode,
+            data
+        };
+    }
+    catch (error) {
+        return null;
+    }
+}
+// Export helper function to get all supported opcodes
+function getSupportedOpcodes() {
+    const opcodes = [];
+    // Pool opcodes
+    Object.entries(Pool_1.Pool.Op).forEach(([name, code]) => {
+        opcodes.push({ contractType: 'Pool', opName: name, opCode: code });
+    });
+    // ShareVault opcodes
+    Object.entries(ShareVault_1.ShareVault.Op).forEach(([name, code]) => {
+        opcodes.push({ contractType: 'ShareVault', opName: name, opCode: code });
+    });
+    // StrategyVault opcodes
+    Object.entries(StrategyVault_1.StrategyVault.Op).forEach(([name, code]) => {
+        opcodes.push({ contractType: 'StrategyVault', opName: name, opCode: code });
+    });
+    return opcodes;
+}

package/dist/utils/assert.d.ts

@@ -0,0 +1 @@
+export declare function assert(condition: boolean, message?: string): asserts condition;

package/dist/utils/assert.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.assert = assert;
+// Browser-compatible assert function to replace Node.js assert module for webpack5 compatibility
+function assert(condition, message) {
+    if (!condition) {
+        throw new Error(message || "Assertion failed");
+    }
+}

package/dist/utils/client-for-parameter.d.ts

@@ -0,0 +1,12 @@
+import { Contract, StateInit, TonClient, Address } from "@ton/ton";
+export declare class TonClientForParameter extends TonClient {
+    constructor(params: any);
+    open<T extends Contract>(src: T): OpenedContract<T>;
+}
+export type OpenedContract<F> = {
+    [P in keyof F]: P extends `${'get' | 'send' | 'is'}${string}` ? (F[P] extends (x: any, ...args: infer P) => infer R ? (...args: P) => R : never) : F[P];
+};
+export declare function openContract<T extends Contract>(src: T, factory: (params: {
+    address: Address;
+    init: StateInit | null;
+}) => any): OpenedContract<T>;

package/dist/utils/client-for-parameter.js

@@ -0,0 +1,97 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TonClientForParameter = void 0;
+exports.openContract = openContract;
+const ton_1 = require("@ton/ton");
+// import { Maybe, ExtraCurrency } from "@ton/core";
+class TonClientForParameter extends ton_1.TonClient {
+    constructor(params) {
+        super(params);
+    }
+    // @ts-ignore
+    open(src) {
+        return openContract(src, (args) => createProvider(this, args.address, args.init));
+    }
+}
+exports.TonClientForParameter = TonClientForParameter;
+function createProvider(client, address, init) {
+    return {
+        async internal(via, message) {
+            // Resolve init
+            let neededInit = null;
+            if (init && (!await client.isContractDeployed(address))) {
+                neededInit = init;
+            }
+            // Resolve bounce
+            let bounce = true;
+            if (message.bounce !== null && message.bounce !== undefined) {
+                bounce = message.bounce;
+            }
+            // Resolve value
+            let value;
+            if (typeof message.value === 'string') {
+                value = (0, ton_1.toNano)(message.value);
+            }
+            else {
+                value = message.value;
+            }
+            // Resolve body
+            let body = null;
+            if (typeof message.body === 'string') {
+                body = (0, ton_1.comment)(message.body);
+            }
+            else if (message.body) {
+                body = message.body;
+            }
+            throw {
+                to: address,
+                value,
+                bounce,
+                sendMode: message.sendMode,
+                extracurrency: message.extracurrency,
+                init: neededInit,
+                body
+            };
+        },
+    };
+}
+function openContract(src, factory) {
+    // Resolve parameters
+    let address;
+    let init = null;
+    if (!ton_1.Address.isAddress(src.address)) {
+        throw Error('Invalid address');
+    }
+    address = src.address;
+    if (src.init) {
+        if (!(src.init.code instanceof ton_1.Cell)) {
+            throw Error('Invalid init.code');
+        }
+        if (!(src.init.data instanceof ton_1.Cell)) {
+            throw Error('Invalid init.data');
+        }
+        init = src.init;
+    }
+    // Create executor
+    let executor = factory({ address, init });
+    // Create proxy
+    return new Proxy(src, {
+        get(target, prop) {
+            const value = target[prop];
+            if (typeof prop === 'string' && (prop.startsWith('get') || prop.startsWith('send') || prop.startsWith('is'))) {
+                if (typeof value === 'function') {
+                    return (...args) => new Promise(async (r) => {
+                        try {
+                            await value.apply(target, [executor, ...args]);
+                            r(true);
+                        }
+                        catch (e) {
+                            r(e);
+                        }
+                    });
+                }
+            }
+            return value;
+        }
+    });
+}

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

@@ -0,0 +1,4 @@
+import { Cell } from "@ton/core";
+import { RedstonOracleConfig } from "../../contracts/oracle/redstone-oracle/type";
+export declare function getOracleParams(assets: string[]): Cell;
+export declare function getOraclePrices(redstonOracleConfig: RedstonOracleConfig, assets: string[], prices: Record<string, bigint>): Record<string, bigint>;

package/dist/utils/oracle/index.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getOracleParams = getOracleParams;
+exports.getOraclePrices = getOraclePrices;
+const core_1 = require("@ton/core");
+function getOracleParams(assets) {
+    return (0, core_1.beginCell)().endCell();
+}
+function getOraclePrices(redstonOracleConfig, assets, prices) {
+    const result = {};
+    Object.keys(prices).forEach((key) => {
+        const assetInfo = redstonOracleConfig.assetInfo[key];
+        if (assetInfo) {
+            result[assetInfo.address.toString()] =
+                (prices[key] * BigInt(1e8)) / assetInfo.precision;
+        }
+    });
+    return result;
+}

package/dist/utils/oracle/redstone/helper.d.ts

@@ -0,0 +1,22 @@
+import { Builder } from "@ton/core";
+export declare function storeMetadata(metadataHex: string, builder: Builder): void;
+export declare class RedstoneHelper {
+    private dataServiceId;
+    private uniqueSignersCount;
+    constructor(type: "demo" | "prod");
+    createPayload(assets: string[]): Promise<import("@ton/core").Cell>;
+    getPrices(assets: string[]): Promise<any[]>;
+    getHexlifiedFeedIds(assets: string[]): string[];
+    getDataFeedIdTuples(assets: string[]): import("@ton/core").Cell;
+}
+export declare function splitPayloadHex(payloadHex: string): {
+    dataPackageChunks: string[];
+    metadata: string;
+};
+export declare function stringToBytes(value: string): Buffer<ArrayBuffer>;
+export declare function storeSignatureAndData(dataPackageHex: string, builder: Builder): void;
+export declare function parseDataPackageHex(dataPackageHex: string): {
+    timestamp: bigint;
+    price: bigint;
+    feedId: bigint;
+};