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

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/src/tails-staking/authority-entry.ts

@@ -0,0 +1,333 @@
+import { TransactionBlock, TransactionObjectInput } from "@mysten/sui.js/transactions";
+
+/**
+    entry fun upload_ids(
+        version: &Version,
+        tails_staking_registry: &mut TailsStakingRegistry,
+        mut ids: vector<address>, // reverse
+        ctx: &TxContext,
+    ) {
+*/
+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),
+            input.tx.object(input.typusTailsStakingRegistry),
+            input.tx.pure(input.ids),
+        ],
+    });
+
+    return input.tx;
+}
+
+/**
+    entry fun remove_ids(
+        version: &Version,
+        tails_staking_registry: &mut TailsStakingRegistry,
+        mut count: u64,
+        ctx: &TxContext,
+    ) {
+*/
+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),
+            input.tx.object(input.typusTailsStakingRegistry),
+            input.tx.pure(input.count),
+        ],
+    });
+
+    return input.tx;
+}
+
+/**
+    entry fun upload_levels(
+        version: &Version,
+        tails_staking_registry: &mut TailsStakingRegistry,
+        mut count: u64,
+        ctx: &TxContext,
+    ) {
+*/
+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),
+            input.tx.object(input.typusTailsStakingRegistry),
+            input.tx.pure(input.count),
+        ],
+    });
+
+    return input.tx;
+}
+
+/**
+    entry fun remove_levels(
+        version: &Version,
+        tails_staking_registry: &mut TailsStakingRegistry,
+        mut count: u64,
+        ctx: &TxContext,
+    ) {
+*/
+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),
+            input.tx.object(input.typusTailsStakingRegistry),
+            input.tx.pure(input.count),
+        ],
+    });
+
+    return input.tx;
+}
+
+/**
+    entry fun upload_ipfs_urls(
+        version: &Version,
+        tails_staking_registry: &mut TailsStakingRegistry,
+        level: u64,
+        mut urls: vector<vector<u8>>, // reverse
+        ctx: &TxContext,
+    ) {
+*/
+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),
+            input.tx.object(input.typusTailsStakingRegistry),
+            input.tx.pure(input.level),
+            input.tx.pure(input.urls),
+        ],
+    });
+
+    return input.tx;
+}
+
+/**
+    entry fun remove_ipfs_urls(
+        version: &Version,
+        tails_staking_registry: &mut TailsStakingRegistry,
+        level: u64,
+        ctx: &mut TxContext,
+    ) {
+*/
+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),
+            input.tx.object(input.typusTailsStakingRegistry),
+            input.tx.pure(input.level),
+        ],
+    });
+
+    return input.tx;
+}
+
+/**
+    entry fun upload_webp_bytes(
+        version: &Version,
+        tails_staking_registry: &mut TailsStakingRegistry,
+        number: u64,
+        level: u64,
+        mut bytes: vector<u8>, // reverse when extend
+        ctx: &TxContext,
+    ) {
+*/
+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),
+            input.tx.object(input.typusTailsStakingRegistry),
+            input.tx.pure(input.number),
+            input.tx.pure(input.level),
+            input.tx.pure(input.bytes),
+        ],
+    });
+
+    return input.tx;
+}
+
+/**
+    entry fun remove_webp_bytes(
+        version: &Version,
+        tails_staking_registry: &mut TailsStakingRegistry,
+        number: u64,
+        level: u64,
+        ctx: &TxContext,
+    ) {
+*/
+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),
+            input.tx.object(input.typusTailsStakingRegistry),
+            input.tx.pure(input.number),
+            input.tx.pure(input.level),
+        ],
+    });
+
+    return input.tx;
+}
+
+/**
+    entry fun update_tails_staking_registry_config(
+        version: &Version,
+        tails_staking_registry: &mut TailsStakingRegistry,
+        index: u64,
+        value: u64,
+        ctx: &TxContext,
+    ) {
+*/
+export function getUpdateTailsStakingRegistryConfigTx(input: {
+    tx: TransactionBlock;
+    typusPackageId: string;
+    typusEcosystemVersion: string;
+    typusTailsStakingRegistry: string;
+    index: string;
+    value: string;
+}) {
+    input.tx.moveCall({
+        target: `${input.typusPackageId}::tails_staking::update_tails_staking_registry_config`,
+        typeArguments: [],
+        arguments: [
+            input.tx.object(input.typusEcosystemVersion),
+            input.tx.object(input.typusTailsStakingRegistry),
+            input.tx.pure(input.index),
+            input.tx.pure(input.value),
+        ],
+    });
+
+    return input.tx;
+}
+
+/**
+    entry fun set_profit_sharing<TOKEN>(
+        version: &Version,
+        tails_staking_registry: &mut TailsStakingRegistry,
+        level_profits: vector<u64>,
+        mut profit: vector<Coin<TOKEN>>,
+        ctx: &TxContext,
+    ) {
+*/
+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),
+            input.tx.object(input.typusTailsStakingRegistry),
+            input.tx.pure(input.levelProfits),
+            input.tx.object(input.coin),
+            input.tx.pure(input.amount),
+            input.tx.pure(input.tsMs),
+        ],
+    });
+
+    return input.tx;
+}
+
+/**
+    entry fun remove_profit_sharing<TOKEN>(
+        version: &Version,
+        tails_staking_registry: &mut TailsStakingRegistry,
+        recipient: address,
+        ctx: &mut TxContext,
+    ) {
+*/
+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),
+            input.tx.object(input.typusTailsStakingRegistry),
+            input.tx.pure(input.recipient),
+        ],
+    });
+
+    return input.tx;
+}

package/src/tails-staking/index.ts

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