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

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

@@ -1,401 +0,0 @@
-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

@@ -1,86 +0,0 @@
-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

@@ -1,171 +0,0 @@
-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

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