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

package/src/_framework/util.ts

@@ -1,265 +0,0 @@
-import { TransactionArgument, TransactionBlock, TransactionObjectArgument } from "@mysten/sui.js/transactions";
-import { bcs, ObjectArg as SuiObjectArg } from "@mysten/sui.js/bcs";
-import { BcsType } from "@mysten/bcs";
-
-export interface FieldsWithTypes {
-    /* eslint-disable @typescript-eslint/no-explicit-any */
-    fields: Record<string, any>;
-    type: string;
-}
-
-export type ObjectId = string;
-
-export type ObjectCallArg = { Object: SuiObjectArg };
-
-export type ObjectArg = string | ObjectCallArg | TransactionArgument;
-
-export type PureArg = bigint | string | number | boolean | null | TransactionArgument | Array<PureArg>;
-export type GenericArg = ObjectArg | PureArg | Array<ObjectArg> | Array<PureArg> | Array<GenericArg>;
-
-export function parseTypeName(name: string): { typeName: string; typeArgs: string[] } {
-    const parsed = bcs.parseTypeName(name);
-    return { typeName: parsed.name, typeArgs: parsed.params as string[] };
-}
-
-export function isTransactionArgument(arg: GenericArg): arg is TransactionArgument {
-    if (!arg || typeof arg !== "object" || Array.isArray(arg)) {
-        return false;
-    }
-
-    return "kind" in arg;
-}
-
-export function isTransactionObjectArgument(arg: GenericArg): arg is TransactionObjectArgument {
-    if (!isTransactionArgument(arg)) {
-        return false;
-    }
-
-    if (arg.kind === "Input" && arg.type === "pure") {
-        return false;
-    }
-
-    return true;
-}
-
-export function obj(txb: TransactionBlock, arg: ObjectArg) {
-    return isTransactionArgument(arg) ? arg : txb.object(arg);
-}
-
-export function pure(txb: TransactionBlock, arg: PureArg, type: string) {
-    if (isTransactionArgument(arg)) {
-        return obj(txb, arg);
-    }
-
-    function getBcsForType(type: string): BcsType<any> {
-        const { typeName, typeArgs } = parseTypeName(type);
-        switch (typeName) {
-            case "bool":
-                return bcs.Bool;
-            case "u8":
-                return bcs.U8;
-            case "u16":
-                return bcs.U16;
-            case "u32":
-                return bcs.U32;
-            case "u64":
-                return bcs.U64;
-            case "u128":
-                return bcs.U128;
-            case "u256":
-                return bcs.U256;
-            case "address":
-                return bcs.Address;
-            case "0x1::string::String":
-            case "0x1::ascii::String":
-                return bcs.String;
-            case "0x2::object::ID":
-                return bcs.Address;
-            case "0x1::option::Option":
-                return bcs.option(getBcsForType(typeArgs[0]));
-            case "vector":
-                return bcs.vector(getBcsForType(typeArgs[0]));
-            default:
-                throw new Error(`invalid primitive type ${type}`);
-        }
-    }
-
-    function isOrHasNestedTransactionArgument(arg: PureArg): boolean {
-        if (Array.isArray(arg)) {
-            return arg.some((item) => isOrHasNestedTransactionArgument(item));
-        }
-        return isTransactionArgument(arg);
-    }
-
-    // handle some cases when TransactionArgument is nested within a vector or option
-    const { typeName, typeArgs } = parseTypeName(type);
-    switch (typeName) {
-        case "0x1::option::Option":
-            if (arg === null) {
-                return txb.pure(bcs.option(bcs.Bool).serialize(null)); // bcs.Bool is arbitrary
-            }
-            if (isOrHasNestedTransactionArgument(arg)) {
-                throw new Error("nesting TransactionArgument is not supported");
-            }
-            break;
-        case "vector":
-            if (!Array.isArray(arg)) {
-                throw new Error("expected an array for vector type");
-            }
-            if (arg.length === 0) {
-                return txb.pure(bcs.vector(bcs.Bool).serialize([])); // bcs.Bool is arbitrary
-            }
-            if (arg.some((arg) => Array.isArray(arg) && isOrHasNestedTransactionArgument(arg))) {
-                throw new Error("nesting TransactionArgument is not supported");
-            }
-            if (isTransactionArgument(arg[0]) && arg.filter((arg) => !isTransactionArgument(arg)).length > 0) {
-                throw new Error("mixing TransactionArgument with other types is not supported");
-            }
-            if (isTransactionObjectArgument(arg[0])) {
-                return txb.makeMoveVec({
-                    objects: arg as Array<TransactionObjectArgument>,
-                    type: typeArgs[0],
-                });
-            }
-    }
-
-    return txb.pure(getBcsForType(type).serialize(arg));
-}
-
-export function option(txb: TransactionBlock, type: string, arg: GenericArg | null) {
-    if (isTransactionArgument(arg)) {
-        return arg;
-    }
-    if (typeArgIsPure(type)) {
-        return pure(txb, arg as PureArg | TransactionArgument, `0x1::option::Option<${type}>`);
-    }
-    if (arg === null) {
-        return txb.moveCall({
-            target: `0x1::option::none`,
-            typeArguments: [type],
-            arguments: [],
-        });
-    }
-    // wrap it with some
-    const val = generic(txb, type, arg);
-    return txb.moveCall({
-        target: `0x1::option::some`,
-        typeArguments: [type],
-        arguments: [val],
-    });
-}
-
-export function generic(txb: TransactionBlock, type: string, arg: GenericArg) {
-    if (typeArgIsPure(type)) {
-        return pure(txb, arg as PureArg | TransactionArgument, type);
-    } else {
-        const { typeName, typeArgs } = parseTypeName(type);
-        if (typeName === "vector" && Array.isArray(arg)) {
-            const itemType = typeArgs[0];
-
-            return txb.makeMoveVec({
-                objects: arg.map((item) => obj(txb, item as ObjectArg)) as Array<TransactionObjectArgument>,
-                type: itemType,
-            });
-        } else {
-            return obj(txb, arg as ObjectArg);
-        }
-    }
-}
-
-export function vector(txb: TransactionBlock, itemType: string, items: Array<GenericArg> | TransactionArgument) {
-    if (typeArgIsPure(itemType)) {
-        return pure(txb, items as PureArg, `vector<${itemType}>`);
-    } else if (isTransactionArgument(items)) {
-        return items;
-    } else {
-        const { typeName: itemTypeName, typeArgs: itemTypeArgs } = parseTypeName(itemType);
-        if (itemTypeName === "0x1::option::Option") {
-            const objects = items.map((item) => option(txb, itemTypeArgs[0], item)) as Array<TransactionObjectArgument>;
-            return txb.makeMoveVec({
-                objects,
-                type: itemType,
-            });
-        }
-
-        return txb.makeMoveVec({
-            objects: items as Array<TransactionObjectArgument>,
-            type: itemType,
-        });
-    }
-}
-
-export function typeArgIsPure(type: string): boolean {
-    const { typeName, typeArgs } = parseTypeName(type);
-    switch (typeName) {
-        case "bool":
-        case "u8":
-        case "u16":
-        case "u32":
-        case "u64":
-        case "u128":
-        case "u256":
-        case "address":
-        case "signer":
-            return true;
-        case "vector":
-            return typeArgIsPure(typeArgs[0]);
-        case "0x1::string::String":
-        case "0x1::ascii::String":
-        case "0x2::object::ID":
-            return true;
-        case "0x1::option::Option":
-            return typeArgIsPure(typeArgs[0]);
-        default:
-            return false;
-    }
-}
-
-export function compressSuiAddress(addr: string): string {
-    // remove leading zeros
-    const stripped = addr.split("0x").join("");
-    for (let i = 0; i < stripped.length; i++) {
-        if (stripped[i] !== "0") {
-            return `0x${stripped.substring(i)}`;
-        }
-    }
-    return "0x0";
-}
-
-// Recursively removes leading zeros from a type.
-// e.g. `0x00000002::module::Name<0x00001::a::C>` -> `0x2::module::Name<0x1::a::C>`
-export function compressSuiType(type: string): string {
-    const { typeName, typeArgs } = parseTypeName(type);
-    switch (typeName) {
-        case "bool":
-        case "u8":
-        case "u16":
-        case "u32":
-        case "u64":
-        case "u128":
-        case "u256":
-        case "address":
-        case "signer":
-            return typeName;
-        case "vector":
-            return `vector<${compressSuiType(typeArgs[0])}>`;
-        default: {
-            const tok = typeName.split("::");
-            tok[0] = compressSuiAddress(tok[0]);
-            const compressedName = tok.join("::");
-            if (typeArgs.length > 0) {
-                return `${compressedName}<${typeArgs.map((typeArg) => compressSuiType(typeArg)).join(",")}>`;
-            } else {
-                return compressedName;
-            }
-        }
-    }
-}
-
-export function composeSuiType(typeName: string, ...typeArgs: string[]): string {
-    if (typeArgs.length > 0) {
-        return `${typeName}<${typeArgs.join(", ")}>`;
-    } else {
-        return typeName;
-    }
-}

package/src/airdrop/authority-entry.ts

@@ -1,101 +0,0 @@
-import { TransactionBlock } from "@mysten/sui.js/transactions";
-
-/**
-    public fun remove_airdrop<TOKEN>(
-        version: &Version,
-        typus_airdrop_registry: &mut TypusAirdropRegistry,
-        key: String,
-        ctx: &mut TxContext,
-    ): Balance<TOKEN>
-*/
-export async function getRemoveAirdropTx(
-    gasBudget: number,
-    packageId: string,
-    version: string,
-    typusLeaderboardRegistry: string,
-    key: string,
-    typeArguments: string[],
-    sender: string
-) {
-    let tx = new TransactionBlock();
-
-    const balance = tx.moveCall({
-        target: `${packageId}::airdrop::remove_airdrop`,
-        typeArguments,
-        arguments: [tx.object(version), tx.object(typusLeaderboardRegistry), tx.object(key)],
-    });
-
-    const coin = tx.moveCall({
-        target: `0x2::coin::from_balance`,
-        typeArguments,
-        arguments: [balance],
-    });
-
-    tx.transferObjects([coin], sender);
-
-    tx.setGasBudget(gasBudget);
-
-    return tx;
-}
-
-/**
-    public fun set_airdrop<TOKEN>(
-        version: &Version,
-        typus_airdrop_registry: &mut TypusAirdropRegistry,
-        key: String,
-        mut coins: vector<Coin<TOKEN>>,
-        mut users: vector<address>,
-        mut values: vector<u64>,
-        ctx: &mut TxContext,
-    )
-*/
-export async function getSetAirdropTx(
-    gasBudget: number,
-    packageId: string,
-    version: string,
-    typusLeaderboardRegistry: string,
-    key: string,
-    coins: string[],
-    amount: string,
-    users: string[],
-    values: string[],
-    typeArguments: string[]
-) {
-    let tx = new TransactionBlock();
-
-    if (
-        typeArguments[0] == "0x2::sui::SUI" ||
-        typeArguments[0] == "0x0000000000000000000000000000000000000000000000000000000000000002::sui::SUI"
-    ) {
-        let [coin] = tx.splitCoins(tx.gas, [tx.pure(amount)]);
-        tx.moveCall({
-            target: `${packageId}::airdrop::set_airdrop`,
-            typeArguments,
-            arguments: [
-                tx.object(version),
-                tx.object(typusLeaderboardRegistry),
-                tx.object(key),
-                tx.makeMoveVec({ objects: [coin] }),
-                tx.pure(users),
-                tx.pure(values),
-            ],
-        });
-    } else {
-        tx.moveCall({
-            target: `${packageId}::airdrop::set_airdrop`,
-            typeArguments,
-            arguments: [
-                tx.object(version),
-                tx.object(typusLeaderboardRegistry),
-                tx.object(key),
-                tx.makeMoveVec({ objects: coins.map((id) => tx.object(id)) }),
-                tx.pure(users),
-                tx.pure(values),
-            ],
-        });
-    }
-
-    tx.setGasBudget(gasBudget);
-
-    return tx;
-}

package/src/airdrop/index.ts

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

package/src/airdrop/user-entry.ts

@@ -1,24 +0,0 @@
-import { TransactionBlock, TransactionObjectArgument } from "@mysten/sui.js/transactions";
-
-export function getClaimAirdropTx(input: {
-    tx: TransactionBlock;
-    typusPackageId: string;
-    typusEcosystemVersion: string;
-    typusAirdropRegistry: string;
-    typeArguments: string[];
-    key: string;
-    user: string;
-}) {
-    let result = input.tx.moveCall({
-        target: `${input.typusPackageId}::airdrop::claim_airdrop`,
-        typeArguments: input.typeArguments,
-        arguments: [input.tx.object(input.typusEcosystemVersion), input.tx.object(input.typusAirdropRegistry), input.tx.pure(input.key)],
-    });
-    input.tx.moveCall({
-        target: `${input.typusPackageId}::utility::transfer_balance_opt`,
-        typeArguments: [input.typeArguments[0]],
-        arguments: [input.tx.object(result[0]), input.tx.pure(input.user)],
-    });
-
-    return input.tx;
-}

package/src/airdrop/view-function.ts

@@ -1,36 +0,0 @@
-import { TransactionBlock } from "@mysten/sui.js/transactions";
-import { SuiClient } from "@mysten/sui.js/client";
-import { BcsReader } from "@mysten/bcs";
-
-export async function getAirdrop(input: {
-    provider: SuiClient;
-    typusPackageId: string;
-    typusEcosystemVersion: string;
-    typusAirdropRegistry: string;
-    key: string;
-    user: string;
-}): Promise<string[]> {
-    let transactionBlock = new TransactionBlock();
-    transactionBlock.moveCall({
-        target: `${input.typusPackageId}::airdrop::get_airdrop`,
-        typeArguments: [],
-        arguments: [
-            transactionBlock.pure(input.typusEcosystemVersion),
-            transactionBlock.pure(input.typusAirdropRegistry),
-            transactionBlock.pure(input.key),
-            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));
-    return reader.readVec((reader) => {
-        return reader.read64();
-    });
-}

package/src/auto-bid/index.ts

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

package/src/auto-bid/user-entry.ts

@@ -1,256 +0,0 @@
-import { TransactionBlock } from "@mysten/sui.js/transactions";
-
-/**
-    entry fun new_strategy<B_TOKEN>(
-        strategy_pool: &mut StrategyPool,
-        vault_index: u64,
-        signal_index: u64,
-        size: u64,
-        price_percentage: u64,
-        max_times: u64,
-        target_rounds: vector<u64>,
-        coin: Coin<B_TOKEN>,
-        ctx: &mut TxContext
-    )
-*/
-
-export function getNewStrategyTx(
-    gasBudget: number,
-    packageId: string,
-    typeArguments: string[], // D_TOKEN, B_TOKEN
-    registry: string,
-    strategy_pool: string,
-    vault_index: string,
-    signal_index: string,
-    coins: string[],
-    amount: string,
-    size: string,
-    price_percentage: string,
-    max_times: string,
-    target_rounds: string[]
-) {
-    let tx = new TransactionBlock();
-
-    if (
-        // B_TOKEN
-        typeArguments[1] == "0x2::sui::SUI" ||
-        typeArguments[1] == "0x0000000000000000000000000000000000000000000000000000000000000002::sui::SUI"
-    ) {
-        let [input_coin] = tx.splitCoins(tx.gas, [tx.pure(amount)]);
-        tx.moveCall({
-            target: `${packageId}::auto_bid::new_strategy`,
-            typeArguments,
-            arguments: [
-                tx.object(registry),
-                tx.object(strategy_pool),
-                tx.pure(vault_index),
-                tx.pure(signal_index),
-                tx.pure(size),
-                tx.pure(price_percentage),
-                tx.pure(max_times),
-                tx.pure(target_rounds),
-                input_coin,
-            ],
-        });
-    } else {
-        const coin = coins.pop()!;
-
-        if (coins.length > 0) {
-            tx.mergeCoins(
-                tx.object(coin),
-                coins.map((coin) => tx.object(coin))
-            );
-        }
-
-        let [input_coin] = tx.splitCoins(tx.object(coin), [tx.pure(amount)]);
-
-        tx.moveCall({
-            target: `${packageId}::auto_bid::new_strategy`,
-            typeArguments,
-            arguments: [
-                tx.object(registry),
-                tx.object(strategy_pool),
-                tx.pure(vault_index),
-                tx.pure(signal_index),
-                tx.pure(size),
-                tx.pure(price_percentage),
-                tx.pure(max_times),
-                tx.pure(target_rounds),
-                input_coin,
-            ],
-        });
-    }
-    tx.setGasBudget(gasBudget);
-
-    return tx;
-}
-
-/**
-    entry fun close_strategy<D_TOKEN, B_TOKEN>(
-        strategy_pool: &mut StrategyPoolV2,
-        vault_index: u64,
-        signal_index: u64,
-        strategy_index: u64,
-        ctx: &mut TxContext
-    )
-*/
-
-export function getCloseStrategyTx(
-    gasBudget: number,
-    packageId: string,
-    typeArguments: string[], // D_TOKEN, B_TOKEN
-    registry: string,
-    strategy_pool: string,
-    vault_index: string,
-    signal_index: string,
-    strategy_index: string,
-    sender: string,
-    txBlock?: TransactionBlock
-) {
-    let tx = txBlock ? txBlock : new TransactionBlock();
-
-    let [d_token, b_token] = tx.moveCall({
-        target: `${packageId}::auto_bid::close_strategy`,
-        typeArguments,
-        arguments: [tx.object(registry), tx.object(strategy_pool), tx.pure(vault_index), tx.pure(signal_index), tx.pure(strategy_index)],
-    });
-
-    tx.transferObjects([d_token, b_token], sender);
-    tx.setGasBudget(gasBudget);
-
-    return tx;
-}
-
-export function getWithdrawProfitStrategyTx(
-    gasBudget: number,
-    packageId: string,
-    typeArguments: string[], // D_TOKEN, B_TOKEN
-    registry: string,
-    strategy_pool: string,
-    vault_index: string,
-    signal_index: string,
-    strategy_index: string,
-    sender: string,
-    txBlock?: TransactionBlock
-) {
-    let tx = txBlock ? txBlock : new TransactionBlock();
-    let d_token = tx.moveCall({
-        target: `${packageId}::auto_bid::withdraw_profit`,
-        typeArguments,
-        arguments: [tx.object(registry), tx.object(strategy_pool), tx.pure(vault_index), tx.pure(signal_index), tx.pure(strategy_index)],
-    });
-
-    tx.transferObjects([d_token], sender);
-    tx.setGasBudget(gasBudget);
-
-    return tx;
-}
-
-/**
-    entry fun update_strategy<D_TOKEN, B_TOKEN>(
-        strategy_pool: &mut StrategyPoolV2,
-        vault_index: u64,
-        signal_index: u64,
-        strategy_index: u64,
-        size: Option<u64>,
-        price_percentage: Option<u64>,
-        max_times: Option<u64>,
-        target_rounds: vector<u64>,
-        coins: vector<Coin<B_TOKEN>>,
-        ctx: & TxContext
-    )
-*/
-
-export function getUpdateStrategyTx(
-    gasBudget: number,
-    packageId: string,
-    typeArguments: string[], // D_TOKEN, B_TOKEN
-    registry: string,
-    strategy_pool: string,
-    vault_index: string,
-    signal_index: string,
-    strategy_index: string,
-    coins: string[],
-    amount: string,
-    size: string | null,
-    price_percentage: string | null,
-    max_times: string | null,
-    target_rounds: string[]
-) {
-    let tx = new TransactionBlock();
-
-    if (
-        // B_TOKEN
-        typeArguments[1] == "0x2::sui::SUI" ||
-        typeArguments[1] == "0x0000000000000000000000000000000000000000000000000000000000000002::sui::SUI"
-    ) {
-        if (amount) {
-            const [input_coin] = tx.splitCoins(tx.gas, [tx.pure(amount)]);
-
-            tx.moveCall({
-                target: `${packageId}::auto_bid::update_strategy`,
-                typeArguments,
-                arguments: [
-                    tx.object(registry),
-                    tx.object(strategy_pool),
-                    tx.pure(vault_index),
-                    tx.pure(signal_index),
-                    tx.pure(strategy_index),
-                    tx.pure(size ? [size] : []),
-                    tx.pure(price_percentage ? [price_percentage] : []),
-                    tx.pure(max_times ? [max_times] : []),
-                    tx.pure(target_rounds),
-                    tx.makeMoveVec({ objects: [input_coin] }),
-                ],
-            });
-        } else {
-            tx.moveCall({
-                target: `${packageId}::auto_bid::update_strategy`,
-                typeArguments,
-                arguments: [
-                    tx.object(registry),
-                    tx.object(strategy_pool),
-                    tx.pure(vault_index),
-                    tx.pure(signal_index),
-                    tx.pure(strategy_index),
-                    tx.pure(size ? [size] : []),
-                    tx.pure(price_percentage ? [price_percentage] : []),
-                    tx.pure(max_times ? [max_times] : []),
-                    tx.pure(target_rounds),
-                    tx.makeMoveVec({ objects: [] }),
-                ],
-            });
-        }
-    } else {
-        const coin = coins.pop()!;
-
-        if (coins.length > 0) {
-            tx.mergeCoins(
-                tx.object(coin),
-                coins.map((coin) => tx.object(coin))
-            );
-        }
-
-        const [input_coin] = tx.splitCoins(tx.object(coin), [tx.pure(amount)]);
-
-        tx.moveCall({
-            target: `${packageId}::auto_bid::update_strategy`,
-            typeArguments,
-            arguments: [
-                tx.object(registry),
-                tx.object(strategy_pool),
-                tx.pure(vault_index),
-                tx.pure(signal_index),
-                tx.pure(strategy_index),
-                tx.pure(size ? [size] : []),
-                tx.pure(price_percentage ? [price_percentage] : []),
-                tx.pure(max_times ? [max_times] : []),
-                tx.pure(target_rounds),
-                tx.makeMoveVec({ objects: [input_coin] }),
-            ],
-        });
-    }
-    tx.setGasBudget(gasBudget);
-
-    return tx;
-}