@typus/typus-sdk 1.2.85-tails-exp → 1.2.85

package/lib/utils/typus-dov-single-v2/user-entry.js

@@ -16,121 +16,416 @@ var __read = (this && this.__read) || function (o, n) {
     return ar;
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.getRebateTx = exports.getMultiTransferBidReceiptTx = exports.getTransferBidReceiptTx = exports.getExerciseTx = exports.getNewBidTx = exports.getReduceFundTx = exports.getRaiseFundTx = void 0;
+exports.getRebateTx = exports.getMultiTransferBidReceiptTx = exports.getTransferBidReceiptTx = exports.getExerciseTx = exports.getNewBidTx = exports.getWithdrawHarvestClaimTx = exports.getRedeemTx = exports.getHarvestTx = exports.getClaimTx = exports.getCompoundTx = exports.getUnsubscribeTx = exports.getWithdrawTx = exports.getDepositTx = void 0;
 var transactions_1 = require("@mysten/sui.js/transactions");
 var constants_1 = require("../../constants");
 /**
-    public fun public_raise_fund<D_TOKEN, B_TOKEN>(
-        typus_ecosystem_version: &TypusEcosystemVersion,
-        typus_user_registry: &mut TypusUserRegistry,
-        typus_leaderboard_registry: &mut TypusLeaderboardRegistry,
+    public fun deposit<D_TOKEN, B_TOKEN>(
         registry: &mut Registry,
         index: u64,
+        coins: vector<Coin<D_TOKEN>>,
+        amount: u64,
         receipts: vector<TypusDepositReceipt>,
-        raise_balance: Balance<D_TOKEN>,
-        raise_from_premium: bool,
-        raise_from_inactive: bool,
         clock: &Clock,
         ctx: &mut TxContext,
-    ): (TypusDepositReceipt, vector<u64>) {
- */
-function getRaiseFundTx(input) {
-    var raiseBalance = input.tx.moveCall({
-        target: "".concat(input.typusFrameworkPackageId, "::utils::delegate_extract_balance"),
-        typeArguments: [input.typeArguments[0]],
+    )
+*/
+function getDepositTx(input) {
+    if (!input.usingSponsoredGasCoin &&
+        (input.typeArguments[0] == "0x2::sui::SUI" ||
+            input.typeArguments[0] == "0x0000000000000000000000000000000000000000000000000000000000000002::sui::SUI")) {
+        var _a = __read(input.tx.splitCoins(input.tx.gas, [input.tx.pure(input.amount)]), 1), coin = _a[0];
+        var result = input.tx.moveCall({
+            target: "".concat(input.typusDovSinglePackageId, "::tails_staking::deposit"),
+            typeArguments: input.typeArguments,
+            arguments: [
+                input.tx.object(input.typusDovSingleRegistry),
+                input.tx.pure(input.index),
+                input.tx.makeMoveVec({ objects: [coin] }),
+                input.tx.pure(input.amount),
+                input.tx.makeMoveVec({
+                    type: "".concat(input.typusFrameworkOriginPackageId, "::vault::TypusDepositReceipt"),
+                    objects: input.receipts.map(function (receipt) { return input.tx.object(receipt); }),
+                }),
+                input.tx.pure(constants_1.CLOCK),
+            ],
+        });
+        input.tx.moveCall({
+            target: "".concat(input.typusFrameworkPackageId, "::utils::transfer_coins"),
+            typeArguments: [input.typeArguments[0]],
+            arguments: [input.tx.object(result[0]), input.tx.pure(input.user)],
+        });
+        input.tx.transferObjects([input.tx.object(result[1])], input.user);
+    }
+    else {
+        var result = input.tx.moveCall({
+            target: "".concat(input.typusDovSinglePackageId, "::tails_staking::deposit"),
+            typeArguments: input.typeArguments,
+            arguments: [
+                input.tx.object(input.typusDovSingleRegistry),
+                input.tx.pure(input.index),
+                input.tx.makeMoveVec({ objects: input.coins.map(function (coin) { return input.tx.object(coin); }) }),
+                input.tx.pure(input.amount),
+                input.tx.makeMoveVec({
+                    type: "".concat(input.typusFrameworkOriginPackageId, "::vault::TypusDepositReceipt"),
+                    objects: input.receipts.map(function (receipt) { return input.tx.object(receipt); }),
+                }),
+                input.tx.pure(constants_1.CLOCK),
+            ],
+        });
+        input.tx.moveCall({
+            target: "".concat(input.typusFrameworkPackageId, "::utils::transfer_coins"),
+            typeArguments: [input.typeArguments[0]],
+            arguments: [input.tx.object(result[0]), input.tx.pure(input.user)],
+        });
+        input.tx.transferObjects([input.tx.object(result[1])], input.user);
+    }
+    return input.tx;
+}
+exports.getDepositTx = getDepositTx;
+/**
+    public fun withdraw<D_TOKEN, B_TOKEN>(
+        registry: &mut Registry,
+        index: u64,
+        receipts: vector<TypusDepositReceipt>,
+        share: Option<u64>,
+        clock: &Clock,
+        ctx: &mut TxContext,
+    )
+*/
+function getWithdrawTx(input) {
+    var result = input.tx.moveCall({
+        target: "".concat(input.typusDovSinglePackageId, "::tails_staking::withdraw"),
+        typeArguments: input.typeArguments,
         arguments: [
-            input.tx.pure(input.user),
+            input.tx.object(input.typusDovSingleRegistry),
+            input.tx.pure(input.index),
             input.tx.makeMoveVec({
-                type: "0x2::coin::Coin<".concat(input.typeArguments[0], ">"),
-                objects: input.raiseCoins,
+                type: "".concat(input.typusFrameworkOriginPackageId, "::vault::TypusDepositReceipt"),
+                objects: input.receipts.map(function (receipt) { return input.tx.object(receipt); }),
             }),
-            input.tx.pure(input.raiseAmount),
+            input.tx.pure(input.share ? [input.share] : []),
+            input.tx.pure(constants_1.CLOCK),
         ],
     });
+    input.tx.moveCall({
+        target: "".concat(input.typusFrameworkPackageId, "::utils::transfer_balance"),
+        typeArguments: [input.typeArguments[0]],
+        arguments: [input.tx.object(result[0]), input.tx.pure(input.user)],
+    });
+    input.tx.moveCall({
+        target: "".concat(input.typusFrameworkPackageId, "::vault::transfer_deposit_receipt"),
+        arguments: [input.tx.object(result[1]), input.tx.pure(input.user)],
+    });
+    return input.tx;
+}
+exports.getWithdrawTx = getWithdrawTx;
+/**
+    public fun unsubscribe<D_TOKEN, B_TOKEN>(
+        registry: &mut Registry,
+        index: u64,
+        receipts: vector<TypusDepositReceipt>,
+        share: Option<u64>,
+        clock: &Clock,
+        ctx: &mut TxContext,
+    )
+*/
+function getUnsubscribeTx(input) {
     var result = input.tx.moveCall({
-        target: "".concat(input.typusDovSinglePackageId, "::tds_user_entry::public_raise_fund"),
+        target: "".concat(input.typusDovSinglePackageId, "::tails_staking::unsubscribe"),
         typeArguments: input.typeArguments,
         arguments: [
-            input.tx.object(input.typusEcosystemVersion),
-            input.tx.object(input.typusUserRegistry),
-            input.tx.object(input.typusLeaderboardRegistry),
             input.tx.object(input.typusDovSingleRegistry),
             input.tx.pure(input.index),
             input.tx.makeMoveVec({
                 type: "".concat(input.typusFrameworkOriginPackageId, "::vault::TypusDepositReceipt"),
                 objects: input.receipts.map(function (receipt) { return input.tx.object(receipt); }),
             }),
-            input.tx.object(raiseBalance),
-            input.tx.pure(input.raiseFromPremium),
-            input.tx.pure(input.raiseFromInactive),
+            input.tx.pure(input.share ? [input.share] : []),
             input.tx.pure(constants_1.CLOCK),
         ],
     });
     input.tx.transferObjects([input.tx.object(result[0])], input.user);
     return input.tx;
 }
-exports.getRaiseFundTx = getRaiseFundTx;
+exports.getUnsubscribeTx = getUnsubscribeTx;
 /**
-    public fun public_reduce_fund<D_TOKEN, B_TOKEN, I_TOKEN>(
-        typus_ecosystem_version: &TypusEcosystemVersion,
-        typus_user_registry: &mut TypusUserRegistry,
-        typus_leaderboard_registry: &mut TypusLeaderboardRegistry,
+    public fun compound<D_TOKEN, B_TOKEN>(
         registry: &mut Registry,
         index: u64,
         receipts: vector<TypusDepositReceipt>,
-        reduce_from_warmup: u64,
-        reduce_from_active: u64,
-        reduce_from_premium: bool,
-        reduce_from_inactive: bool,
-        reduce_from_incentive: bool,
         clock: &Clock,
         ctx: &mut TxContext,
-    ): (Option<TypusDepositReceipt>, Balance<D_TOKEN>, Balance<B_TOKEN>, Balance<I_TOKEN>, vector<u64>) {
- */
-function getReduceFundTx(input) {
+    )
+*/
+function getCompoundTx(input) {
     var result = input.tx.moveCall({
-        target: "".concat(input.typusDovSinglePackageId, "::tds_user_entry::public_reduce_fund"),
+        target: "".concat(input.typusDovSinglePackageId, "::tails_staking::compound"),
         typeArguments: input.typeArguments,
         arguments: [
-            input.tx.object(input.typusEcosystemVersion),
-            input.tx.object(input.typusUserRegistry),
-            input.tx.object(input.typusLeaderboardRegistry),
             input.tx.object(input.typusDovSingleRegistry),
             input.tx.pure(input.index),
             input.tx.makeMoveVec({
                 type: "".concat(input.typusFrameworkOriginPackageId, "::vault::TypusDepositReceipt"),
                 objects: input.receipts.map(function (receipt) { return input.tx.object(receipt); }),
             }),
-            input.tx.pure(input.reduceFromWarmup),
-            input.tx.pure(input.reduceFromActive),
-            input.tx.pure(input.reduceFromPremium),
-            input.tx.pure(input.reduceFromInactive),
-            input.tx.pure(input.reduceFromIncentive),
-            input.tx.pure(constants_1.CLOCK),
+            input.tx.object(constants_1.CLOCK),
         ],
     });
-    input.tx.moveCall({
-        target: "".concat(input.typusFrameworkPackageId, "::vault::transfer_deposit_receipt"),
-        arguments: [input.tx.object(result[0]), input.tx.pure(input.user)],
+    if (input.incentiveToken) {
+        input.typeArguments.push(input.incentiveToken);
+        input.tx = getRedeemTx({
+            tx: input.tx,
+            typusFrameworkOriginPackageId: input.typusFrameworkOriginPackageId,
+            typusFrameworkPackageId: input.typusFrameworkPackageId,
+            typusDovSinglePackageId: input.typusDovSinglePackageId,
+            typusDovSingleRegistry: input.typusDovSingleRegistry,
+            typeArguments: input.typeArguments,
+            index: input.index,
+            receipts: [input.tx.object(result[0])],
+            user: input.user,
+        });
+    }
+    else {
+        input.tx.transferObjects([input.tx.object(result[0])], input.user);
+    }
+    return input.tx;
+}
+exports.getCompoundTx = getCompoundTx;
+/**
+    public fun claim<D_TOKEN, B_TOKEN>(
+        registry: &mut Registry,
+        index: u64,
+        receipts: vector<TypusDepositReceipt>,
+        ctx: &mut TxContext,
+    )
+*/
+function getClaimTx(input) {
+    var result = input.tx.moveCall({
+        target: "".concat(input.typusDovSinglePackageId, "::tds_user_entry::claim"),
+        typeArguments: input.typeArguments,
+        arguments: [
+            input.tx.object(input.typusDovSingleRegistry),
+            input.tx.pure(input.index),
+            input.tx.makeMoveVec({
+                type: "".concat(input.typusFrameworkOriginPackageId, "::vault::TypusDepositReceipt"),
+                objects: input.receipts.map(function (receipt) { return input.tx.object(receipt); }),
+            }),
+        ],
     });
     input.tx.moveCall({
         target: "".concat(input.typusFrameworkPackageId, "::utils::transfer_balance"),
         typeArguments: [input.typeArguments[0]],
+        arguments: [input.tx.object(result[0]), input.tx.pure(input.user)],
+    });
+    input.tx.moveCall({
+        target: "".concat(input.typusFrameworkPackageId, "::vault::transfer_deposit_receipt"),
         arguments: [input.tx.object(result[1]), input.tx.pure(input.user)],
     });
+    return input.tx;
+}
+exports.getClaimTx = getClaimTx;
+/**
+    public fun harvest<D_TOKEN, B_TOKEN>(
+        registry: &mut Registry,
+        index: u64,
+        receipts: vector<TypusDepositReceipt>,
+        ctx: &mut TxContext,
+    )
+*/
+function getHarvestTx(input) {
+    var result = input.tx.moveCall({
+        target: "".concat(input.typusDovSinglePackageId, "::tds_user_entry::harvest"),
+        typeArguments: input.typeArguments,
+        arguments: [
+            input.tx.object(input.typusDovSingleRegistry),
+            input.tx.pure(input.index),
+            input.tx.makeMoveVec({
+                type: "".concat(input.typusFrameworkOriginPackageId, "::vault::TypusDepositReceipt"),
+                objects: input.receipts.map(function (receipt) { return input.tx.object(receipt); }),
+            }),
+        ],
+    });
     input.tx.moveCall({
         target: "".concat(input.typusFrameworkPackageId, "::utils::transfer_balance"),
         typeArguments: [input.typeArguments[1]],
-        arguments: [input.tx.object(result[2]), input.tx.pure(input.user)],
+        arguments: [input.tx.object(result[0]), input.tx.pure(input.user)],
+    });
+    if (input.incentiveToken) {
+        input.typeArguments.push(input.incentiveToken);
+        var receipt = input.tx.moveCall({
+            target: "0x1::option::destroy_some",
+            typeArguments: ["".concat(input.typusFrameworkOriginPackageId, "::vault::TypusDepositReceipt")],
+            arguments: [input.tx.object(result[1])],
+        });
+        input.tx = getRedeemTx({
+            tx: input.tx,
+            typusFrameworkOriginPackageId: input.typusFrameworkOriginPackageId,
+            typusFrameworkPackageId: input.typusFrameworkPackageId,
+            typusDovSinglePackageId: input.typusDovSinglePackageId,
+            typusDovSingleRegistry: input.typusDovSingleRegistry,
+            typeArguments: input.typeArguments,
+            index: input.index,
+            receipts: [input.tx.object(receipt)],
+            user: input.user,
+        });
+    }
+    else {
+        input.tx.moveCall({
+            target: "".concat(input.typusFrameworkPackageId, "::vault::transfer_deposit_receipt"),
+            arguments: [input.tx.object(result[1]), input.tx.pure(input.user)],
+        });
+    }
+    return input.tx;
+}
+exports.getHarvestTx = getHarvestTx;
+/**
+    public fun redeem<D_TOKEN, B_TOKEN, I_TOKEN>(
+        registry: &mut Registry,
+        index: u64,
+        receipts: vector<TypusDepositReceipt>,
+        ctx: &mut TxContext,
+    )
+*/
+function getRedeemTx(input) {
+    var result = input.tx.moveCall({
+        target: "".concat(input.typusDovSinglePackageId, "::tds_user_entry::redeem"),
+        typeArguments: input.typeArguments,
+        arguments: [
+            input.tx.object(input.typusDovSingleRegistry),
+            input.tx.pure(input.index),
+            input.tx.makeMoveVec({
+                type: "".concat(input.typusFrameworkOriginPackageId, "::vault::TypusDepositReceipt"),
+                objects: input.receipts.map(function (receipt) { return input.tx.object(receipt); }),
+            }),
+        ],
     });
     input.tx.moveCall({
         target: "".concat(input.typusFrameworkPackageId, "::utils::transfer_balance"),
         typeArguments: [input.typeArguments[2]],
-        arguments: [input.tx.object(result[3]), input.tx.pure(input.user)],
+        arguments: [input.tx.object(result[0]), input.tx.pure(input.user)],
+    });
+    input.tx.moveCall({
+        target: "".concat(input.typusFrameworkPackageId, "::vault::transfer_deposit_receipt"),
+        arguments: [input.tx.object(result[1]), input.tx.pure(input.user)],
     });
     return input.tx;
 }
-exports.getReduceFundTx = getReduceFundTx;
+exports.getRedeemTx = getRedeemTx;
+function getWithdrawHarvestClaimTx(input) {
+    var result = input.withdraw
+        ? input.tx.moveCall({
+            target: "".concat(input.typusDovSinglePackageId, "::tails_staking::withdraw"),
+            typeArguments: input.typeArguments,
+            arguments: [
+                input.tx.object(input.typusDovSingleRegistry),
+                input.tx.pure(input.index),
+                input.tx.makeMoveVec({
+                    type: "".concat(input.typusFrameworkOriginPackageId, "::vault::TypusDepositReceipt"),
+                    objects: input.receipts.map(function (receipt) { return input.tx.object(receipt); }),
+                }),
+                input.tx.pure([]),
+                input.tx.pure(constants_1.CLOCK),
+            ],
+        })
+        : undefined;
+    if (input.withdraw) {
+        input.tx.moveCall({
+            target: "".concat(input.typusFrameworkPackageId, "::utils::transfer_balance"),
+            typeArguments: [input.typeArguments[0]],
+            arguments: [input.tx.object(result[0]), input.tx.pure(input.user)],
+        });
+    }
+    result = input.harvest
+        ? input.tx.moveCall({
+            target: "".concat(input.typusDovSinglePackageId, "::tds_user_entry::harvest"),
+            typeArguments: input.typeArguments,
+            arguments: [
+                input.tx.object(input.typusDovSingleRegistry),
+                input.tx.pure(input.index),
+                input.tx.makeMoveVec({
+                    type: "".concat(input.typusFrameworkOriginPackageId, "::vault::TypusDepositReceipt"),
+                    objects: result
+                        ? [
+                            input.tx.object(input.tx.moveCall({
+                                target: "0x1::option::destroy_some",
+                                typeArguments: ["".concat(input.typusFrameworkOriginPackageId, "::vault::TypusDepositReceipt")],
+                                arguments: [input.tx.object(result[1])],
+                            })),
+                        ]
+                        : input.receipts.map(function (receipt) { return input.tx.object(receipt); }),
+                }),
+            ],
+        })
+        : result;
+    if (input.harvest) {
+        input.tx.moveCall({
+            target: "".concat(input.typusFrameworkPackageId, "::utils::transfer_balance"),
+            typeArguments: [input.typeArguments[1]],
+            arguments: [input.tx.object(result[0]), input.tx.pure(input.user)],
+        });
+    }
+    result = input.claim
+        ? input.tx.moveCall({
+            target: "".concat(input.typusDovSinglePackageId, "::tds_user_entry::claim"),
+            typeArguments: input.typeArguments,
+            arguments: [
+                input.tx.object(input.typusDovSingleRegistry),
+                input.tx.pure(input.index),
+                input.tx.makeMoveVec({
+                    type: "".concat(input.typusFrameworkOriginPackageId, "::vault::TypusDepositReceipt"),
+                    objects: result
+                        ? [
+                            input.tx.object(input.tx.moveCall({
+                                target: "0x1::option::destroy_some",
+                                typeArguments: ["".concat(input.typusFrameworkOriginPackageId, "::vault::TypusDepositReceipt")],
+                                arguments: [input.tx.object(result[1])],
+                            })),
+                        ]
+                        : input.receipts.map(function (receipt) { return input.tx.object(receipt); }),
+                }),
+            ],
+        })
+        : result;
+    if (input.claim) {
+        input.tx.moveCall({
+            target: "".concat(input.typusFrameworkPackageId, "::utils::transfer_balance"),
+            typeArguments: [input.typeArguments[0]],
+            arguments: [input.tx.object(result[0]), input.tx.pure(input.user)],
+        });
+    }
+    if (input.incentiveToken) {
+        input.typeArguments.push(input.incentiveToken);
+        var receipts = result
+            ? [
+                input.tx.object(input.tx.moveCall({
+                    target: "0x1::option::destroy_some",
+                    typeArguments: ["".concat(input.typusFrameworkOriginPackageId, "::vault::TypusDepositReceipt")],
+                    arguments: [input.tx.object(result[1])],
+                })),
+            ]
+            : input.receipts.map(function (receipt) { return input.tx.object(receipt); });
+        input.tx = getRedeemTx({
+            tx: input.tx,
+            typusFrameworkOriginPackageId: input.typusFrameworkOriginPackageId,
+            typusFrameworkPackageId: input.typusFrameworkPackageId,
+            typusDovSinglePackageId: input.typusDovSinglePackageId,
+            typusDovSingleRegistry: input.typusDovSingleRegistry,
+            typeArguments: input.typeArguments,
+            index: input.index,
+            receipts: receipts,
+            user: input.user,
+        });
+    }
+    else {
+        input.tx.moveCall({
+            target: "".concat(input.typusFrameworkPackageId, "::vault::transfer_deposit_receipt"),
+            arguments: [input.tx.object(result[1]), input.tx.pure(input.user)],
+        });
+    }
+    return input.tx;
+}
+exports.getWithdrawHarvestClaimTx = getWithdrawHarvestClaimTx;
 /**
     public(friend) entry fun new_bid<D_TOKEN, B_TOKEN>(
         registry: &mut Registry,
@@ -147,7 +442,7 @@ function getNewBidTx(input) {
             input.typeArguments[1] == "0x0000000000000000000000000000000000000000000000000000000000000002::sui::SUI")) {
         var _a = __read(input.tx.splitCoins(input.tx.gas, [input.tx.pure(input.premium_required)]), 1), coin = _a[0];
         var result = input.tx.moveCall({
-            target: "".concat(input.typusDovSinglePackageId, "::tds_user_entry::public_bid"),
+            target: "".concat(input.typusDovSinglePackageId, "::tails_staking::bid"),
             typeArguments: input.typeArguments,
             arguments: [
                 input.tx.object(input.typusEcosystemVersion),
@@ -158,7 +453,7 @@ function getNewBidTx(input) {
                 input.tx.pure(input.index),
                 input.tx.makeMoveVec({ objects: [coin] }),
                 input.tx.pure(input.size),
-                input.tx.pure(constants_1.CLOCK),
+                input.tx.pure("0x6"),
             ],
         });
         input.tx.transferObjects([input.tx.object(result[0])], input.user);
@@ -183,7 +478,7 @@ function getNewBidTx(input) {
             arguments: [input.tx.object(balance)],
         });
         var result = input.tx.moveCall({
-            target: "".concat(input.typusDovSinglePackageId, "::tds_user_entry::public_bid"),
+            target: "".concat(input.typusDovSinglePackageId, "::tails_staking::bid"),
             typeArguments: input.typeArguments,
             arguments: [
                 input.tx.object(input.typusEcosystemVersion),

package/lib/utils/user/view-functions.d.ts

@@ -1,6 +1,6 @@
 import { SuiClient } from "@mysten/sui.js/client";
 export declare const SENDER = "0xAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA";
-export declare function getUserMetadata(input: {
+export declare function getAirdrop(input: {
     provider: SuiClient;
     typusPackageId: string;
     typusEcosystemVersion: string;

package/lib/utils/user/view-functions.js

@@ -36,11 +36,11 @@ var __generator = (this && this.__generator) || function (thisArg, body) {
     }
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.getUserMetadata = exports.SENDER = void 0;
+exports.getAirdrop = exports.SENDER = void 0;
 var transactions_1 = require("@mysten/sui.js/transactions");
 var bcs_1 = require("@mysten/bcs");
 exports.SENDER = "0xAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA";
-function getUserMetadata(input) {
+function getAirdrop(input) {
     return __awaiter(this, void 0, void 0, function () {
         var transactionBlock, results, bytes, reader;
         return __generator(this, function (_a) {
@@ -68,4 +68,4 @@ function getUserMetadata(input) {
         });
     });
 }
-exports.getUserMetadata = getUserMetadata;
+exports.getAirdrop = getAirdrop;

package/package.json

@@ -2,11 +2,13 @@
     "name": "@typus/typus-sdk",
     "author": "Typus",
     "description": "typus sdk",
-    "version": "1.2.85-tails-exp",
+    "version": "1.2.85",
     "dependencies": {
         "@mysten/bcs": "^0.11.1",
         "@mysten/kiosk": "0.8.10",
         "@mysten/sui.js": "0.54.1",
+        "@pythnetwork/client": "^2.21.0",
+        "@solana/web3.js": "^1.91.8",
         "@types/node": "^20.5.7",
         "aftermath-ts-sdk": "^1.1.14",
         "bignumber.js": "^9.1.1",
@@ -33,12 +35,13 @@
         "js-tokens": "^8.0.1",
         "js-yaml": "^4.1.0",
         "json2csv": "^6.0.0-alpha.2",
+        "lodash": "^4.17.21",
         "math-erf": "^1.0.0",
         "minimatch": "^9.0.3",
         "minimist": "^1.2.5",
         "mkdirp": "^3.0.1",
         "mocha": "^10.1.0",
-        "moment": "^2.29.4",
+        "moment": "^2.30.1",
         "node-cron": "^3.0.2",
         "once": "^1.4.0",
         "path-is-absolute": "^2.0.0",