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

package/src/tails-exp-dice/user-entry.ts

@@ -0,0 +1,241 @@
+import { TransactionBlock } from "@mysten/sui.js/transactions";
+
+/**
+    public(friend) entry fun new_game<TOKEN>(
+        registry: &mut Registry,
+        index: u64,
+        coins: vector<Coin<TOKEN>>,
+        stake_amount: u64,
+        ctx: &mut TxContext
+    )
+*/
+export async function newGameTx(
+    gasBudget: number,
+    packageId: string,
+    typeArguments: string[], // [TOKEN]
+    registry: string,
+    index: string,
+    coins: string[],
+    amount: string
+) {
+    let tx = new TransactionBlock();
+    tx.moveCall({
+        target: `${packageId}::tails_exp::new_game`,
+        typeArguments,
+        arguments: [tx.object(registry), tx.pure(index), tx.makeMoveVec({ objects: coins.map((id) => tx.object(id)) }), tx.pure(amount)],
+    });
+    tx.setGasBudget(gasBudget);
+
+    return tx;
+}
+
+/**
+    public(friend) entry fun play_guess(
+        registry: &mut Registry,
+        index: u64,
+        game_id: u64,
+        guess_1: u64,
+        larger_than_1: bool,
+        guess_2: u64,
+        larger_than_2: bool,
+        ctx: &mut TxContext
+    )
+*/
+export async function playGuessTx(
+    gasBudget: number,
+    packageId: string,
+    registry: string,
+    index: string,
+    guess_1: string,
+    larger_than_1: boolean,
+    guess_2: string,
+    larger_than_2: boolean
+) {
+    let tx = new TransactionBlock();
+
+    tx.moveCall({
+        target: `${packageId}::tails_exp::play_guess`,
+        typeArguments: [],
+        arguments: [
+            tx.object(registry),
+            tx.pure(index),
+            tx.pure(guess_1),
+            tx.pure(larger_than_1),
+            tx.pure(guess_2),
+            tx.pure(larger_than_2),
+        ],
+    });
+    tx.setGasBudget(gasBudget);
+
+    return tx;
+}
+
+export async function newGamePlayGuessTx(
+    gasBudget: number,
+    packageId: string,
+    typeArguments: string[], // [TOKEN]
+    registry: string,
+    index: string,
+    coins: string[],
+    amount: string,
+    guess_1: string,
+    larger_than_1: boolean,
+    guess_2: string,
+    larger_than_2: boolean
+) {
+    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}::tails_exp::new_game`,
+            typeArguments,
+            arguments: [tx.object(registry), tx.pure(index), tx.makeMoveVec({ objects: [coin] }), tx.pure(amount)],
+        });
+    } else {
+        tx.moveCall({
+            target: `${packageId}::tails_exp::new_game`,
+            typeArguments,
+            arguments: [
+                tx.object(registry),
+                tx.pure(index),
+                tx.makeMoveVec({ objects: coins.map((id) => tx.object(id)) }),
+                tx.pure(amount),
+            ],
+        });
+    }
+
+    tx.moveCall({
+        target: `${packageId}::tails_exp::play_guess`,
+        typeArguments: [],
+        arguments: [
+            tx.object(registry),
+            tx.pure(index),
+            tx.pure(guess_1),
+            tx.pure(larger_than_1),
+            tx.pure(guess_2),
+            tx.pure(larger_than_2),
+            // tx.object("0x8"),        // TODO: waiting for upgrade
+        ],
+    });
+    tx.setGasBudget(gasBudget);
+
+    return tx;
+}
+
+/**
+    public fun consume_exp_coin_staked(
+        registry: &mut Registry,
+        version: &Version,
+        tails_staking_registry: &mut TailsStakingRegistry,
+        tails: address,
+        coin: Coin<TAILS_EXP>,
+    ) {
+ */
+export function getConsumeExpCoinStakedTx(input: {
+    tx: TransactionBlock;
+    packageId: string;
+    tailsExpRegistry: string;
+    typusEcosystemVersion: string;
+    tailsStakingRegistry: string;
+    tails: string;
+    coins: string[];
+    amount: string;
+}) {
+    let coin = input.coins.pop()!;
+    if (input.coins.length > 0) {
+        input.tx.mergeCoins(
+            input.tx.object(coin),
+            input.coins.map((id) => input.tx.object(id))
+        );
+    }
+    let [input_coin] = input.tx.splitCoins(input.tx.object(coin), [input.tx.pure(input.amount)]);
+    input.tx.moveCall({
+        target: `${input.packageId}::tails_exp::consume_exp_coin_staked`,
+        typeArguments: [],
+        arguments: [
+            input.tx.object(input.tailsExpRegistry),
+            input.tx.object(input.typusEcosystemVersion),
+            input.tx.object(input.tailsStakingRegistry),
+            input.tx.pure(input.tails),
+            input.tx.object(input_coin),
+        ],
+    });
+
+    return input.tx;
+}
+/**
+    public fun consume_exp_coin_unstaked(
+        registry: &mut Registry,
+        version: &Version,
+        tails_staking_registry: &TailsStakingRegistry,
+        kiosk: &mut Kiosk,
+        kiosk_owner_cap: &KioskOwnerCap,
+        tails: address,
+        coin: Coin<TAILS_EXP>,
+    ) {
+ */
+export function getConsumeExpCoinUnstakedTx(input: {
+    tx: TransactionBlock;
+    packageId: string;
+    tailsExpRegistry: string;
+    typusEcosystemVersion: string;
+    tailsStakingRegistry: string;
+    kiosk: string;
+    kioskCap: string;
+    tails: string;
+    coins: string[];
+    amount: string;
+    personalKioskPackageId: string | undefined;
+}) {
+    let coin = input.coins.pop()!;
+    if (input.coins.length > 0) {
+        input.tx.mergeCoins(
+            input.tx.object(coin),
+            input.coins.map((id) => input.tx.object(id))
+        );
+    }
+    let [input_coin] = input.tx.splitCoins(input.tx.object(coin), [input.tx.pure(input.amount)]);
+    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.packageId}::tails_exp::consume_exp_coin_unstaked`,
+            typeArguments: [],
+            arguments: [
+                input.tx.object(input.tailsExpRegistry),
+                input.tx.object(input.typusEcosystemVersion),
+                input.tx.object(input.tailsStakingRegistry),
+                input.tx.object(input.kiosk),
+                personalKioskCap,
+                input.tx.pure(input.tails),
+                input.tx.object(input_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.packageId}::tails_exp::consume_exp_coin_unstaked`,
+            typeArguments: [],
+            arguments: [
+                input.tx.object(input.tailsExpRegistry),
+                input.tx.object(input.typusEcosystemVersion),
+                input.tx.object(input.tailsStakingRegistry),
+                input.tx.object(input.kiosk),
+                input.tx.object(input.kioskCap),
+                input.tx.pure(input.tails),
+                input.tx.object(input_coin),
+            ],
+        });
+    }
+
+    return input.tx;
+}

package/src/tails-exp-dice/view-function.ts

@@ -0,0 +1,111 @@
+import { TransactionBlock } from "@mysten/sui.js/transactions";
+import { SuiClient, getFullnodeUrl } from "@mysten/sui.js/client";
+import { Ed25519Keypair } from "@mysten/sui.js/keypairs/ed25519";
+import { BcsReader } from "@mysten/bcs";
+import loadBls from "bls-signatures";
+
+export interface DrawResult {
+    answer_1: string;
+    result_1: string;
+    answer_2: string;
+    result_2: string;
+    exp: string;
+}
+
+export async function simulateGame(
+    network: "mainnet" | "testnet",
+    packageId: string,
+    registry: string,
+    index: string,
+    amount: string,
+    guess_1: string,
+    larger_than_1: boolean,
+    guess_2: string,
+    larger_than_2: boolean,
+    vrf_input_1: number[],
+    vrf_input_2: number[],
+    drawKeys,
+    sender = "0xb6c7e3b1c61ee81516a8317f221daa035f1503e0ac3ae7a50b61834bc7a3ead9"
+): Promise<DrawResult> {
+    const provider = new SuiClient({ url: getFullnodeUrl(network) });
+
+    let transactionBlock = new TransactionBlock();
+    let target = `${packageId}::tails_exp::simulate_game` as any;
+
+    const BLS = await loadBls();
+    const PRIVATE_KEY = Uint8Array.from(drawKeys[network][index]); // your draw key. TODO: use env for cloud function
+    let draw_private_key = BLS.PrivateKey.from_bytes(PRIVATE_KEY, true);
+
+    let bls_signature_1 = BLS.BasicSchemeMPL.sign(draw_private_key, Uint8Array.from(vrf_input_1)).serialize();
+    let bls_signature_2 = BLS.BasicSchemeMPL.sign(draw_private_key, Uint8Array.from(vrf_input_2)).serialize();
+
+    let transactionBlockArguments = [
+        transactionBlock.object(registry),
+        transactionBlock.pure(index),
+        transactionBlock.pure(amount),
+        transactionBlock.pure(guess_1),
+        transactionBlock.pure(larger_than_1),
+        transactionBlock.pure(guess_2),
+        transactionBlock.pure(larger_than_2),
+        transactionBlock.pure(uint8ArrayToBCSStringArray(Uint8Array.from(vrf_input_1))),
+        transactionBlock.pure(uint8ArrayToBCSStringArray(Uint8Array.from(vrf_input_2))),
+        transactionBlock.pure(uint8ArrayToBCSStringArray(bls_signature_1)),
+        transactionBlock.pure(uint8ArrayToBCSStringArray(bls_signature_2)),
+    ];
+    transactionBlock.moveCall({
+        target,
+        typeArguments: [],
+        arguments: transactionBlockArguments,
+    });
+    let results = (await provider.devInspectTransactionBlock({ transactionBlock, sender })).results;
+    // @ts-ignore
+    let bytes = results[results.length - 1].returnValues[0][0];
+    let reader = new BcsReader(new Uint8Array(bytes));
+    // vector[
+    //     answer_1,
+    //     result_1,
+    //     answer_2,
+    //     result_2,
+    //     exp
+    // ]
+    // skip vector length byte first
+    reader.read8();
+    let answer_1 = reader.read64();
+    let result_1 = reader.read64();
+    let answer_2 = reader.read64();
+    let result_2 = reader.read64();
+    let exp = reader.read64();
+    let result = {
+        answer_1,
+        result_1,
+        answer_2,
+        result_2,
+        exp,
+    };
+
+    return result;
+}
+
+function uint8ArrayToBCSStringArray(uint8Array: Uint8Array): string[] {
+    const result: string[] = [];
+
+    for (let i = 0; i < uint8Array.length; i++) {
+        // Assume each byte is a UTF-8 character
+        const character = String.fromCharCode(uint8Array[i]);
+
+        // Convert character to its BCS representation (you need to implement this part)
+        const bcsRepresentation = encodeToBCS(character);
+
+        // Add BCS representation to the result array
+        result.push(bcsRepresentation);
+    }
+
+    return result;
+}
+
+// Function to encode a character to its BCS representation
+function encodeToBCS(character: string): string {
+    // You need to implement this part based on BCS encoding rules
+    // This is a placeholder; the actual implementation depends on BCS specifications
+    return character.charCodeAt(0).toString();
+}

package/{dist/tails-staking/authority-entry.js → src/tails-staking/authority-entry.ts}

@@ -1,16 +1,5 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.getUploadIdsTx = getUploadIdsTx;
-exports.getRemoveIdsTx = getRemoveIdsTx;
-exports.getUploadLevelsTx = getUploadLevelsTx;
-exports.getRemoveLevelsTx = getRemoveLevelsTx;
-exports.getUploadIpfsUrlsTx = getUploadIpfsUrlsTx;
-exports.getRemoveIpfsUrlsTx = getRemoveIpfsUrlsTx;
-exports.getUploadWebpBytesTx = getUploadWebpBytesTx;
-exports.getRemoveWebpBytesTx = getRemoveWebpBytesTx;
-exports.getUpdateTailsStakingRegistryConfigTx = getUpdateTailsStakingRegistryConfigTx;
-exports.getSetProfitSharingTx = getSetProfitSharingTx;
-exports.getRemoveProfitSharingTx = getRemoveProfitSharingTx;
+import { TransactionBlock, TransactionObjectInput } from "@mysten/sui.js/transactions";
+
 /**
     entry fun upload_ids(
         version: &Version,
@@ -19,9 +8,15 @@ exports.getRemoveProfitSharingTx = getRemoveProfitSharingTx;
         ctx: &TxContext,
     ) {
 */
-function getUploadIdsTx(input) {
-    var result = input.tx.moveCall({
-        target: "".concat(input.typusPackageId, "::tails_staking::upload_ids"),
+export function getUploadIdsTx(input: {
+    tx: TransactionBlock;
+    typusPackageId: string;
+    typusEcosystemVersion: string;
+    typusTailsStakingRegistry: string;
+    ids: string[];
+}) {
+    let result = input.tx.moveCall({
+        target: `${input.typusPackageId}::tails_staking::upload_ids`,
         typeArguments: [],
         arguments: [
             input.tx.object(input.typusEcosystemVersion),
@@ -29,8 +24,10 @@ function getUploadIdsTx(input) {
             input.tx.pure(input.ids),
         ],
     });
+
     return input.tx;
 }
+
 /**
     entry fun remove_ids(
         version: &Version,
@@ -39,9 +36,15 @@ function getUploadIdsTx(input) {
         ctx: &TxContext,
     ) {
 */
-function getRemoveIdsTx(input) {
-    var result = input.tx.moveCall({
-        target: "".concat(input.typusPackageId, "::tails_staking::remove_ids"),
+export function getRemoveIdsTx(input: {
+    tx: TransactionBlock;
+    typusPackageId: string;
+    typusEcosystemVersion: string;
+    typusTailsStakingRegistry: string;
+    count: string;
+}) {
+    let result = input.tx.moveCall({
+        target: `${input.typusPackageId}::tails_staking::remove_ids`,
         typeArguments: [],
         arguments: [
             input.tx.object(input.typusEcosystemVersion),
@@ -49,8 +52,10 @@ function getRemoveIdsTx(input) {
             input.tx.pure(input.count),
         ],
     });
+
     return input.tx;
 }
+
 /**
     entry fun upload_levels(
         version: &Version,
@@ -59,9 +64,15 @@ function getRemoveIdsTx(input) {
         ctx: &TxContext,
     ) {
 */
-function getUploadLevelsTx(input) {
-    var result = input.tx.moveCall({
-        target: "".concat(input.typusPackageId, "::tails_staking::upload_levels"),
+export function getUploadLevelsTx(input: {
+    tx: TransactionBlock;
+    typusPackageId: string;
+    typusEcosystemVersion: string;
+    typusTailsStakingRegistry: string;
+    count: string;
+}) {
+    let result = input.tx.moveCall({
+        target: `${input.typusPackageId}::tails_staking::upload_levels`,
         typeArguments: [],
         arguments: [
             input.tx.object(input.typusEcosystemVersion),
@@ -69,8 +80,10 @@ function getUploadLevelsTx(input) {
             input.tx.pure(input.count),
         ],
     });
+
     return input.tx;
 }
+
 /**
     entry fun remove_levels(
         version: &Version,
@@ -79,9 +92,15 @@ function getUploadLevelsTx(input) {
         ctx: &TxContext,
     ) {
 */
-function getRemoveLevelsTx(input) {
-    var result = input.tx.moveCall({
-        target: "".concat(input.typusPackageId, "::tails_staking::remove_levels"),
+export function getRemoveLevelsTx(input: {
+    tx: TransactionBlock;
+    typusPackageId: string;
+    typusEcosystemVersion: string;
+    typusTailsStakingRegistry: string;
+    count: string;
+}) {
+    let result = input.tx.moveCall({
+        target: `${input.typusPackageId}::tails_staking::remove_levels`,
         typeArguments: [],
         arguments: [
             input.tx.object(input.typusEcosystemVersion),
@@ -89,8 +108,10 @@ function getRemoveLevelsTx(input) {
             input.tx.pure(input.count),
         ],
     });
+
     return input.tx;
 }
+
 /**
     entry fun upload_ipfs_urls(
         version: &Version,
@@ -100,9 +121,16 @@ function getRemoveLevelsTx(input) {
         ctx: &TxContext,
     ) {
 */
-function getUploadIpfsUrlsTx(input) {
-    var result = input.tx.moveCall({
-        target: "".concat(input.typusPackageId, "::tails_staking::upload_ipfs_urls"),
+export function getUploadIpfsUrlsTx(input: {
+    tx: TransactionBlock;
+    typusPackageId: string;
+    typusEcosystemVersion: string;
+    typusTailsStakingRegistry: string;
+    level: string;
+    urls: string[][];
+}) {
+    let result = input.tx.moveCall({
+        target: `${input.typusPackageId}::tails_staking::upload_ipfs_urls`,
         typeArguments: [],
         arguments: [
             input.tx.object(input.typusEcosystemVersion),
@@ -111,8 +139,10 @@ function getUploadIpfsUrlsTx(input) {
             input.tx.pure(input.urls),
         ],
     });
+
     return input.tx;
 }
+
 /**
     entry fun remove_ipfs_urls(
         version: &Version,
@@ -121,9 +151,15 @@ function getUploadIpfsUrlsTx(input) {
         ctx: &mut TxContext,
     ) {
 */
-function getRemoveIpfsUrlsTx(input) {
-    var result = input.tx.moveCall({
-        target: "".concat(input.typusPackageId, "::tails_staking::remove_ipfs_urls"),
+export function getRemoveIpfsUrlsTx(input: {
+    tx: TransactionBlock;
+    typusPackageId: string;
+    typusEcosystemVersion: string;
+    typusTailsStakingRegistry: string;
+    level: string;
+}) {
+    let result = input.tx.moveCall({
+        target: `${input.typusPackageId}::tails_staking::remove_ipfs_urls`,
         typeArguments: [],
         arguments: [
             input.tx.object(input.typusEcosystemVersion),
@@ -131,8 +167,10 @@ function getRemoveIpfsUrlsTx(input) {
             input.tx.pure(input.level),
         ],
     });
+
     return input.tx;
 }
+
 /**
     entry fun upload_webp_bytes(
         version: &Version,
@@ -143,9 +181,17 @@ function getRemoveIpfsUrlsTx(input) {
         ctx: &TxContext,
     ) {
 */
-function getUploadWebpBytesTx(input) {
-    var result = input.tx.moveCall({
-        target: "".concat(input.typusPackageId, "::tails_staking::upload_webp_bytes"),
+export function getUploadWebpBytesTx(input: {
+    tx: TransactionBlock;
+    typusPackageId: string;
+    typusEcosystemVersion: string;
+    typusTailsStakingRegistry: string;
+    number: string;
+    level: string;
+    bytes: string[];
+}) {
+    let result = input.tx.moveCall({
+        target: `${input.typusPackageId}::tails_staking::upload_webp_bytes`,
         typeArguments: [],
         arguments: [
             input.tx.object(input.typusEcosystemVersion),
@@ -155,8 +201,10 @@ function getUploadWebpBytesTx(input) {
             input.tx.pure(input.bytes),
         ],
     });
+
     return input.tx;
 }
+
 /**
     entry fun remove_webp_bytes(
         version: &Version,
@@ -166,9 +214,16 @@ function getUploadWebpBytesTx(input) {
         ctx: &TxContext,
     ) {
 */
-function getRemoveWebpBytesTx(input) {
-    var result = input.tx.moveCall({
-        target: "".concat(input.typusPackageId, "::tails_staking::remove_webp_bytes"),
+export function getRemoveWebpBytesTx(input: {
+    tx: TransactionBlock;
+    typusPackageId: string;
+    typusEcosystemVersion: string;
+    typusTailsStakingRegistry: string;
+    number: string;
+    level: string;
+}) {
+    let result = input.tx.moveCall({
+        target: `${input.typusPackageId}::tails_staking::remove_webp_bytes`,
         typeArguments: [],
         arguments: [
             input.tx.object(input.typusEcosystemVersion),
@@ -177,8 +232,10 @@ function getRemoveWebpBytesTx(input) {
             input.tx.pure(input.level),
         ],
     });
+
     return input.tx;
 }
+
 /**
     entry fun update_tails_staking_registry_config(
         version: &Version,
@@ -188,9 +245,16 @@ function getRemoveWebpBytesTx(input) {
         ctx: &TxContext,
     ) {
 */
-function getUpdateTailsStakingRegistryConfigTx(input) {
+export function getUpdateTailsStakingRegistryConfigTx(input: {
+    tx: TransactionBlock;
+    typusPackageId: string;
+    typusEcosystemVersion: string;
+    typusTailsStakingRegistry: string;
+    index: string;
+    value: string;
+}) {
     input.tx.moveCall({
-        target: "".concat(input.typusPackageId, "::tails_staking::update_tails_staking_registry_config"),
+        target: `${input.typusPackageId}::tails_staking::update_tails_staking_registry_config`,
         typeArguments: [],
         arguments: [
             input.tx.object(input.typusEcosystemVersion),
@@ -199,8 +263,10 @@ function getUpdateTailsStakingRegistryConfigTx(input) {
             input.tx.pure(input.value),
         ],
     });
+
     return input.tx;
 }
+
 /**
     entry fun set_profit_sharing<TOKEN>(
         version: &Version,
@@ -210,9 +276,19 @@ function getUpdateTailsStakingRegistryConfigTx(input) {
         ctx: &TxContext,
     ) {
 */
-function getSetProfitSharingTx(input) {
-    var result = input.tx.moveCall({
-        target: "".concat(input.typusPackageId, "::tails_staking::set_profit_sharing"),
+export function getSetProfitSharingTx(input: {
+    tx: TransactionBlock;
+    typusPackageId: string;
+    typusEcosystemVersion: string;
+    typusTailsStakingRegistry: string;
+    typeArguments: string[];
+    levelProfits: string[];
+    coin: TransactionObjectInput;
+    amount: string;
+    tsMs: string;
+}) {
+    let result = input.tx.moveCall({
+        target: `${input.typusPackageId}::tails_staking::set_profit_sharing`,
         typeArguments: input.typeArguments,
         arguments: [
             input.tx.object(input.typusEcosystemVersion),
@@ -223,8 +299,10 @@ function getSetProfitSharingTx(input) {
             input.tx.pure(input.tsMs),
         ],
     });
+
     return input.tx;
 }
+
 /**
     entry fun remove_profit_sharing<TOKEN>(
         version: &Version,
@@ -233,9 +311,16 @@ function getSetProfitSharingTx(input) {
         ctx: &mut TxContext,
     ) {
 */
-function getRemoveProfitSharingTx(input) {
-    var result = input.tx.moveCall({
-        target: "".concat(input.typusPackageId, "::tails_staking::remove_profit_sharing"),
+export function getRemoveProfitSharingTx(input: {
+    tx: TransactionBlock;
+    typusPackageId: string;
+    typusEcosystemVersion: string;
+    typusTailsStakingRegistry: string;
+    typeArguments: string[];
+    recipient: string;
+}) {
+    let result = input.tx.moveCall({
+        target: `${input.typusPackageId}::tails_staking::remove_profit_sharing`,
         typeArguments: input.typeArguments,
         arguments: [
             input.tx.object(input.typusEcosystemVersion),
@@ -243,5 +328,6 @@ function getRemoveProfitSharingTx(input) {
             input.tx.pure(input.recipient),
         ],
     });
+
     return input.tx;
 }