@typus/typus-sdk 1.4.3-d → 1.4.3-e

package/src/tails-staking/user-entry.ts

@@ -0,0 +1,401 @@
+import { TransactionBlock } from "@mysten/sui.js/transactions";
+import { CLOCK } from "../constants";
+import { KIOSK_TYPE, KioskClient, KioskTransaction } from "@mysten/kiosk";
+/**
+    public fun stake_tails(
+        version: &mut Version,
+        tails_staking_registry: &mut TailsStakingRegistry,
+        kiosk: &mut Kiosk,
+        kiosk_owner_cap: &KioskOwnerCap,
+        tails: address,
+        coin: Coin<SUI>,
+        ctx: &mut TxContext,
+    ) {
+*/
+export async function getStakeTailsTx(input: {
+    tx: TransactionBlock;
+    typusPackageId: string;
+    typusEcosystemVersion: string;
+    typusTailsStakingRegistry: string;
+    kiosk: string;
+    kioskCap: string;
+    tails: string;
+    fee: string;
+    personalKioskPackageId: string | undefined;
+}) {
+    let [coin] = input.tx.splitCoins(input.tx.gas, [input.tx.pure(input.fee)]);
+
+    if (input.personalKioskPackageId) {
+        const [personalKioskCap, borrow] = input.tx.moveCall({
+            target: `${input.personalKioskPackageId}::personal_kiosk::borrow_val`,
+            arguments: [input.tx.object(input.kioskCap)],
+        });
+        input.tx.moveCall({
+            target: `${input.typusPackageId}::tails_staking::stake_tails`,
+            typeArguments: [],
+            arguments: [
+                input.tx.object(input.typusEcosystemVersion),
+                input.tx.object(input.typusTailsStakingRegistry),
+                input.tx.object(input.kiosk),
+                personalKioskCap,
+                input.tx.pure(input.tails),
+                coin,
+            ],
+        });
+        input.tx.moveCall({
+            target: `${input.personalKioskPackageId}::personal_kiosk::return_val`,
+            arguments: [input.tx.object(input.kioskCap), personalKioskCap, borrow],
+        });
+    } else {
+        input.tx.moveCall({
+            target: `${input.typusPackageId}::tails_staking::stake_tails`,
+            typeArguments: [],
+            arguments: [
+                input.tx.object(input.typusEcosystemVersion),
+                input.tx.object(input.typusTailsStakingRegistry),
+                input.tx.object(input.kiosk),
+                input.tx.object(input.kioskCap),
+                input.tx.pure(input.tails),
+                coin,
+            ],
+        });
+    }
+
+    return input.tx;
+}
+
+/**
+    public fun unstake_tails(
+        version: &mut Version,
+        tails_staking_registry: &mut TailsStakingRegistry,
+        kiosk: &mut Kiosk,
+        kiosk_owner_cap: &KioskOwnerCap,
+        tails: address,
+        ctx: &TxContext,
+    ) {
+*/
+export async function getUnstakeTailsTx(input: {
+    tx: TransactionBlock;
+    typusPackageId: string;
+    typusEcosystemVersion: string;
+    typusTailsStakingRegistry: string;
+    kiosk: string;
+    kioskCap: string;
+    tails: string;
+    personalKioskPackageId: string | undefined;
+}) {
+    if (input.personalKioskPackageId) {
+        const [personalKioskCap, borrow] = input.tx.moveCall({
+            target: `${input.personalKioskPackageId}::personal_kiosk::borrow_val`,
+            arguments: [input.tx.object(input.kioskCap)],
+        });
+        input.tx.moveCall({
+            target: `${input.typusPackageId}::tails_staking::unstake_tails`,
+            typeArguments: [],
+            arguments: [
+                input.tx.object(input.typusEcosystemVersion),
+                input.tx.object(input.typusTailsStakingRegistry),
+                input.tx.object(input.kiosk),
+                personalKioskCap,
+                input.tx.pure(input.tails),
+            ],
+        });
+        input.tx.moveCall({
+            target: `${input.personalKioskPackageId}::personal_kiosk::return_val`,
+            arguments: [input.tx.object(input.kioskCap), personalKioskCap, borrow],
+        });
+    } else {
+        input.tx.moveCall({
+            target: `${input.typusPackageId}::tails_staking::unstake_tails`,
+            typeArguments: [],
+            arguments: [
+                input.tx.object(input.typusEcosystemVersion),
+                input.tx.object(input.typusTailsStakingRegistry),
+                input.tx.object(input.kiosk),
+                input.tx.object(input.kioskCap),
+                input.tx.pure(input.tails),
+            ],
+        });
+    }
+
+    return input.tx;
+}
+
+/**
+    public fun transfer_tails(
+        version: &mut Version,
+        tails_staking_registry: &TailsStakingRegistry,
+        kiosk: &mut Kiosk,
+        kiosk_owner_cap: &KioskOwnerCap,
+        tails: address,
+        coin: Coin<SUI>,
+        recipient: address,
+        ctx: &mut TxContext,
+    ) {
+*/
+export async function getTransferTailsTx(input: {
+    tx: TransactionBlock;
+    typusPackageId: string;
+    typusEcosystemVersion: string;
+    typusTailsStakingRegistry: string;
+    kiosk: string;
+    kioskCap: string;
+    tails: string;
+    recipient: string;
+    fee: string;
+    personalKioskPackageId: string | undefined;
+}) {
+    let [coin] = input.tx.splitCoins(input.tx.gas, [input.tx.pure(input.fee)]);
+
+    if (input.personalKioskPackageId) {
+        const [personalKioskCap, borrow] = input.tx.moveCall({
+            target: `${input.personalKioskPackageId}::personal_kiosk::borrow_val`,
+            arguments: [input.tx.object(input.kioskCap)],
+        });
+        input.tx.moveCall({
+            target: `${input.typusPackageId}::tails_staking::transfer_tails`,
+            typeArguments: [],
+            arguments: [
+                input.tx.object(input.typusEcosystemVersion),
+                input.tx.object(input.typusTailsStakingRegistry),
+                input.tx.object(input.kiosk),
+                personalKioskCap,
+                input.tx.pure(input.tails),
+                coin,
+                input.tx.pure(input.recipient),
+            ],
+        });
+        input.tx.moveCall({
+            target: `${input.personalKioskPackageId}::personal_kiosk::return_val`,
+            arguments: [input.tx.object(input.kioskCap), personalKioskCap, borrow],
+        });
+    } else {
+        input.tx.moveCall({
+            target: `${input.typusPackageId}::tails_staking::transfer_tails`,
+            typeArguments: [],
+            arguments: [
+                input.tx.object(input.typusEcosystemVersion),
+                input.tx.object(input.typusTailsStakingRegistry),
+                input.tx.object(input.kiosk),
+                input.tx.object(input.kioskCap),
+                input.tx.pure(input.tails),
+                coin,
+                input.tx.pure(input.recipient),
+            ],
+        });
+    }
+
+    return input.tx;
+}
+
+/**
+    entry fun daily_sign_up(
+        version: &Version,
+        tails_staking_registry: &mut TailsStakingRegistry,
+        clock: &Clock,
+        ctx: &TxContext,
+    ) {
+*/
+export async function getDailySignUpTx(input: {
+    tx: TransactionBlock;
+    typusPackageId: string;
+    typusEcosystemVersion: string;
+    typusTailsStakingRegistry: string;
+}) {
+    let result = input.tx.moveCall({
+        target: `${input.typusPackageId}::tails_staking::daily_sign_up`,
+        typeArguments: [],
+        arguments: [input.tx.object(input.typusEcosystemVersion), input.tx.object(input.typusTailsStakingRegistry), input.tx.pure(CLOCK)],
+    });
+
+    return input.tx;
+}
+
+/**
+    public fun claim_profit_sharing<TOKEN>(
+        version: &mut Version,
+        tails_staking_registry: &mut TailsStakingRegistry,
+        ctx: &mut TxContext,
+    ): Balance<TOKEN>
+*/
+export async function getClaimProfitSharingTx(input: {
+    tx: TransactionBlock;
+    typusPackageId: string;
+    typusEcosystemVersion: string;
+    typusTailsStakingRegistry: string;
+    typeArguments: string[];
+    user: string;
+}) {
+    let result = input.tx.moveCall({
+        target: `${input.typusPackageId}::tails_staking::claim_profit_sharing`,
+        typeArguments: input.typeArguments,
+        arguments: [input.tx.object(input.typusEcosystemVersion), input.tx.object(input.typusTailsStakingRegistry)],
+    });
+    input.tx.moveCall({
+        target: `${input.typusPackageId}::utility::transfer_balance`,
+        typeArguments: input.typeArguments,
+        arguments: [input.tx.object(result[0]), input.tx.pure(input.user)],
+    });
+
+    return input.tx;
+}
+
+/**
+    entry fun level_up(
+        version: &Version,
+        tails_staking_registry: &mut TailsStakingRegistry,
+        tails: address,
+        raw: bool,
+    ) {
+*/
+export async function getLevelUpTx(input: {
+    tx: TransactionBlock;
+    typusPackageId: string;
+    typusEcosystemVersion: string;
+    typusTailsStakingRegistry: string;
+    tails: string;
+    raw: boolean;
+}) {
+    input.tx.moveCall({
+        target: `${input.typusPackageId}::tails_staking::level_up`,
+        typeArguments: [],
+        arguments: [
+            input.tx.object(input.typusEcosystemVersion),
+            input.tx.object(input.typusTailsStakingRegistry),
+            input.tx.pure(input.tails),
+            input.tx.pure(input.raw),
+        ],
+    });
+
+    return input.tx;
+}
+
+/**
+    entry fun exp_up(
+        version: &Version,
+        tails_staking_registry: &mut TailsStakingRegistry,
+        typus_user_registry: &mut TypusUserRegistry,
+        tails: address,
+        amount: u64,
+        ctx: &TxContext,
+    ) {
+*/
+export async function getExpUpTx(input: {
+    tx: TransactionBlock;
+    typusPackageId: string;
+    typusEcosystemVersion: string;
+    typusTailsStakingRegistry: string;
+    typusUserRegistry: string;
+    tails: string;
+    amount: string;
+}) {
+    input.tx.moveCall({
+        target: `${input.typusPackageId}::tails_staking::exp_up`,
+        typeArguments: [],
+        arguments: [
+            input.tx.object(input.typusEcosystemVersion),
+            input.tx.object(input.typusTailsStakingRegistry),
+            input.tx.object(input.typusUserRegistry),
+            input.tx.pure(input.tails),
+            input.tx.pure(input.amount),
+        ],
+    });
+
+    return input.tx;
+}
+/**
+    entry fun exp_up_without_staking(
+        version: &Version,
+        tails_staking_registry: &TailsStakingRegistry,
+        typus_user_registry: &mut TypusUserRegistry,
+        kiosk: &mut Kiosk,
+        kiosk_owner_cap: &KioskOwnerCap,
+        tails: address,
+        amount: u64,
+        ctx: &TxContext,
+    ) {
+*/
+export async function getExpUpWithoutStakingTx(input: {
+    tx: TransactionBlock;
+    typusPackageId: string;
+    typusEcosystemVersion: string;
+    typusTailsStakingRegistry: string;
+    typusUserRegistry: string;
+    kiosk: string;
+    kioskCap: string;
+    tails: string;
+    amount: string;
+    personalKioskPackageId: string | undefined;
+}) {
+    if (input.personalKioskPackageId) {
+        const [personalKioskCap, borrow] = input.tx.moveCall({
+            target: `${input.personalKioskPackageId}::personal_kiosk::borrow_val`,
+            arguments: [input.tx.object(input.kioskCap)],
+        });
+        input.tx.moveCall({
+            target: `${input.typusPackageId}::tails_staking::exp_up_without_staking`,
+            typeArguments: [],
+            arguments: [
+                input.tx.object(input.typusEcosystemVersion),
+                input.tx.object(input.typusTailsStakingRegistry),
+                input.tx.object(input.typusUserRegistry),
+                input.tx.object(input.kiosk),
+                personalKioskCap,
+                input.tx.pure(input.tails),
+                input.tx.pure(input.amount),
+            ],
+        });
+        input.tx.moveCall({
+            target: `${input.personalKioskPackageId}::personal_kiosk::return_val`,
+            arguments: [input.tx.object(input.kioskCap), personalKioskCap, borrow],
+        });
+    } else {
+        input.tx.moveCall({
+            target: `${input.typusPackageId}::tails_staking::exp_up_without_staking`,
+            typeArguments: [],
+            arguments: [
+                input.tx.object(input.typusEcosystemVersion),
+                input.tx.object(input.typusTailsStakingRegistry),
+                input.tx.object(input.typusUserRegistry),
+                input.tx.object(input.kiosk),
+                input.tx.object(input.kioskCap),
+                input.tx.pure(input.tails),
+                input.tx.pure(input.amount),
+            ],
+        });
+    }
+
+    return input.tx;
+}
+
+export async function getCreateKioskAndLockNftTx(
+    kioskClient: KioskClient,
+    gasBudget: number,
+    nftPackageId: string,
+    policy: string,
+    nft_id: string,
+    singer: string
+) {
+    let tx = new TransactionBlock();
+
+    const kioskTx = new KioskTransaction({ transactionBlock: tx, kioskClient });
+    kioskTx.create();
+    // @ts-ignore
+    kioskTx.lock({ itemType: `${nftPackageId}::typus_nft::Tails`, itemId: nft_id, policy, item: nft_id });
+
+    const { kiosk, kioskCap } = kioskTx;
+
+    if (kiosk && kioskCap) {
+        tx.moveCall({
+            target: `0x2::transfer::public_share_object`,
+            typeArguments: [KIOSK_TYPE],
+            arguments: [kiosk],
+        });
+        tx.transferObjects([kioskCap], tx.pure(singer));
+        tx.setGasBudget(gasBudget);
+    } else {
+        console.error("Fail to Create Kiosk Tx!!");
+    }
+
+    return tx;
+}

package/src/tails-staking/view-function.ts

@@ -0,0 +1,86 @@
+import { TransactionBlock } from "@mysten/sui.js/transactions";
+import { SuiClient } from "@mysten/sui.js/client";
+import { BcsReader } from "@mysten/bcs";
+import { AddressFromBytes } from "../utils/tools";
+
+export interface StakingInfo {
+    user: string;
+    tails: string[];
+    profits: string[];
+    u64Padding: string[];
+}
+export async function getStakingInfo(input: {
+    provider: SuiClient;
+    typusPackageId: string;
+    typusEcosystemVersion: string;
+    typusTailsStakingRegistry: string;
+    user: string;
+}): Promise<StakingInfo> {
+    let transactionBlock = new TransactionBlock();
+    transactionBlock.moveCall({
+        target: `${input.typusPackageId}::tails_staking::get_staking_info`,
+        typeArguments: [],
+        arguments: [
+            transactionBlock.pure(input.typusEcosystemVersion),
+            transactionBlock.pure(input.typusTailsStakingRegistry),
+            transactionBlock.pure(input.user),
+        ],
+    });
+    let results = (
+        await input.provider.devInspectTransactionBlock({
+            sender: "0xAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA",
+            transactionBlock,
+        })
+    ).results;
+    // @ts-ignore
+    let bytes = results[results.length - 1].returnValues[0][0];
+    let reader = new BcsReader(new Uint8Array(bytes));
+    let length = reader.readULEB();
+    if (length > 0) {
+        return {
+            user: AddressFromBytes(reader.readBytes(32)),
+            tails: reader.readVec((reader) => {
+                return reader.read64();
+            }),
+            profits: reader.readVec((reader) => {
+                return reader.read64();
+            }),
+            u64Padding: reader.readVec((reader) => {
+                return reader.read64();
+            }),
+        } as StakingInfo;
+    } else {
+        return {
+            user: input.user,
+            tails: [],
+            profits: [],
+            u64Padding: ["0"],
+        } as StakingInfo;
+    }
+}
+
+export async function getLevelCounts(input: {
+    provider: SuiClient;
+    typusPackageId: string;
+    typusEcosystemVersion: string;
+    typusTailsStakingRegistry: string;
+}): Promise<number[]> {
+    let transactionBlock = new TransactionBlock();
+    transactionBlock.moveCall({
+        target: `${input.typusPackageId}::tails_staking::get_level_counts`,
+        typeArguments: [],
+        arguments: [transactionBlock.pure(input.typusEcosystemVersion), transactionBlock.pure(input.typusTailsStakingRegistry)],
+    });
+    let results = (
+        await input.provider.devInspectTransactionBlock({
+            sender: "0xAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA",
+            transactionBlock,
+        })
+    ).results;
+    // @ts-ignore
+    let bytes = results[results.length - 1].returnValues[0][0];
+    let reader = new BcsReader(new Uint8Array(bytes));
+    return reader.readVec((reader) => {
+        return Number.parseInt(reader.read64());
+    });
+}

package/src/typus-dov-single-v2/entry/authority-entry.ts

@@ -0,0 +1,171 @@
+import { TransactionBlock } from "@mysten/sui.js/transactions";
+import { CLOCK } from "src/constants";
+
+/**
+    public(friend) entry fun otc<D_TOKEN, B_TOKEN>(
+        registry: &mut Registry,
+        index: u64,
+        coins: vector<Coin<B_TOKEN>>,
+        delivery_price: u64,
+        delivery_size: u64,
+        bidder_bid_value: u64,
+        bidder_fee_balance_value: u64,
+        incentive_bid_value: u64,
+        incentive_fee_balance_value: u64,
+        depositor_incentive_value: u64,
+        clock: &Clock,
+        ctx: &mut TxContext,
+    )
+*/
+export async function getOtcTx(
+    gasBudget: number,
+    packageId: string,
+    typeArguments: string[],
+    registry: string,
+    index: string,
+    coins: string[],
+    deliveryPrice: string,
+    deliverySize: string,
+    bidderBidValue: string,
+    bidderFeeBalanceValue: string,
+    incentiveBidValue: string,
+    incentiveFeeBalanceValue: string,
+    depositorIncentiveValue: string,
+    usingSponsoredGasCoin = false
+) {
+    let tx = new TransactionBlock();
+    if (
+        !usingSponsoredGasCoin &&
+        (typeArguments[0] == "0x2::sui::SUI" ||
+            typeArguments[0] == "0x0000000000000000000000000000000000000000000000000000000000000002::sui::SUI")
+    ) {
+        let amount = BigInt(bidderBidValue) + BigInt(bidderFeeBalanceValue);
+        let [coin] = tx.splitCoins(tx.gas, [tx.pure(amount.toString())]);
+        tx.moveCall({
+            target: `${packageId}::tds_authorized_entry::otc`,
+            typeArguments,
+            arguments: [
+                tx.object(registry),
+                tx.pure(index),
+                tx.makeMoveVec({ objects: [coin] }),
+                tx.pure(deliveryPrice),
+                tx.pure(deliverySize),
+                tx.pure(bidderBidValue),
+                tx.pure(bidderFeeBalanceValue),
+                tx.pure(incentiveBidValue),
+                tx.pure(incentiveFeeBalanceValue),
+                tx.pure(depositorIncentiveValue),
+                tx.object(CLOCK),
+            ],
+        });
+    } else {
+        tx.moveCall({
+            target: `${packageId}::tds_authorized_entry::otc`,
+            typeArguments,
+            arguments: [
+                tx.object(registry),
+                tx.pure(index),
+                tx.makeMoveVec({ objects: coins.map((id) => tx.object(id)) }),
+                tx.pure(deliveryPrice),
+                tx.pure(deliverySize),
+                tx.pure(bidderBidValue),
+                tx.pure(bidderFeeBalanceValue),
+                tx.pure(incentiveBidValue),
+                tx.pure(incentiveFeeBalanceValue),
+                tx.pure(depositorIncentiveValue),
+                tx.object(CLOCK),
+            ],
+        });
+    }
+    tx.setGasBudget(gasBudget);
+
+    return tx;
+}
+
+/**
+    public(friend) entry fun update_config(
+        registry: &mut Registry,
+        index: u64,
+        oracle_id: Option<address>,
+        deposit_lot_size: Option<u64>,
+        bid_lot_size: Option<u64>,
+        min_deposit_size: Option<u64>,
+        min_bid_size: Option<u64>,
+        max_deposit_entry: Option<u64>,
+        max_bid_entry: Option<u64>,
+        deposit_fee_bp: Option<u64>,
+        deposit_fee_share_bp: Option<u64>,
+        deposit_shared_fee_pool: Option<Option<vector<u8>>>,
+        bid_fee_bp: Option<u64>,
+        deposit_incentive_bp: Option<u64>,
+        bid_incentive_bp: Option<u64>,
+        auction_delay_ts_ms: Option<u64>,
+        auction_duration_ts_ms: Option<u64>,
+        recoup_delay_ts_ms: Option<u64>,
+        capacity: Option<u64>,
+        leverage: Option<u64>,
+        risk_level: Option<u64>,
+        ctx: &TxContext,
+    ) {
+ */
+export interface UpdateConfigRequests {
+    index: string;
+    config: {
+        oracleId?: string;
+        depositLotSize?: string;
+        bidLotSize?: string;
+        minDepositSize?: string;
+        minBidSize?: string;
+        maxDepositEntry?: string;
+        maxBidEntry?: string;
+        depositFeeBp?: string;
+        depositFeeShareBp?: string;
+        depositSharedFeePool?: string;
+        bidFeeBp?: string;
+        depositIncentiveBp?: string;
+        bidIncentiveBp?: string;
+        auctionDelayTsMs?: string;
+        auctionDurationTsMs?: string;
+        recoupDelayTsMs?: string;
+        capacity?: string;
+        leverage?: string;
+        riskLevel?: string;
+        depositIncentiveBpDivisorDecimal?: string;
+    };
+}
+export async function getUpdateConfigTx(gasBudget: number, packageId: string, registry: string, requests: UpdateConfigRequests[]) {
+    let tx = new TransactionBlock();
+    requests.forEach((request) => {
+        tx.moveCall({
+            target: `${packageId}::tds_authorized_entry::update_config`,
+            typeArguments: [],
+            arguments: [
+                tx.object(registry),
+                tx.pure(request.index),
+                tx.pure(request.config.oracleId ? [request.config.oracleId] : []),
+                tx.pure(request.config.depositLotSize ? [request.config.depositLotSize] : []),
+                tx.pure(request.config.bidLotSize ? [request.config.bidLotSize] : []),
+                tx.pure(request.config.minDepositSize ? [request.config.minDepositSize] : []),
+                tx.pure(request.config.minBidSize ? [request.config.minBidSize] : []),
+                tx.pure(request.config.maxDepositEntry ? [request.config.maxDepositEntry] : []),
+                tx.pure(request.config.maxBidEntry ? [request.config.maxBidEntry] : []),
+                tx.pure(request.config.depositFeeBp ? [request.config.depositFeeBp] : []),
+                tx.pure(request.config.depositFeeShareBp ? [request.config.depositFeeShareBp] : []),
+                tx.pure(request.config.depositSharedFeePool ? [request.config.depositSharedFeePool] : []),
+                tx.pure(request.config.bidFeeBp ? [request.config.bidFeeBp] : []),
+                tx.pure(request.config.depositIncentiveBp ? [request.config.depositIncentiveBp] : []),
+                tx.pure(request.config.bidIncentiveBp ? [request.config.bidIncentiveBp] : []),
+                tx.pure(request.config.auctionDelayTsMs ? [request.config.auctionDelayTsMs] : []),
+                tx.pure(request.config.auctionDurationTsMs ? [request.config.auctionDurationTsMs] : []),
+                tx.pure(request.config.recoupDelayTsMs ? [request.config.recoupDelayTsMs] : []),
+                tx.pure(request.config.capacity ? [request.config.capacity] : []),
+                tx.pure(request.config.leverage ? [request.config.leverage] : []),
+                tx.pure(request.config.riskLevel ? [request.config.riskLevel] : []),
+                tx.pure(request.config.depositIncentiveBpDivisorDecimal ? [request.config.depositIncentiveBpDivisorDecimal] : []),
+            ],
+        });
+    });
+    tx.setGasBudget(gasBudget);
+
+    return tx;
+}

package/src/typus-dov-single-v2/entry/index.ts

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