@typus/typus-sdk 1.4.67 → 1.4.69

package/dist/src/typus-launch/auction/user-entry.js

@@ -32,9 +32,9 @@ var constants_1 = require("../../../src/constants");
 function bidTx(config, tx, input) {
     var _a = __read(tx.splitCoins(tx.gas, [tx.pure(input.amount)]), 1), input_coin = _a[0];
     tx.moveCall({
-        target: "".concat(config.package.launchAuction, "::auction::bid"),
+        target: "".concat(config.package.launch.auction, "::auction::bid"),
         arguments: [
-            tx.object(config.version.launchAuction),
+            tx.object(config.version.launch.auction),
             tx.object(config.object.launchAuction),
             tx.pure(input.size),
             input_coin,
@@ -53,8 +53,8 @@ function bidTx(config, tx, input) {
 */
 function claimTx(config, tx) {
     tx.moveCall({
-        target: "".concat(config.package.launchAuction, "::auction::claim"),
-        arguments: [tx.object(config.version.launchAuction), tx.object(config.object.launchAuction), tx.object(constants_1.CLOCK)],
+        target: "".concat(config.package.launch.auction, "::auction::claim"),
+        arguments: [tx.object(config.version.launch.auction), tx.object(config.object.launchAuction), tx.object(constants_1.CLOCK)],
     });
     return tx;
 }

package/dist/src/typus-launch/auction/view-function.js

@@ -52,7 +52,7 @@ function getLaunchAuctionBids(config) {
                 case 0:
                     provider = new client_1.SuiClient({ url: config.rpcEndpoint });
                     transactionBlock = new transactions_1.TransactionBlock();
-                    target = "".concat(config.package.launchAuction, "::auction::get_records_bcs");
+                    target = "".concat(config.package.launch.auction, "::auction::get_records_bcs");
                     transactionBlockArguments = [transactionBlock.pure(config.object.launchAuction)];
                     transactionBlock.moveCall({
                         target: target,
@@ -88,7 +88,7 @@ function getBidderInfo(config, bidder) {
                 case 0:
                     provider = new client_1.SuiClient({ url: config.rpcEndpoint });
                     transactionBlock = new transactions_1.TransactionBlock();
-                    target = "".concat(config.package.launchAuction, "::auction::get_bidder_info");
+                    target = "".concat(config.package.launch.auction, "::auction::get_bidder_info");
                     transactionBlockArguments = [transactionBlock.pure(config.object.launchAuction), transactionBlock.pure(bidder)];
                     transactionBlock.moveCall({
                         target: target,

package/dist/src/typus-launch/funding-vault/authority-entry.d.ts

@@ -0,0 +1,114 @@
+import { TransactionBlock } from "@mysten/sui.js/transactions";
+import { TypusConfig } from "../../../src/utils";
+/**
+    entry fun new_vault<TOKEN>(
+        version: &Version,
+        registry: &mut Registry,
+        config: vector<u64>,
+        ctx: &mut TxContext,
+    ) {
+*/
+export declare function newVault(config: TypusConfig, tx: TransactionBlock, input: {
+    typeArguments: string[];
+    config: string[];
+}): void;
+/**
+    entry fun update_registry_setting(
+        version: &Version,
+        registry: &mut Registry,
+        setting_index: u64,
+        value: u64,
+        ctx: &TxContext,
+    ) {
+*/
+export declare function updateRegistrySetting(config: TypusConfig, tx: TransactionBlock, input: {
+    settingIndex: string;
+    value: string;
+}): void;
+/**
+    entry fun update_info(
+        version: &Version,
+        registry: &mut Registry,
+        index: u64,
+        info_index: u64,
+        value: u64,
+        ctx: &TxContext,
+    ) {
+*/
+export declare function updateInfo(config: TypusConfig, tx: TransactionBlock, input: {
+    index: string;
+    infoIndex: string;
+    value: string;
+}): void;
+/**
+    entry fun update_config(
+        version: &Version,
+        registry: &mut Registry,
+        index: u64,
+        config_index: u64,
+        value: u64,
+        ctx: &TxContext,
+    ) {
+*/
+export declare function updateConfig(config: TypusConfig, tx: TransactionBlock, input: {
+    index: string;
+    configIndex: string;
+    value: string;
+}): void;
+/**
+    entry fun deposit_fund_to_deepbook_balance_manager<TOKEN>(
+        version: &Version,
+        registry: &mut Registry,
+        index: u64,
+        ctx: &mut TxContext,
+    ) {
+*/
+export declare function depositFundToDeepbookBalanceManager(config: TypusConfig, tx: TransactionBlock, input: {
+    typeArguments: string[];
+    index: string;
+}): void;
+/**
+    entry fun withdraw_fund_from_deepbook_balance_manager<TOKEN>(
+        version: &Version,
+        registry: &mut Registry,
+        index: u64,
+        amount: Option<u64>,
+        ctx: &mut TxContext,
+    ) {
+*/
+export declare function withdrawFundFromDeepbookBalanceManager(config: TypusConfig, tx: TransactionBlock, input: {
+    typeArguments: string[];
+    index: string;
+    amount: string | null;
+}): void;
+/**
+    entry fun increase_fund<TOKEN>(
+        version: &Version,
+        registry: &mut Registry,
+        index: u64,
+        coin: Coin<TOKEN>,
+        ctx: &TxContext,
+    ) {
+*/
+export declare function increaseFund(config: TypusConfig, tx: TransactionBlock, input: {
+    typeArguments: string[];
+    index: string;
+    coins: string[];
+    amount: string;
+}): void;
+/**
+    entry fun decrease_fund<TOKEN>(
+        version: &Version,
+        registry: &mut Registry,
+        index: u64,
+        amount: u64,
+        recipient: address,
+        ctx: &mut TxContext,
+    ) {
+*/
+export declare function decreaseFund(config: TypusConfig, tx: TransactionBlock, input: {
+    typeArguments: string[];
+    index: string;
+    amount: string;
+    recipient: string;
+}): void;

package/dist/src/typus-launch/funding-vault/authority-entry.js

@@ -0,0 +1,195 @@
+"use strict";
+var __read = (this && this.__read) || function (o, n) {
+    var m = typeof Symbol === "function" && o[Symbol.iterator];
+    if (!m) return o;
+    var i = m.call(o), r, ar = [], e;
+    try {
+        while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
+    }
+    catch (error) { e = { error: error }; }
+    finally {
+        try {
+            if (r && !r.done && (m = i["return"])) m.call(i);
+        }
+        finally { if (e) throw e.error; }
+    }
+    return ar;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.newVault = newVault;
+exports.updateRegistrySetting = updateRegistrySetting;
+exports.updateInfo = updateInfo;
+exports.updateConfig = updateConfig;
+exports.depositFundToDeepbookBalanceManager = depositFundToDeepbookBalanceManager;
+exports.withdrawFundFromDeepbookBalanceManager = withdrawFundFromDeepbookBalanceManager;
+exports.increaseFund = increaseFund;
+exports.decreaseFund = decreaseFund;
+/**
+    entry fun new_vault<TOKEN>(
+        version: &Version,
+        registry: &mut Registry,
+        config: vector<u64>,
+        ctx: &mut TxContext,
+    ) {
+*/
+function newVault(config, tx, input) {
+    tx.moveCall({
+        target: "".concat(config.package.launch.fundingVault, "::funding_vault::new_vault"),
+        typeArguments: input.typeArguments,
+        arguments: [tx.object(config.version.launch.fundingVault), tx.object(config.registry.launch.fundingVault), tx.pure(input.config)],
+    });
+}
+/**
+    entry fun update_registry_setting(
+        version: &Version,
+        registry: &mut Registry,
+        setting_index: u64,
+        value: u64,
+        ctx: &TxContext,
+    ) {
+*/
+function updateRegistrySetting(config, tx, input) {
+    tx.moveCall({
+        target: "".concat(config.package.launch.fundingVault, "::funding_vault::update_registry_setting"),
+        arguments: [
+            tx.object(config.version.launch.fundingVault),
+            tx.object(config.registry.launch.fundingVault),
+            tx.pure(input.settingIndex),
+            tx.pure(input.value),
+        ],
+    });
+}
+/**
+    entry fun update_info(
+        version: &Version,
+        registry: &mut Registry,
+        index: u64,
+        info_index: u64,
+        value: u64,
+        ctx: &TxContext,
+    ) {
+*/
+function updateInfo(config, tx, input) {
+    tx.moveCall({
+        target: "".concat(config.package.launch.fundingVault, "::funding_vault::update_info"),
+        arguments: [
+            tx.object(config.version.launch.fundingVault),
+            tx.object(config.registry.launch.fundingVault),
+            tx.pure(input.index),
+            tx.pure(input.infoIndex),
+            tx.pure(input.value),
+        ],
+    });
+}
+/**
+    entry fun update_config(
+        version: &Version,
+        registry: &mut Registry,
+        index: u64,
+        config_index: u64,
+        value: u64,
+        ctx: &TxContext,
+    ) {
+*/
+function updateConfig(config, tx, input) {
+    tx.moveCall({
+        target: "".concat(config.package.launch.fundingVault, "::funding_vault::update_config"),
+        arguments: [
+            tx.object(config.version.launch.fundingVault),
+            tx.object(config.registry.launch.fundingVault),
+            tx.pure(input.index),
+            tx.pure(input.configIndex),
+            tx.pure(input.value),
+        ],
+    });
+}
+/**
+    entry fun deposit_fund_to_deepbook_balance_manager<TOKEN>(
+        version: &Version,
+        registry: &mut Registry,
+        index: u64,
+        ctx: &mut TxContext,
+    ) {
+*/
+function depositFundToDeepbookBalanceManager(config, tx, input) {
+    tx.moveCall({
+        target: "".concat(config.package.launch.fundingVault, "::funding_vault::deposit_fund_to_deepbook_balance_manager"),
+        typeArguments: input.typeArguments,
+        arguments: [tx.object(config.version.launch.fundingVault), tx.object(config.registry.launch.fundingVault), tx.pure(input.index)],
+    });
+}
+/**
+    entry fun withdraw_fund_from_deepbook_balance_manager<TOKEN>(
+        version: &Version,
+        registry: &mut Registry,
+        index: u64,
+        amount: Option<u64>,
+        ctx: &mut TxContext,
+    ) {
+*/
+function withdrawFundFromDeepbookBalanceManager(config, tx, input) {
+    tx.moveCall({
+        target: "".concat(config.package.launch.fundingVault, "::funding_vault::withdraw_fund_from_deepbook_balance_manager"),
+        typeArguments: input.typeArguments,
+        arguments: [
+            tx.object(config.version.launch.fundingVault),
+            tx.object(config.registry.launch.fundingVault),
+            tx.pure(input.index),
+            tx.pure(input.amount ? [input.amount] : []),
+        ],
+    });
+}
+/**
+    entry fun increase_fund<TOKEN>(
+        version: &Version,
+        registry: &mut Registry,
+        index: u64,
+        coin: Coin<TOKEN>,
+        ctx: &TxContext,
+    ) {
+*/
+function increaseFund(config, tx, input) {
+    var _a = __read(input.typeArguments[0] == "0x2::sui::SUI" ||
+        input.typeArguments[0] == "0x0000000000000000000000000000000000000000000000000000000000000002::sui::SUI"
+        ? tx.splitCoins(tx.gas, [tx.pure(input.amount)])
+        : (function () {
+            var coin = input.coins.pop();
+            if (input.coins.length > 0) {
+                tx.mergeCoins(tx.object(coin), input.coins.map(function (coin) { return tx.object(coin); }));
+            }
+            return tx.splitCoins(tx.object(coin), [tx.pure(input.amount)]);
+        })(), 1), coin = _a[0];
+    tx.moveCall({
+        target: "".concat(config.package.launch.fundingVault, "::funding_vault::increase_fund"),
+        typeArguments: input.typeArguments,
+        arguments: [
+            tx.object(config.version.launch.fundingVault),
+            tx.object(config.registry.launch.fundingVault),
+            tx.pure(input.index),
+            coin,
+        ],
+    });
+}
+/**
+    entry fun decrease_fund<TOKEN>(
+        version: &Version,
+        registry: &mut Registry,
+        index: u64,
+        amount: u64,
+        recipient: address,
+        ctx: &mut TxContext,
+    ) {
+*/
+function decreaseFund(config, tx, input) {
+    tx.moveCall({
+        target: "".concat(config.package.launch.fundingVault, "::funding_vault::decrease_fund"),
+        typeArguments: input.typeArguments,
+        arguments: [
+            tx.object(config.version.launch.fundingVault),
+            tx.object(config.registry.launch.fundingVault),
+            tx.pure(input.index),
+            tx.pure(input.amount),
+            tx.pure(input.recipient),
+        ],
+    });
+}

package/dist/src/typus-launch/funding-vault/index.d.ts

@@ -0,0 +1,3 @@
+export * from "./authority-entry";
+export * from "./user-entry";
+export * from "./view-function";

package/dist/src/typus-launch/funding-vault/index.js

@@ -0,0 +1,19 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./authority-entry"), exports);
+__exportStar(require("./user-entry"), exports);
+__exportStar(require("./view-function"), exports);

package/dist/src/typus-launch/funding-vault/user-entry.d.ts

@@ -0,0 +1,36 @@
+import { TransactionBlock } from "@mysten/sui.js/transactions";
+import { TypusConfig } from "../../../src/utils";
+/**
+    public fun raise_fund<TOKEN>(
+        version: &Version,
+        registry: &mut Registry,
+        index: u64,
+        coin: Coin<TOKEN>,
+        clock: &Clock,
+        ctx: &TxContext,
+    ) {
+*/
+export declare function raiseFund(config: TypusConfig, tx: TransactionBlock, input: {
+    typeArguments: string[];
+    index: string;
+    coins: string[];
+    amount: string;
+}): void;
+/**
+    public fun reduce_fund<TOKEN>(
+        version: &mut Version,
+        registry: &mut Registry,
+        index: u64,
+        mut reduce_from_fund: u64,
+        reduce_from_refund: bool,
+        clock: &Clock,
+        ctx: &mut TxContext,
+    ): Balance<TOKEN> {
+*/
+export declare function reduceFund(config: TypusConfig, tx: TransactionBlock, input: {
+    typeArguments: string[];
+    index: string;
+    reduceFromFund: string;
+    reduceFromRefund: boolean;
+    user: string;
+}): void;

package/dist/src/typus-launch/funding-vault/user-entry.js

@@ -0,0 +1,84 @@
+"use strict";
+var __read = (this && this.__read) || function (o, n) {
+    var m = typeof Symbol === "function" && o[Symbol.iterator];
+    if (!m) return o;
+    var i = m.call(o), r, ar = [], e;
+    try {
+        while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
+    }
+    catch (error) { e = { error: error }; }
+    finally {
+        try {
+            if (r && !r.done && (m = i["return"])) m.call(i);
+        }
+        finally { if (e) throw e.error; }
+    }
+    return ar;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.raiseFund = raiseFund;
+exports.reduceFund = reduceFund;
+var constants_1 = require("../../../src/constants");
+/**
+    public fun raise_fund<TOKEN>(
+        version: &Version,
+        registry: &mut Registry,
+        index: u64,
+        coin: Coin<TOKEN>,
+        clock: &Clock,
+        ctx: &TxContext,
+    ) {
+*/
+function raiseFund(config, tx, input) {
+    var _a = __read(input.typeArguments[0] == "0x2::sui::SUI" ||
+        input.typeArguments[0] == "0x0000000000000000000000000000000000000000000000000000000000000002::sui::SUI"
+        ? tx.splitCoins(tx.gas, [tx.pure(input.amount)])
+        : (function () {
+            var coin = input.coins.pop();
+            if (input.coins.length > 0) {
+                tx.mergeCoins(tx.object(coin), input.coins.map(function (coin) { return tx.object(coin); }));
+            }
+            return tx.splitCoins(tx.object(coin), [tx.pure(input.amount)]);
+        })(), 1), coin = _a[0];
+    tx.moveCall({
+        target: "".concat(config.package.launch.fundingVault, "::funding_vault::raise_fund"),
+        typeArguments: input.typeArguments,
+        arguments: [
+            tx.object(config.version.launch.fundingVault),
+            tx.object(config.registry.launch.fundingVault),
+            tx.pure(input.index),
+            coin,
+            tx.object(constants_1.CLOCK),
+        ],
+    });
+}
+/**
+    public fun reduce_fund<TOKEN>(
+        version: &mut Version,
+        registry: &mut Registry,
+        index: u64,
+        mut reduce_from_fund: u64,
+        reduce_from_refund: bool,
+        clock: &Clock,
+        ctx: &mut TxContext,
+    ): Balance<TOKEN> {
+*/
+function reduceFund(config, tx, input) {
+    var result = tx.moveCall({
+        target: "".concat(config.package.launch.fundingVault, "::funding_vault::reduce_fund"),
+        typeArguments: input.typeArguments,
+        arguments: [
+            tx.object(config.version.launch.fundingVault),
+            tx.object(config.registry.launch.fundingVault),
+            tx.pure(input.index),
+            tx.pure(input.reduceFromFund),
+            tx.pure(input.reduceFromRefund),
+            tx.object(constants_1.CLOCK),
+        ],
+    });
+    tx.moveCall({
+        target: "".concat(config.package.typus, "::utility::transfer_balance"),
+        typeArguments: input.typeArguments,
+        arguments: [tx.object(result[0]), tx.pure(input.user)],
+    });
+}

package/dist/src/typus-launch/funding-vault/view-function.d.ts

@@ -0,0 +1,28 @@
+import { TypusConfig } from "../../../src/utils";
+export interface Vault {
+    id: string;
+    token: string;
+    info: string[];
+    config: string[];
+}
+export declare function getVault(config: TypusConfig, input: {
+    indexes: string[];
+}): Promise<{
+    [key: string]: [Vault];
+}>;
+export interface Fund {
+    balance: string;
+    tsMs: string;
+}
+export declare function getFund(config: TypusConfig, input: {
+    indexes: string[];
+    user: string;
+}): Promise<{
+    [key: string]: [Fund[]];
+}>;
+export declare function getRefund(config: TypusConfig, input: {
+    indexes: string[];
+    user: string;
+}): Promise<{
+    [key: string]: [Fund[]];
+}>;

package/dist/src/typus-launch/funding-vault/view-function.js

@@ -0,0 +1,171 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __generator = (this && this.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
+    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (g && (g = 0, op[0] && (_ = 0)), _) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getVault = getVault;
+exports.getFund = getFund;
+exports.getRefund = getRefund;
+var transactions_1 = require("@mysten/sui.js/transactions");
+var client_1 = require("@mysten/sui.js/client");
+var bcs_1 = require("@mysten/bcs");
+var constants_1 = require("../../../src/constants");
+var utils_1 = require("../../../src/utils");
+function getVault(config, input) {
+    return __awaiter(this, void 0, void 0, function () {
+        var provider, transactionBlock, results, vaults;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    provider = new client_1.SuiClient({ url: config.rpcEndpoint });
+                    transactionBlock = new transactions_1.TransactionBlock();
+                    input.indexes.forEach(function (index) {
+                        transactionBlock.moveCall({
+                            target: "".concat(config.package.launch.fundingVault, "::funding_vault::get_vault_bcs"),
+                            arguments: [transactionBlock.object(config.registry.launch.fundingVault), transactionBlock.pure(index)],
+                        });
+                    });
+                    return [4 /*yield*/, provider.devInspectTransactionBlock({ sender: constants_1.SENDER, transactionBlock: transactionBlock })];
+                case 1:
+                    results = (_a.sent()).results;
+                    vaults = {};
+                    results === null || results === void 0 ? void 0 : results.forEach(function (result) {
+                        // @ts-ignore
+                        var bytes = result.returnValues[0][0];
+                        var reader = new bcs_1.BcsReader(new Uint8Array(bytes));
+                        reader.readULEB();
+                        var id = (0, utils_1.AddressFromBytes)(reader.readBytes(32));
+                        var token = String.fromCharCode.apply(null, Array.from(reader.readBytes(reader.read8())));
+                        var info = reader.readVec(function (reader) {
+                            return reader.read64();
+                        });
+                        var config = reader.readVec(function (reader) {
+                            return reader.read64();
+                        });
+                        vaults[info[0]] = [
+                            {
+                                id: id,
+                                token: token,
+                                info: info,
+                                config: config,
+                            },
+                        ];
+                    });
+                    return [2 /*return*/, vaults];
+            }
+        });
+    });
+}
+function getFund(config, input) {
+    return __awaiter(this, void 0, void 0, function () {
+        var provider, transactionBlock, results, funds;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    provider = new client_1.SuiClient({ url: config.rpcEndpoint });
+                    transactionBlock = new transactions_1.TransactionBlock();
+                    input.indexes.forEach(function (index) {
+                        transactionBlock.moveCall({
+                            target: "".concat(config.package.launch.fundingVault, "::funding_vault::get_fund_bcs"),
+                            arguments: [
+                                transactionBlock.object(config.registry.launch.fundingVault),
+                                transactionBlock.pure(index),
+                                transactionBlock.pure(input.user),
+                            ],
+                        });
+                    });
+                    return [4 /*yield*/, provider.devInspectTransactionBlock({ sender: constants_1.SENDER, transactionBlock: transactionBlock })];
+                case 1:
+                    results = (_a.sent()).results;
+                    funds = {};
+                    results === null || results === void 0 ? void 0 : results.forEach(function (result, i) {
+                        // @ts-ignore
+                        var bytes = result.returnValues[0][0];
+                        var reader = new bcs_1.BcsReader(new Uint8Array(bytes));
+                        reader.readULEB();
+                        var fund = reader.readVec(function (reader) {
+                            return {
+                                balance: reader.read64(),
+                                tsMs: reader.read64(),
+                            };
+                        });
+                        funds[input.indexes[i]] = [fund];
+                    });
+                    return [2 /*return*/, funds];
+            }
+        });
+    });
+}
+function getRefund(config, input) {
+    return __awaiter(this, void 0, void 0, function () {
+        var provider, transactionBlock, results, funds;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    provider = new client_1.SuiClient({ url: config.rpcEndpoint });
+                    transactionBlock = new transactions_1.TransactionBlock();
+                    input.indexes.forEach(function (index) {
+                        transactionBlock.moveCall({
+                            target: "".concat(config.package.launch.fundingVault, "::funding_vault::get_refund_bcs"),
+                            arguments: [
+                                transactionBlock.object(config.registry.launch.fundingVault),
+                                transactionBlock.pure(index),
+                                transactionBlock.pure(input.user),
+                            ],
+                        });
+                    });
+                    return [4 /*yield*/, provider.devInspectTransactionBlock({ sender: constants_1.SENDER, transactionBlock: transactionBlock })];
+                case 1:
+                    results = (_a.sent()).results;
+                    funds = {};
+                    results === null || results === void 0 ? void 0 : results.forEach(function (result, i) {
+                        // @ts-ignore
+                        var bytes = result.returnValues[0][0];
+                        var reader = new bcs_1.BcsReader(new Uint8Array(bytes));
+                        reader.readULEB();
+                        var fund = reader.readVec(function (reader) {
+                            return {
+                                balance: reader.read64(),
+                                tsMs: reader.read64(),
+                            };
+                        });
+                        funds[input.indexes[i]] = [fund];
+                    });
+                    return [2 /*return*/, funds];
+            }
+        });
+    });
+}

package/dist/src/typus-launch/option-airdrop/{user-entry.js → authority-entry.js}

@@ -16,9 +16,9 @@ var constants_1 = require("../../../src/constants");
 */
 function addUserShare(config, tx, input) {
     tx.moveCall({
-        target: "".concat(config.package.launchOptionAirdrop, "::option_airdop::add_user_share"),
+        target: "".concat(config.package.launch.optionAirdrop, "::option_airdop::add_user_share"),
         arguments: [
-            tx.object(config.version.launchOptionAirdrop),
+            tx.object(config.version.launch.optionAirdrop),
             tx.object(config.object.launchSnapshot),
             tx.pure(input.users),
             tx.pure(input.shares),
@@ -34,8 +34,8 @@ function addUserShare(config, tx, input) {
 */
 function removeUserShare(config, tx, input) {
     tx.moveCall({
-        target: "".concat(config.package.launchOptionAirdrop, "::option_airdop::remove_user_share"),
-        arguments: [tx.object(config.version.launchOptionAirdrop), tx.object(config.object.launchSnapshot)],
+        target: "".concat(config.package.launch.optionAirdrop, "::option_airdop::remove_user_share"),
+        arguments: [tx.object(config.version.launch.optionAirdrop), tx.object(config.object.launchSnapshot)],
     });
 }
 /**
@@ -51,9 +51,9 @@ function removeUserShare(config, tx, input) {
 */
 function addAirdropPlan(config, tx, input) {
     tx.moveCall({
-        target: "".concat(config.package.launchOptionAirdrop, "::option_airdop::add_airdrop_plan"),
+        target: "".concat(config.package.launch.optionAirdrop, "::option_airdop::add_airdrop_plan"),
         arguments: [
-            tx.object(config.version.launchOptionAirdrop),
+            tx.object(config.version.launch.optionAirdrop),
             tx.object(config.object.launchSnapshot),
             tx.pure(input.vault_index),
             tx.pure(input.auction_max_size),
@@ -73,9 +73,9 @@ function addAirdropPlan(config, tx, input) {
 */
 function airdropOtc(config, tx) {
     tx.moveCall({
-        target: "".concat(config.package.launchOptionAirdrop, "::option_airdop::airdrop_otc"),
+        target: "".concat(config.package.launch.optionAirdrop, "::option_airdop::airdrop_otc"),
         arguments: [
-            tx.object(config.version.launchOptionAirdrop),
+            tx.object(config.version.launch.optionAirdrop),
             tx.object(config.object.launchSnapshot),
             tx.object(config.registry.dov.dovSingle),
             tx.object(constants_1.CLOCK),

package/dist/src/typus-launch/option-airdrop/index.d.ts

@@ -1 +1 @@
-export * from "./user-entry";
+export * from "./authority-entry";

package/dist/src/typus-launch/option-airdrop/index.js

@@ -14,4 +14,4 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
     for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-__exportStar(require("./user-entry"), exports);
+__exportStar(require("./authority-entry"), exports);

package/dist/src/typus-safu/user-history.js

@@ -137,11 +137,13 @@ function parseTxHistory(datas) {
                                         // console.log(asset, decimal);
                                         switch (action) {
                                             case "raise_fund":
-                                                if (Number(log[2]) + Number(log[3]) + Number(log[4]) > 0) {
+                                                // balance_value, deactivating_value, inactive_value,
+                                                // Number(log[2]) + Number(log[3]) + Number(log[4])
+                                                if (Number(log[2]) > 0) {
                                                     txHistory.push({
                                                         Action: "Deposit",
                                                         Index: log[0],
-                                                        Amount: divByDecimal(Number(log[2]) + Number(log[3]) + Number(log[4]), decimal),
+                                                        Amount: divByDecimal(Number(log[2]), decimal),
                                                         Token: Token,
                                                         Exp: log[6],
                                                         Date: new Date(Number(event.timestampMs)),

package/dist/src/utils/typusConfig.d.ts

@@ -19,15 +19,21 @@ export interface Package {
     perp: string;
     safu: string;
     typus: string;
-    launchAuction: string;
-    launchOptionAirdrop: string;
+    launch: {
+        auction: string;
+        optionAirdrop: string;
+        fundingVault: string;
+    };
 }
 export interface Version {
     perp: string;
     safu: string;
     typus: string;
-    launchAuction: string;
-    launchOptionAirdrop: string;
+    launch: {
+        auction: string;
+        optionAirdrop: string;
+        fundingVault: string;
+    };
 }
 export interface Registry {
     dice: {
@@ -62,6 +68,9 @@ export interface Registry {
         tgld: string;
         user: string;
     };
+    launch: {
+        fundingVault: string;
+    };
 }
 export interface Object {
     nftTransferPolicy: string;

package/package.json

@@ -2,7 +2,7 @@
     "name": "@typus/typus-sdk",
     "author": "Typus",
     "description": "typus sdk",
-    "version": "1.4.67",
+    "version": "1.4.69",
     "dependencies": {
         "@mysten/bcs": "^0.11.1",
         "@mysten/kiosk": "0.8.10",