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

package/src/typus-nft/fetch.ts

@@ -1,428 +0,0 @@
-import { SuiClient, SuiEventFilter, SuiObjectResponse } from "@mysten/sui.js/client";
-import { KioskClient, KioskListing } from "@mysten/kiosk";
-
-export async function getPool(provider: SuiClient, pool: string) {
-    const res = await provider.getObject({ id: pool, options: { showContent: true } });
-
-    // @ts-ignore
-    const fields = res.data?.content.fields;
-
-    const poolData: PoolData = {
-        pool_id: pool,
-        is_live: fields.is_live,
-        start_ms: fields.start_ms,
-        num: Number(fields.num),
-        remaining: Number(fields.tails.fields.contents.fields.size),
-        table: fields.tails.fields.contents.fields.id.id,
-    };
-
-    return poolData;
-}
-
-export interface PoolData {
-    pool_id: string;
-    is_live: boolean;
-    start_ms: string;
-    num: number;
-    remaining: number;
-    table: string;
-}
-
-export const necklaces = [
-    "none",
-    "bucket_protocol",
-    "kriya_dex",
-    "cetus_protocol",
-    "ethos_wallet",
-    "typus",
-    "mysten_labs",
-    "navi_protocol",
-    "scallop_sui",
-    "shinami_corp",
-    "studio_mirai",
-    "sui_network",
-    "blockvision",
-    "team",
-    "nft_vault",
-];
-
-export async function getPoolMap(provider: SuiClient, nftConfig) {
-    let pools: string[] = necklaces.map((necklace) => nftConfig[necklace]);
-
-    const res = await provider.multiGetObjects({ ids: pools, options: { showContent: true } });
-
-    const poolMap = new Map<string, PoolData>();
-
-    necklaces.forEach(async (necklace, i) => {
-        // @ts-ignore
-        const fields = res[i].data?.content.fields;
-
-        // console.log(fields);
-
-        const poolData: PoolData = {
-            pool_id: pools[i],
-            is_live: fields.is_live,
-            start_ms: fields.start_ms,
-            num: Number(fields.num),
-            remaining: Number(fields.tails.fields.contents.fields.size),
-            table: fields.tails.fields.contents.fields.id.id,
-        };
-
-        poolMap.set(necklace, poolData);
-    });
-
-    return poolMap;
-}
-
-export async function getWhitelistMap(nftConfig, wlTokens) {
-    let pools: string[] = necklaces.map((necklace) => nftConfig[necklace]);
-
-    // console.log(pools);
-
-    const whitelistMap = new Map<string, string[]>();
-
-    necklaces.forEach(async (necklace, i) => {
-        const tokens = wlTokens.filter(
-            (wlToken) =>
-                // @ts-ignore
-                wlToken.data?.content?.fields.for == pools[i]
-        );
-
-        whitelistMap.set(
-            necklace,
-            tokens.map((token) => token.data?.objectId)
-        );
-    });
-
-    return whitelistMap;
-}
-
-export interface TailsId {
-    nftId: string;
-    kiosk: string;
-    kioskCap: string;
-    tails: Tails | undefined;
-    isPersonal: boolean;
-    listing?: KioskListing;
-}
-
-export interface kioskOwnerCap {
-    kioskId: string;
-    objectId: string;
-    isPersonal: boolean;
-}
-
-export function getkioskOwnerCaps(datas: SuiObjectResponse[]): kioskOwnerCap[] {
-    const kioskOwnerCaps: kioskOwnerCap[] = [];
-
-    for (let data of datas) {
-        if (data.data?.type == "0x2::kiosk::KioskOwnerCap") {
-            // console.log(data.data?.content);
-            // @ts-ignore
-            const fields = data.data.content.fields;
-            kioskOwnerCaps.push({ objectId: fields.id.id, kioskId: fields.for, isPersonal: false });
-        } else if (data.data?.type?.endsWith("personal_kiosk::PersonalKioskCap")) {
-            // @ts-ignore
-            const fields = data.data.content.fields;
-            kioskOwnerCaps.push({ objectId: fields.id.id, kioskId: fields.cap.fields.for, isPersonal: true });
-        }
-    }
-
-    return kioskOwnerCaps;
-}
-
-export async function getTailsIds(kioskClient: KioskClient, NFT_PACKAGE_ORIGIN: string, kioskOwnerCaps: kioskOwnerCap[]) {
-    let Tails: TailsId[] = [];
-
-    for (let kioskOwnerCap of kioskOwnerCaps) {
-        const res = await kioskClient.getKiosk({ id: kioskOwnerCap.kioskId });
-        // console.log(res);
-        const tails: TailsId[] = res.items
-            .filter((item) => item.type == `${NFT_PACKAGE_ORIGIN}::typus_nft::Tails`)
-            .map((item) => {
-                // console.log(item);
-                // @ts-ignore
-                const tails = item.data as Tails;
-                let t: TailsId = {
-                    kiosk: kioskOwnerCap.kioskId,
-                    kioskCap: kioskOwnerCap.objectId,
-                    isPersonal: kioskOwnerCap.isPersonal,
-                    nftId: item.objectId,
-                    listing: item.listing,
-                    tails,
-                };
-
-                return t;
-            });
-        // console.log(tails);
-
-        Tails = Tails.concat(tails);
-    }
-
-    return Tails;
-}
-
-export interface TailsWithType extends Tails {
-    type: string | null | undefined;
-}
-
-export async function getTails(provider: SuiClient, tailsIds: string[]) {
-    let Tails: TailsWithType[] = [];
-
-    while (tailsIds.length > 0) {
-        let len = tailsIds.length > 50 ? 50 : tailsIds.length;
-
-        const results = await provider.multiGetObjects({ ids: tailsIds.splice(0, len), options: { showContent: true } });
-
-        for (let result of results) {
-            // @ts-ignore
-            const fields = result.data?.content.fields;
-
-            const tails = fieldsToTails(fields);
-
-            Tails.push({ ...tails, type: result.data?.type });
-        }
-    }
-    return Tails;
-}
-
-export async function getTailsDynamicField(provider: SuiClient, tailsIds: string[]): Promise<[Tails[], Map<string, string>]> {
-    let Tails: TailsWithType[] = [];
-
-    let tailsToDynamicField = new Map<string, string>();
-    // let DynamicFieldToKiosk = new Map<string, string>();
-    // let KioskToOwner = new Map<string, string>();
-
-    while (tailsIds.length > 0) {
-        let len = tailsIds.length > 50 ? 50 : tailsIds.length;
-
-        const results = await provider.multiGetObjects({ ids: tailsIds.splice(0, len), options: { showContent: true, showOwner: true } });
-
-        for (let result of results) {
-            // @ts-ignore
-            const owner = result.data?.owner.ObjectOwner;
-
-            // @ts-ignore
-            const fields = result.data?.content.fields;
-
-            const tails = fieldsToTails(fields);
-
-            Tails.push({ ...tails, type: result.data?.type });
-
-            if (owner) {
-                tailsToDynamicField.set(tails.id, owner);
-            } else {
-                tailsToDynamicField.set(tails.id, "");
-            }
-        }
-    }
-    return [Tails, tailsToDynamicField];
-}
-
-export async function getTailsKiosk(provider: SuiClient, tailsToDynamicField: Map<string, string>) {
-    let DynamicFieldToKiosk = new Map<string, string>();
-    // let KioskToOwner = new Map<string, string>();
-
-    const dynamicFields = Array.from(tailsToDynamicField.values());
-
-    var i = 0;
-
-    while (dynamicFields.length > 0) {
-        let len = dynamicFields.length > 50 ? 50 : dynamicFields.length;
-
-        const results = await provider.multiGetObjects({
-            ids: dynamicFields.splice(0, len),
-            options: { showOwner: true },
-        });
-
-        for (let result of results) {
-            // @ts-ignore
-            const owner = result.data?.owner.ObjectOwner;
-
-            DynamicFieldToKiosk.set(dynamicFields.at(i)!, owner);
-            i += 1;
-        }
-    }
-    return DynamicFieldToKiosk;
-}
-
-export async function getKioskOwner(provider: SuiClient, DynamicFieldToKiosk: Map<string, string>) {
-    let KioskToOwner = new Map<string, string>();
-
-    const kiosks = Array.from(DynamicFieldToKiosk.values());
-
-    const uniqueKiosks = kiosks.filter((value, index, self) => {
-        return self.findIndex((obj) => obj === value) === index;
-    });
-
-    var i = 0;
-
-    while (uniqueKiosks.length > 0) {
-        let len = uniqueKiosks.length > 50 ? 50 : uniqueKiosks.length;
-
-        const results = await provider.multiGetObjects({
-            ids: uniqueKiosks.splice(0, len),
-            options: { showContent: true },
-        });
-
-        for (let result of results) {
-            // @ts-ignore
-            const owner = result.data?.content.fields.owner;
-
-            KioskToOwner.set(uniqueKiosks.at(i)!, owner);
-            i += 1;
-        }
-    }
-    return KioskToOwner;
-}
-
-export function fieldsToTails(fields) {
-    let id = fields.id.id;
-    if (fields.value) {
-        fields = fields.value.fields;
-    }
-    // console.log(fields.attributes.fields.contents);
-    const attributes = new Map<string, string>();
-    fields.attributes.fields.contents.forEach((f) => attributes.set(f.fields.key, f.fields.value));
-
-    const u64_padding = new Map<string, string>();
-    fields.u64_padding.fields.contents.forEach((f) => u64_padding.set(f.fields.key, f.fields.value));
-
-    const tails: Tails = {
-        id,
-        name: fields.name,
-        number: fields.number,
-        url: fields.url,
-        level: fields.level,
-        exp: fields.exp,
-        first_bid: fields.first_bid,
-        first_deposit: fields.first_deposit,
-        first_deposit_nft: fields.first_deposit_nft,
-        attributes,
-        u64_padding,
-    };
-
-    return tails;
-}
-
-export interface Tails {
-    id: string;
-    name: string;
-    number: string;
-    url: string;
-    level: string;
-    exp: string;
-    first_bid: string;
-    first_deposit: string;
-    first_deposit_nft: string;
-    attributes: Map<string, string>;
-    u64_padding: Map<string, string>;
-}
-
-export function getLevelExp(level: number): number | undefined {
-    switch (level) {
-        case 1:
-            return LevelExpVec[1];
-        case 2:
-            return LevelExpVec[2];
-        case 3:
-            return LevelExpVec[3];
-        case 4:
-            return LevelExpVec[4];
-        case 5:
-            return LevelExpVec[5];
-        case 6:
-            return LevelExpVec[6];
-        case 7:
-            return LevelExpVec[7];
-    }
-}
-
-export const LevelExpVec = [0, 0, 1_000, 50_000, 250_000, 1_000_000, 5_000_000, 20_000_000];
-
-export async function getTableTails(provider: SuiClient, parentId: string): Promise<TailsWithType[]> {
-    var result = await provider.getDynamicFields({
-        parentId,
-    });
-    var datas = result.data;
-    while (result.hasNextPage) {
-        result = await provider.getDynamicFields({
-            parentId,
-            cursor: result.nextCursor,
-        });
-        datas = datas.concat(result.data);
-    }
-    // console.log(datas);
-    const tails: TailsWithType[] = await getTails(
-        provider,
-        datas.map((data) => data.objectId)
-    );
-    // console.log(tails);
-    const levelUsers = [0, 0, 0, 0, 0, 0, 0];
-    tails.forEach((tail) => (levelUsers[Number(tail.level) - 1] += 1));
-    console.log("Level Users: ", levelUsers);
-
-    return tails;
-}
-
-export async function getDiscountPool(provider: SuiClient, pool: string) {
-    const res = await provider.getObject({ id: pool, options: { showContent: true } });
-    // console.log(res);
-
-    // @ts-ignore
-    const poolData = res.data?.content.fields as DiscountPoolData;
-
-    // @ts-ignore
-    const inventory = poolData.tails.fields.contents.fields.size - poolData.requests.length;
-    poolData.inventory = inventory;
-
-    const dynamicField = await provider.getDynamicFieldObject({
-        parentId: pool,
-        name: { type: "0x1::string::String", value: "total" },
-    });
-    // @ts-ignore
-    const total = dynamicField.data?.content.fields.value;
-    poolData.total = total;
-
-    return poolData;
-}
-
-export interface DiscountPoolData {
-    id: string;
-    num: string;
-    total: string;
-    price: string; // SUI decimal 9
-    start_ms: string;
-    end_ms: string;
-    authority: string;
-    public_key: number[];
-    discount_pcts: string[]; // decimal 2
-    is_live: boolean;
-    balance: string;
-    inventory: number;
-}
-
-export async function getMintHistory(provider: SuiClient, NFT_PACKAGE: string, vrf_input) {
-    const eventFilter: SuiEventFilter = {
-        MoveEventType: `${NFT_PACKAGE}::discount_mint::DiscountEventV3`,
-    };
-
-    var result = await provider.queryEvents({ query: eventFilter, order: "descending" });
-    // console.log(result);
-
-    // @ts-ignore
-    // result.data.forEach((d) => console.log(d.parsedJson.vrf_input));
-
-    // @ts-ignore
-    const res = result.data.filter((d) => d.parsedJson.vrf_input.toString() == vrf_input.toString());
-
-    if (res.length > 0) {
-        const eventFilter: SuiEventFilter = {
-            Transaction: res[0].id.txDigest,
-        };
-
-        var result = await provider.queryEvents({ query: eventFilter, order: "descending" });
-        // console.log(result);
-        return result;
-    }
-}

package/src/typus-nft/user-entry.ts

@@ -1,113 +0,0 @@
-import { TransactionArgument, TransactionBlock } from "@mysten/sui.js/transactions";
-import { CLOCK } from "../constants";
-
-/**
-    entry fun free_mint(
-        pool: &mut Pool,
-        whitelist_token: Whitelist,
-        ctx: &mut TxContext,
-    )
-*/
-export async function getMintTx(gasBudget: number, nftPackageId: string, policy: string, pool: string, whitelist_token: string) {
-    let tx = new TransactionBlock();
-
-    tx.moveCall({
-        target: `${nftPackageId}::typus_nft::free_mint`,
-        typeArguments: [],
-        arguments: [tx.object(pool), tx.object(policy), tx.object(whitelist_token), tx.object(CLOCK)],
-    });
-    tx.setGasBudget(gasBudget);
-
-    return tx;
-}
-
-/**
-    entry fun free_mint_into_kiosk(
-        pool: &mut Pool,
-        whitelist_token: Whitelist,
-        kiosk: &mut Kiosk,
-        kiosk_cap: &KioskOwnerCap,
-        ctx: &mut TxContext,
-    )
-*/
-export async function getMintToKioskTx(
-    gasBudget: number,
-    nftPackageId: string,
-    pool: string,
-    policy: string,
-    whitelist_token: string,
-    kiosk: string,
-    kiosk_cap: string
-) {
-    let tx = new TransactionBlock();
-
-    tx.moveCall({
-        target: `${nftPackageId}::typus_nft::free_mint_into_kiosk`,
-        typeArguments: [],
-        arguments: [
-            tx.object(pool),
-            tx.object(policy),
-            tx.object(whitelist_token),
-            tx.object(kiosk),
-            tx.object(kiosk_cap),
-            tx.object(CLOCK),
-        ],
-    });
-    tx.setGasBudget(gasBudget);
-
-    return tx;
-}
-
-/**
-    public fun pay<T>(
-        policy: &mut TransferPolicy<T>,
-        request: &mut TransferRequest<T>,
-        payment: Coin<SUI>
-    )
-*/
-export async function getPayRoyaltyTx(tx: TransactionBlock, nftPackageId: string, policy: string, request: TransactionArgument, coin) {
-    tx.moveCall({
-        target: `${nftPackageId}::royalty_rule::pay`,
-        typeArguments: [`${nftPackageId}::typus_nft::Tails`],
-        arguments: [tx.object(policy), request, coin],
-    });
-
-    return tx;
-}
-
-/**
-    entry fun request_mint(
-        pool: &mut Pool,
-        seed: u64, // 0, 1, 2
-        coin: Coin<SUI>,
-        clock: &Clock,
-        ctx: & TxContext
-    )
-*/
-export async function getRequestMintTx(gasBudget: number, nftPackageId: string, pool: string, seed: string, price: string) {
-    let tx = new TransactionBlock();
-
-    let [coin] = tx.splitCoins(tx.gas, [tx.pure(price)]);
-
-    tx.moveCall({
-        target: `${nftPackageId}::discount_mint::request_mint`,
-        typeArguments: [],
-        arguments: [tx.object(pool), tx.pure(seed), coin, tx.object(CLOCK)],
-    });
-    tx.setGasBudget(gasBudget);
-
-    return tx;
-}
-
-export async function getIsWhitelistTx(gasBudget: number, nftPackageId: string, pool: string, user: string) {
-    let tx = new TransactionBlock();
-
-    tx.moveCall({
-        target: `${nftPackageId}::discount_mint::is_whitelist`,
-        typeArguments: [],
-        arguments: [tx.object(pool), tx.pure(user)],
-    });
-    tx.setGasBudget(gasBudget);
-
-    return tx;
-}

package/src/typus-perp/admin/functions.ts

@@ -1,141 +0,0 @@
-import { PUBLISHED_AT } from "..";
-import { ObjectArg, obj, pure } from "../../_framework/util";
-import { TransactionArgument, TransactionBlock } from "@mysten/sui.js/transactions";
-
-export function upgrade(txb: TransactionBlock, version: ObjectArg) {
-    return txb.moveCall({ target: `${PUBLISHED_AT}::admin::upgrade`, arguments: [obj(txb, version)] });
-}
-
-export function init(txb: TransactionBlock) {
-    return txb.moveCall({ target: `${PUBLISHED_AT}::admin::init`, arguments: [] });
-}
-
-export function verify(txb: TransactionBlock, version: ObjectArg) {
-    return txb.moveCall({ target: `${PUBLISHED_AT}::admin::verify`, arguments: [obj(txb, version)] });
-}
-
-export interface AddAuthorizedUserArgs {
-    version: ObjectArg;
-    userAddress: string | TransactionArgument;
-}
-
-export function addAuthorizedUser(txb: TransactionBlock, args: AddAuthorizedUserArgs) {
-    return txb.moveCall({
-        target: `${PUBLISHED_AT}::admin::add_authorized_user`,
-        arguments: [obj(txb, args.version), pure(txb, args.userAddress, `address`)],
-    });
-}
-
-export interface ChargeFeeArgs {
-    version: ObjectArg;
-    balance: ObjectArg;
-}
-
-export function chargeFee(txb: TransactionBlock, typeArg: string, args: ChargeFeeArgs) {
-    return txb.moveCall({
-        target: `${PUBLISHED_AT}::admin::charge_fee`,
-        typeArguments: [typeArg],
-        arguments: [obj(txb, args.version), obj(txb, args.balance)],
-    });
-}
-
-export function issueManagerCap(txb: TransactionBlock, version: ObjectArg) {
-    return txb.moveCall({ target: `${PUBLISHED_AT}::admin::issue_manager_cap`, arguments: [obj(txb, version)] });
-}
-
-export interface RemoveAuthorizedUserArgs {
-    version: ObjectArg;
-    userAddress: string | TransactionArgument;
-}
-
-export function removeAuthorizedUser(txb: TransactionBlock, args: RemoveAuthorizedUserArgs) {
-    return txb.moveCall({
-        target: `${PUBLISHED_AT}::admin::remove_authorized_user`,
-        arguments: [obj(txb, args.version), pure(txb, args.userAddress, `address`)],
-    });
-}
-
-export function sendFee(txb: TransactionBlock, typeArg: string, version: ObjectArg) {
-    return txb.moveCall({ target: `${PUBLISHED_AT}::admin::send_fee`, typeArguments: [typeArg], arguments: [obj(txb, version)] });
-}
-
-export function versionCheck(txb: TransactionBlock, version: ObjectArg) {
-    return txb.moveCall({ target: `${PUBLISHED_AT}::admin::version_check`, arguments: [obj(txb, version)] });
-}
-
-export interface AddTailsExpAmountArgs {
-    version: ObjectArg;
-    typusEcosystemVersion: ObjectArg;
-    typusUserRegistry: ObjectArg;
-    user: string | TransactionArgument;
-    amount: bigint | TransactionArgument;
-}
-
-export function addTailsExpAmount(txb: TransactionBlock, args: AddTailsExpAmountArgs) {
-    return txb.moveCall({
-        target: `${PUBLISHED_AT}::admin::add_tails_exp_amount`,
-        arguments: [
-            obj(txb, args.version),
-            obj(txb, args.typusEcosystemVersion),
-            obj(txb, args.typusUserRegistry),
-            pure(txb, args.user, `address`),
-            pure(txb, args.amount, `u64`),
-        ],
-    });
-}
-
-export interface AddExpLeaderboardArgs {
-    version: ObjectArg;
-    typusEcosystemVersion: ObjectArg;
-    typusLeaderboardRegistry: ObjectArg;
-    user: string | TransactionArgument;
-    score: bigint | TransactionArgument;
-    clock: ObjectArg;
-}
-
-export function addExpLeaderboard(txb: TransactionBlock, args: AddExpLeaderboardArgs) {
-    return txb.moveCall({
-        target: `${PUBLISHED_AT}::admin::add_exp_leaderboard`,
-        arguments: [
-            obj(txb, args.version),
-            obj(txb, args.typusEcosystemVersion),
-            obj(txb, args.typusLeaderboardRegistry),
-            pure(txb, args.user, `address`),
-            pure(txb, args.score, `u64`),
-            obj(txb, args.clock),
-        ],
-    });
-}
-
-export interface ChargeLiquidatorFeeArgs {
-    version: ObjectArg;
-    balance: ObjectArg;
-}
-
-export function chargeLiquidatorFee(txb: TransactionBlock, typeArg: string, args: ChargeLiquidatorFeeArgs) {
-    return txb.moveCall({
-        target: `${PUBLISHED_AT}::admin::charge_liquidator_fee`,
-        typeArguments: [typeArg],
-        arguments: [obj(txb, args.version), obj(txb, args.balance)],
-    });
-}
-
-export interface InstallEcosystemManagerCapEntryArgs {
-    version: ObjectArg;
-    typusEcosystemVersion: ObjectArg;
-}
-
-export function installEcosystemManagerCapEntry(txb: TransactionBlock, args: InstallEcosystemManagerCapEntryArgs) {
-    return txb.moveCall({
-        target: `${PUBLISHED_AT}::admin::install_ecosystem_manager_cap_entry`,
-        arguments: [obj(txb, args.version), obj(txb, args.typusEcosystemVersion)],
-    });
-}
-
-export function sendLiquidatorFee(txb: TransactionBlock, typeArg: string, version: ObjectArg) {
-    return txb.moveCall({
-        target: `${PUBLISHED_AT}::admin::send_liquidator_fee`,
-        typeArguments: [typeArg],
-        arguments: [obj(txb, version)],
-    });
-}