Game

C:\Users\Alice>endless --version
endless 2.4.0

{path}\mkdir endless-hero
{path}\cd  endless-hero
{path}\endless-hero>mkdir move
{path}\endless-hero>cd move

endless move init --name endless-hero
Success

move
├─scripts
├─sources
└─tests
└─Move.toml

endless init
Configuring for profile default
Choose network from [testnet, mainnet, local, custom | defaults to testnet]

Enter your private key as a hex literal (0x...) [Current: None | No input: Generate new key (or keep one if present)]

No key given, generating key...
Account 0xd4a2aa8290cde4791919c6f0b74d00464e598104dcc2cd3158ae1d7d6e5b91b3 doesn't exist, creating it and funding it with 100000000 Veins
Account 0xd4a2aa8290cde4791919c6f0b74d00464e598104dcc2cd3158ae1d7d6e5b91b3 funded successfully

---
Endless CLI is now set up for account 0xd4a2aa8290cde4791919c6f0b74d00464e598104dcc2cd3158ae1d7d6e5b91b3 as profile default!  Run `endless --help` for more information about commands
Success

---
profiles:
  default:
    private_key: "0xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx"
    public_key: "0x61f0767d5c8a158f10b6cdc19703558095c159b44da4d23745c6e00bdbbcf87e"
    account: d4a2aa8290cde4791919c6f0b74d00464e598104dcc2cd3158ae1d7d6e5b91b3
    rest_url: "https://rpc-test.endless.link"

endless account list --query balance 
[1000000000]

[addresses]
hero_address = "d4a2aa8290cde4791919c6f0b74d00464e598104dcc2cd3158ae1d7d6e5b91b3"

[dependencies.EndlessFramework]
git = "https://github.com/endless-labs/endless-move-framework"
rev = "main"
subdir = "endless-framework"

[dependencies]
EndlessFramework = {git = "https://github.com/endless-labs/endless-move-framework", subdir = "endless-framework", rev = "8332b04"}
EndlessToken = {git = "https://github.com/endless-labs/endless-move-framework", subdir = "endless-token", rev = "8332b04"}

#[resource_group_member(group = endless_framework::object::ObjectGroup)]
struct Armor has key {
    defense: u64,
    gem: Option<Object<Gem>>,
    weight: u64,
}

#[resource_group_member(group = endless_framework::object::ObjectGroup)]
struct Gem has key {
    attack_modifier: u64,
    defense_modifier: u64,
    magic_attribute: String,
}

fun create(
    creator: &signer,
    description: String,
    name: String,
    uri: String,
): ConstructorRef acquires OnChainConfig {
    let on_chain_config = borrow_global<OnChainConfig>(signer::address_of(creator));
    token::create_named_token(
        creator,
        on_chain_config.collection,
        description,
        name,
        option::none(),
        uri,
    )
}

public fun create_hero(
    creator: &signer,
    description: String,
    gender: String,
    name: String,
    race: String,
    uri: String,
): Object<Hero> acquires OnChainConfig {
    let constructor_ref = create(creator, description, name, uri);
    let token_signer = object::generate_signer(&constructor_ref);

    let hero = Hero {
        armor: option::none(),
        gender,
        race,
        shield: option::none(),
        weapon: option::none(),
        mutator_ref: token::generate_mutator_ref(&constructor_ref),
    };
    move_to(&token_signer, hero);

    object::address_to_object(signer::address_of(&token_signer))
}

entry fun transfer_nft_to_player(
    owner: &signer,
    nft_address: address,
    to_player: address,
)  {
    if (exists<Armor>(nft_address)) {
        let armor_obj = object::address_to_object<Armor>(nft_address);
        assert!(object::is_owner(armor_obj, signer::address_of(owner)), EOWNER_NOT_MATCH);
        object::transfer(owner,armor_obj, to_player);
    } else if (exists<Gem>(nft_address)) {
        let gem_obj = object::address_to_object<Gem>(nft_address);
        assert!(object::is_owner(gem_obj, signer::address_of(owner)), EOWNER_NOT_MATCH);
        object::transfer(owner,gem_obj, to_player);
    } else if (exists<Hero>(nft_address)) {
        let hero_obj = object::address_to_object<Hero>(nft_address);
        assert!(object::is_owner(hero_obj, signer::address_of(owner)), EOWNER_NOT_MATCH);
        object::transfer(owner,hero_obj, to_player);
    } else if (exists<Shield>(nft_address)) {
        let shield_obj = object::address_to_object<Shield>(nft_address);
        assert!(object::is_owner(shield_obj, signer::address_of(owner)), EOWNER_NOT_MATCH);
        object::transfer(owner,shield_obj, to_player);
    } else if (exists<Weapon>(nft_address)) {
            let weapon_obj = object::address_to_object<Weapon>(nft_address);
        assert!(object::is_owner(weapon_obj, signer::address_of(owner)), EOWNER_NOT_MATCH);
        object::transfer(owner,weapon_obj, to_player);
    } else {
        abort EINVALID_TYPE
    }
}

\endless-hero>cd move
endless-hero\move>endless move compile
Compiling, may take a little while to download git dependencies...
INCLUDING DEPENDENCY EndlessFramework
INCLUDING DEPENDENCY EndlessStdlib
INCLUDING DEPENDENCY EndlessToken
INCLUDING DEPENDENCY MoveStdlib
BUILDING endless-hero
[d4a2aa8290cde4791919c6f0b74d00464e598104dcc2cd3158ae1d7d6e5b91b3::hero]

\endless-hero\move>endless move publish 
Compiling, may take a little while to download git dependencies...
INCLUDING DEPENDENCY EndlessFramework
INCLUDING DEPENDENCY EndlessStdlib
INCLUDING DEPENDENCY EndlessToken
INCLUDING DEPENDENCY MoveStdlib
BUILDING endless-hero
package size 6129 bytes
Do you want to submit a transaction for a range of [438600 - 657900] Veins at a gas unit price of 100 Veins? [yes/no] >
yes
transaction_hash:MVZyn5hamcCX5RhY8KrbVmLJ9Je7r3Ffh1dyDPdZuXH
gas_used:4386
gas_unit_price:100
sender:d4a2aa8290cde4791919c6f0b74d00464e598104dcc2cd3158ae1d7d6e5b91b3
sequence_number:0
success:true
timestamp_us:1750486559926763
version:235395928
vm_status:Executed successfully

{path}\endless-hero>npm init -y

npm install @endlesslab/endless-ts-sdk dotenv
npm install --save-dev @types/node

{
  "compilerOptions": {
    "target": "es2020",
    "module": "commonjs",
    "esModuleInterop": true,
    "forceConsistentCasingInFileNames": true,
    "strict": true,
    "skipLibCheck": true,
    "types": ["node"],
    "lib": ["es2020"]
  }
}

ENDLESS_NETWORK=testnet

mkdir web3

// account.ts
import {
    Account,
    AccountAddress,
    Ed25519Account,
    Ed25519PrivateKey,
    Endless,
} from "@endlesslab/endless-ts-sdk";
import * as fs from 'fs';

// account.ts
interface AccountData {
    address: string;
    private_key: string;
}

async function writeJsonFileAsync(filename: string, data: any): Promise<void> {
    try {
        const jsonString = JSON.stringify(data, null, 2);
        await fs.promises.writeFile(filename, jsonString, 'utf8');
        console.log(`✅ Asynchronous write success: Data has been saved to ${filename}`);
    } catch (error) {
        console.error(`❌ Asynchronous write failed ${filename}:`, error);
    }
}

async function readJsonFileAsync<T>(filename: string): Promise<T | null> {
    try {
        const fileContent = await fs.promises.readFile(filename, 'utf8');
        console.log(`✅ Asynchronous read succeeded: Read file contents from ${filename}.`);
        const parsedData: T = JSON.parse(fileContent);
        console.log(`✅ Deserialization successful: Parsed ${filename} contents into an object.`);
        return parsedData;
    } catch (error: any) {
        if (error.code === 'ENOENT') { // ENOENT Indicates that the file does not exist
            console.error(`❌ Read failed: file '${filename}' does not exist.`);
        } else if (error instanceof SyntaxError) {
            console.error(`❌ Read failed: The contents of file '${filename}' are not in valid JSON format.`, error.message);
        } else {
            console.error(`❌ Asynchronous read or deserialization failed from ${filename}:`, error);
        }
        return null;
    }
}

export async function createOrLoadAccount(accountName: string): Promise<Ed25519Account> {
    const filename = accountName + ".json";
    const json_data = await readJsonFileAsync<AccountData>(filename);
    let account = null;
    if (json_data == null) {
        account = Account.generate();
        const json_data: AccountData = {
            address: account.accountAddress.toString(),
            private_key: account.privateKey.toString()
        };
        writeJsonFileAsync(filename, json_data)
            .then(() => {
                console.log(`Completes a single object asynchronous write operation to ${filename}`);
            });

    } else {
        const address = AccountAddress.fromString(json_data.address);
        account = Account.fromPrivateKey({ privateKey: new Ed25519PrivateKey(json_data.private_key) });
    }
    return account;
}

// account.ts
function sleep(ms: number): Promise<void> {
  return new Promise(resolve => setTimeout(resolve, ms));
}

export async function fundAccount(chain: Endless, signer: Ed25519Account) {
    try {
        console.log("Funding ", signer.accountAddress.toString(), "'s account...");
        await chain.fundAccount({ signer });
    } catch (error: any) {
        console.error("Error:", error.message);
    }
    await sleep(3000);
    try {
        const balance = await chain.viewEDSBalance(signer.accountAddress);
        console.log("current balance:", balance);
    } catch (error: any) {
        console.error("Error:", error.message);
    }
}

// account.ts
import {
    Account,
    AccountAddress,
    Ed25519Account,
    Ed25519PrivateKey,
    Endless,
} from "@endlesslab/endless-ts-sdk";
import * as fs from 'fs';

interface AccountData {
    address: string;
    private_key: string;
}

async function writeJsonFileAsync(filename: string, data: any): Promise<void> {
    try {
        const jsonString = JSON.stringify(data, null, 2);
        await fs.promises.writeFile(filename, jsonString, 'utf8');
        console.log(`✅ Asynchronous write success: Data has been saved to ${filename}`);
    } catch (error) {
        console.error(`❌ Asynchronous write failed ${filename}:`, error);
    }
}

async function readJsonFileAsync<T>(filename: string): Promise<T | null> {
    try {
        const fileContent = await fs.promises.readFile(filename, 'utf8');
        console.log(`✅ Asynchronous read succeeded: Read file contents from ${filename}.`);
        const parsedData: T = JSON.parse(fileContent);
        console.log(`✅ Deserialization successful: Parsed ${filename} contents into an object.`);
        return parsedData;
    } catch (error: any) {
        if (error.code === 'ENOENT') { // ENOENT Indicates that the file does not exist
            console.error(`❌ Read failed: file '${filename}' does not exist.`);
        } else if (error instanceof SyntaxError) {
            console.error(`❌ Read failed: The contents of file '${filename}' are not in valid JSON format.`, error.message);
        } else {
            console.error(`❌ Asynchronous read or deserialization failed from ${filename}:`, error);
        }
        return null;
    }
}

export async function createOrLoadAccount(accountName: string): Promise<Ed25519Account> {
    const filename = accountName + ".json";
    const json_data = await readJsonFileAsync<AccountData>(filename);
    let account = null;
    if (json_data == null) {
        account = Account.generate();
        const json_data: AccountData = {
            address: account.accountAddress.toString(),
            private_key: account.privateKey.toString()
        };
        writeJsonFileAsync(filename, json_data)
            .then(() => {
                console.log(`Completes a single object asynchronous write operation to ${filename}`);
            });

    } else {
        const address = AccountAddress.fromString(json_data.address);
        account = Account.fromPrivateKey({ privateKey: new Ed25519PrivateKey(json_data.private_key) });
    }
    return account;
}

function sleep(ms: number): Promise<void> {
  return new Promise(resolve => setTimeout(resolve, ms));
}

export async function fundAccount(chain: Endless, signer: Ed25519Account) {
    try {
        console.log("Funding ", signer.accountAddress.toString(), "'s account...");
        await chain.fundAccount({ signer });
    } catch (error: any) {
        console.error("Error:", error.message);
    }
    await sleep(3000);
    try {
        const balance = await chain.viewEDSBalance(signer.accountAddress);
        console.log("current balance:", balance);
    } catch (error: any) {
        console.error("Error:", error.message);
    }
}

import "dotenv/config";
import {
    Endless,
    EndlessConfig,
    Network,
    NetworkToNetworkName,
} from "@endlesslab/endless-ts-sdk";

import { createOrLoadAccount, fundAccount } from './web3/account'
// Verify environment variables are loaded
console.log("Environment variables loaded:", {
    ENDLESS_NETWORK: process.env.ENDLESS_NETWORK || "not set"
});

// console.log("Step 1: Setting up a client to connect to Aptos");
const ENDLESS_NETWORK = NetworkToNetworkName[process.env.ENDLESS_NETWORK!] || Network.DEVNET;
const config = new EndlessConfig({ network: ENDLESS_NETWORK });
const endless = new Endless(config);

const command = process.argv[2];

async function create_or_load_account() {
    const name = process.argv[3];
    if (name == null) {
        create_or_load_account_help()
        return;
    }
    await createOrLoadAccount(name);
    return;
}

function create_or_load_account_help() {
    console.log("1.[");
    console.log("\x1b[32mcommand:\x1b[0m");
    console.log("create_or_load_account");
    console.log("\x1b[32mparameters:\x1b[0m");
    console.log("account_name");
    console.log("\x1b[32mexample:\x1b[0m");
    console.log("npx ts-node index.ts create_or_load_account user1");
    console.log("]");
}


async function fund_account() {
    const name = process.argv[3];
    if (name == null) {
        fund_account_help()
        return;
    }
    const account = await createOrLoadAccount(name);
    await fundAccount(endless, account);
    return;
}

function fund_account_help() {
    console.log("2.[");
    console.log("\x1b[32mcommand:\x1b[0m");
    console.log("fund_account");
    console.log("\x1b[32mparameters:\x1b[0m");
    console.log("account_name");
    console.log("\x1b[32mexample:\x1b[0m");
    console.log("npx ts-node index.ts fund_account user1");
    console.log("]");
}

function help() {
    create_or_load_account_help();
}

async function main() {
    if (command === "help" || command == null) {
        help();
    } else {
        switch (command) {
            case "create_or_load_account": {
                await create_or_load_account();
            }
                break;
            case "fund_account": {
                await fund_account();
            }
                break;
        }
    }
}

main();

npx ts-node index.ts create_or_load_account alice
Environment variables loaded: { ENDLESS_NETWORK: 'testnet' }
❌ Read failed: file 'alice.json' does not exist.
✅ Asynchronous write success: Data has been saved to alice.json
Completes a single object asynchronous write operation to alice.json

{
  "address": "0x75f4fd0c6f2f6f29326f5a286fc7d368cb3cfcbea067d9cc9e8f262a8b596649",
  "private_key": "********"
}

npx ts-node index.ts fund_account alice
Environment variables loaded: { ENDLESS_NETWORK: 'testnet' }
✅ Asynchronous read succeeded: Read file contents from alice.json.
✅ Deserialization successful: Parsed alice.json contents into an object.
Funding  0x75f4fd0c6f2f6f29326f5a286fc7d368cb3cfcbea067d9cc9e8f262a8b596649 's account...
current balance: 1000000000n

ENDLESS_NETWORK=testnet
CONTRACT_ADDRESS=d4a2aa8290cde4791919c6f0b74d00464e598104dcc2cd3158ae1d7d6e5b91b3

// event.ts
export interface CollectionMintData {
  collection: string;
  index: string;
  token: string;
}

//  nft.ts.
import {
    Account,
    AccountAddress,
    Endless,
    isUserTransactionResponse,
    MoveFunctionId,
    SimpleTransaction
} from "@endlesslab/endless-ts-sdk";
import { CollectionMintData } from "./event";

const contract_address = process.env.CONTRACT_ADDRESS || "d4a2aa8290cde4791919c6f0b74d00464e598104dcc2cd3158ae1d7d6e5b91b3";

const fun_mint_hero = toMoveFunctionId(`${contract_address}::hero::mint_hero`);

function toMoveFunctionId(str: string): MoveFunctionId {
    if (!str.includes("::")) throw new Error("Invalid function name format");
    const parts = str.split("::");
    if (parts.length !== 3) throw new Error("Function name must have 3 parts");
    if (!AccountAddress.isValid({ input: parts[0], strict: true })) throw new Error("Contract address is not valid.");
    return str as MoveFunctionId;
}

async function mintNFT(endless: Endless, mgrSigner: Account, transaction: SimpleTransaction): Promise<string | null> {
    let committedTxn = null;
    let result = null;
    try {
        // Sign and submit the transaction
        committedTxn = await endless.signAndSubmitTransaction({
            signer: mgrSigner,
            transaction: transaction,
        });
        console.log("Transaction submitted, hash:", committedTxn.hash);
    } catch (error: any) {
        console.error("committedTxn error:", error.message);
        return null;
    }

    try {
        // Wait for transaction confirmation
        const response = await endless.waitForTransaction({ transactionHash: committedTxn.hash });
        const response_str = JSON.stringify(response);
        console.log("Transaction confirmed:", response_str);
        if (isUserTransactionResponse(response) && response.vm_status == "Executed successfully") {
            for (const event of response.events) {
                if (event.type === "0x4::collection::Mint") {
                    const data = event.data as CollectionMintData;
                    return data.token;
                }
            }
        }
    } catch (error: any) {
        console.error("waitForTransaction error:", error.message);
        return null;
    }

    return result;
}

export async function mintHeroAndGetId(
    endless: Endless,
    mgrSigner: Account,
    heroName: string,
    heroDescription: string,
    heroUri: string,
    heroGender: string,
    heroRace: string
): Promise<string | null> {
    try {
        const transaction = await endless.transaction.build.simple({
            sender: mgrSigner.accountAddress,
            data: {
                function: fun_mint_hero,
                typeArguments: [],
                functionArguments: [
                    heroDescription,
                    heroGender,
                    heroName,
                    heroRace,
                    heroUri,
                ],
            },
        });
        return await mintNFT(endless, mgrSigner, transaction);
    } catch (error) {
        console.error("Error during NFT minting:", error);
        return null;
    }
}

import "dotenv/config";
import {
    Endless,
    EndlessConfig,
    Network,
    NetworkToNetworkName,
} from "@endlesslab/endless-ts-sdk";

import { createOrLoadAccount, fundAccount } from './web3/account'
import { mintHeroAndGetId } from "./web3/nft";
// Verify environment variables are loaded
console.log("Environment variables loaded:", {
    ENDLESS_NETWORK: process.env.ENDLESS_NETWORK || "not set"
});

// console.log("Step 1: Setting up a client to connect to Aptos");
const ENDLESS_NETWORK = NetworkToNetworkName[process.env.ENDLESS_NETWORK!] || Network.DEVNET;
const config = new EndlessConfig({ network: ENDLESS_NETWORK });
const endless = new Endless(config);

const command = process.argv[2];

async function create_or_load_account() {
    const name = process.argv[3];
    if (name == null) {
        create_or_load_account_help()
        return;
    }
    await createOrLoadAccount(name);
    return;
}

function create_or_load_account_help() {
    console.log("1.[");
    console.log("\x1b[32mcommand:\x1b[0m");
    console.log("create_or_load_account");
    console.log("\x1b[32mparameters:\x1b[0m");
    console.log("account_name");
    console.log("\x1b[32mexample:\x1b[0m");
    console.log("npx ts-node index.ts create_or_load_account user1");
    console.log("]");
}


async function fund_account() {
    const name = process.argv[3];
    if (name == null) {
        fund_account_help()
        return;
    }
    const account = await createOrLoadAccount(name);
    await fundAccount(endless, account);
    return;
}

function fund_account_help() {
    console.log("2.[");
    console.log("\x1b[32mcommand:\x1b[0m");
    console.log("fund_account");
    console.log("\x1b[32mparameters:\x1b[0m");
    console.log("account_name");
    console.log("\x1b[32mexample:\x1b[0m");
    console.log("npx ts-node index.ts fund_account user1");
    console.log("]");
}

async function mint_hero() {
    const creator = process.argv[3];
    const heroName = process.argv[4];
    const heroDescription = process.argv[5];
    const heroUri = process.argv[6];
    const heroGender = process.argv[7];
    const heroRace = process.argv[8];
    if (creator == null || heroName == null || heroDescription == null
        || heroUri == null || heroGender == null || heroRace == null
    ) {
        mint_hero_help()
        return;
    }
    const creator_account = await createOrLoadAccount(creator);
    const id = await mintHeroAndGetId(endless, creator_account, heroName, heroDescription, heroUri, heroGender, heroRace);
    console.log(id);
}


function mint_hero_help() {
    console.log("3.[");
    console.log("\x1b[32mcommand:\x1b[0m");
    console.log("mint_hero");
    console.log("\x1b[32mparameters:\x1b[0m");
    console.log("creator heroName heroDescription heroUri heroGender heroRace");
    console.log("\x1b[32mexample:\x1b[0m");
    console.log("npx ts-node index.ts mint_hero mgr heroName heroDescription heroUri heroGender heroRace");
    console.log("]");
}

function help() {
    create_or_load_account_help();
    fund_account_help();
    mint_hero_help();
}

async function main() {
    if (command === "help" || command == null) {
        help();
    } else {
        switch (command) {
            case "create_or_load_account": {
                await create_or_load_account();
            }
                break;
            case "fund_account": {
                await fund_account();
            }
                break;
            case "mint_hero": {
                await mint_hero();
            }
        }
    }
}

main();

{
  "address": "0xd4a2aa8290cde4791919c6f0b74d00464e598104dcc2cd3158ae1d7d6e5b91b3",
  "private_key": "0xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx"
}

npx ts-node index.ts mint_hero mgr test_heroName heroDescription heroUri heroGender heroRace
Environment variables loaded: { ENDLESS_NETWORK: 'testnet' }
✅ Asynchronous read succeeded: Read file contents from mgr.json.
✅ Deserialization successful: Parsed mgr.json contents into an object.
Transaction submitted, hash: 0xefa136421b0807116e6bac457d0d8fb297630541b284629dcf97733d8afbac0a
H9ZVsV1rME62Fr8yYGbb2DxekDFcUm9H2p3j2QFE8mTJ

Type:

FK3J64indQEVV42Qz1a1s38o4bx6DaZxyWL4WygKvc7c::hero::Hero
{
  "armor": {
    "vec": []
  },
  "gender": "heroGender",
  "mutator_ref": {
    "self": "H9ZVsV1rME62Fr8yYGbb2DxekDFcUm9H2p3j2QFE8mTJ"
  },
  "race": "heroRace",
  "shield": {
    "vec": []
  },
  "weapon": {
    "vec": []
  }
}

Type:

0x1::object::ObjectCore
{
  "allow_ungated_transfer": true,
  "guid_creation_num": "1125899906842625",
  "owner": "FK3J64indQEVV42Qz1a1s38o4bx6DaZxyWL4WygKvc7c",
  "transfer_events": {
    "counter": "0",
    "guid": {
      "id": {
        "addr": "H9ZVsV1rME62Fr8yYGbb2DxekDFcUm9H2p3j2QFE8mTJ",
        "creation_num": "1125899906842624"
      }
    }
  }
}

npx ts-node index.ts mint_weapon mgr weaponName weaponDescription weaponUri weaponType 2000 20
Environment variables loaded: { ENDLESS_NETWORK: 'testnet' }
✅ Asynchronous read succeeded: Read file contents from mgr.json.
✅ Deserialization successful: Parsed mgr.json contents into an object.
Transaction submitted, hash: 0x932dc6af2e7cf89f96cc3e0b38d2bd98068f462710161dd82f490e3ac3e3ab57
......
AAsAGWsPCLyn3Gx5b6hPixYWc1vM67YogwDNgx3mXyon

Type:

FK3J64indQEVV42Qz1a1s38o4bx6DaZxyWL4WygKvc7c::hero::Weapon
{
  "attack": "2000",
  "gem": {
    "vec": []
  },
  "weapon_type": "weaponType",
  "weight": "20"
}

Type:

0x1::object::ObjectCore
{
  "allow_ungated_transfer": true,
  "guid_creation_num": "1125899906842625",
  "owner": "FK3J64indQEVV42Qz1a1s38o4bx6DaZxyWL4WygKvc7c",
  "transfer_events": {
    "counter": "0",
    "guid": {
      "id": {
        "addr": "AAsAGWsPCLyn3Gx5b6hPixYWc1vM67YogwDNgx3mXyon",
        "creation_num": "1125899906842624"
      }
    }
  }
}

npx ts-node index.ts mint_gem mgr gemName_003 gemDescription_001 gemUri 300 2000 gemMagicAttribute
Environment variables loaded: { ENDLESS_NETWORK: 'testnet' }
✅ Asynchronous read succeeded: Read file contents from mgr.json.
✅ Deserialization successful: Parsed mgr.json contents into an object.
Transaction submitted, hash: 0x035ab7d7f68701dce84ce75d5359cb94f1baafa3bad04814c8c960d5e74d265c
......
EiCX3rtKrhcXZsbeey1dqD5jeDPodcvqaWxG7JDKePoP

Type:

FK3J64indQEVV42Qz1a1s38o4bx6DaZxyWL4WygKvc7c::hero::Gem
{
  "attack_modifier": "300",
  "defense_modifier": "2000",
  "magic_attribute": "gemMagicAttribute"
}

Type:

0x1::object::ObjectCore
{
  "allow_ungated_transfer": true,
  "guid_creation_num": "1125899906842625",
  "owner": "FK3J64indQEVV42Qz1a1s38o4bx6DaZxyWL4WygKvc7c",
  "transfer_events": {
    "counter": "0",
    "guid": {
      "id": {
        "addr": "EiCX3rtKrhcXZsbeey1dqD5jeDPodcvqaWxG7JDKePoP",
        "creation_num": "1125899906842624"
      }
    }
  }
}

npx ts-node index.ts transfer_nft mgr H9ZVsV1rME62Fr8yYGbb2DxekDFcUm9H2p3j2QFE8mTJ 8wTNScjbYY4Gz4CbRa3oYmjBGCbTRekWDHJr4sHTYahW
Environment variables loaded: { ENDLESS_NETWORK: 'testnet' }
✅ Asynchronous read succeeded: Read file contents from mgr.json.
✅ Deserialization successful: Parsed mgr.json contents into an object.
Transaction submitted, hash: 0x25bfd4f15107a8aa025c2e841440d2a94220ab7f72bba991c8330ec5ee166277

npx ts-node index.ts transfer_nft mgr AAsAGWsPCLyn3Gx5b6hPixYWc1vM67YogwDNgx3mXyon 8wTNScjbYY4Gz4CbRa3oYmjBGCbTRekWDHJr4sHTYahW 
Environment variables loaded: { ENDLESS_NETWORK: 'testnet' }
✅ Asynchronous read succeeded: Read file contents from mgr.json.
✅ Deserialization successful: Parsed mgr.json contents into an object.
Transaction submitted, hash: 0x0e02fb6a520251c5e3203cdc3a1b47c0c2d0f7343d1c2613fd7aa4eccf6f4e21

npx ts-node index.ts transfer_nft mgr EiCX3rtKrhcXZsbeey1dqD5jeDPodcvqaWxG7JDKePoP 8wTNScjbYY4Gz4CbRa3oYmjBGCbTRekWDHJr4sHTYahW
Environment variables loaded: { ENDLESS_NETWORK: 'testnet' }
✅ Asynchronous read succeeded: Read file contents from mgr.json.
✅ Deserialization successful: Parsed mgr.json contents into an object.
Transaction submitted, hash: 0x471d46bfcd424e1a3b9164614a80750fc66e0007a49dd805b3f95e893d2d7693

npx ts-node index.ts weapon_equip_gem alice AAsAGWsPCLyn3Gx5b6hPixYWc1vM67YogwDNgx3mXyon EiCX3rtKrhcXZsbeey1dqD5jeDPodcvqaWxG7JDKePoP
Environment variables loaded: { ENDLESS_NETWORK: 'testnet' }
✅ Asynchronous read succeeded: Read file contents from alice.json.
✅ Deserialization successful: Parsed alice.json contents into an object.
Transaction submitted, hash: 0x5d23295c1dc599e6cc7386c27b68218884ce2a296b17a37aac5974a6b6bc7851

#gem
#https://scan.endless.link/object/EiCX3rtKrhcXZsbeey1dqD5jeDPodcvqaWxG7JDKePoP/resources?network=testnet

Type:   0x1::object::ObjectCore
{
  "allow_ungated_transfer": true,
  "guid_creation_num": "1125899906842625",
  "owner": "AAsAGWsPCLyn3Gx5b6hPixYWc1vM67YogwDNgx3mXyon",
  "transfer_events": {
    "counter": "0",
    "guid": {
      "id": {
        "addr": "EiCX3rtKrhcXZsbeey1dqD5jeDPodcvqaWxG7JDKePoP",
        "creation_num": "1125899906842624"
      }
    }
  }
}

#weapon
#https://scan.endless.link/object/AAsAGWsPCLyn3Gx5b6hPixYWc1vM67YogwDNgx3mXyon/resources?network=testnet

Type:   FK3J64indQEVV42Qz1a1s38o4bx6DaZxyWL4WygKvc7c::hero::Weapon
{
  "attack": "2000",
  "gem": {
    "vec": [
      {
        "inner": "EiCX3rtKrhcXZsbeey1dqD5jeDPodcvqaWxG7JDKePoP"
      }
    ]
  },
  "weapon_type": "weaponType",
  "weight": "20"
}

>npx ts-node index.ts hero_equip_weapon alice H9ZVsV1rME62Fr8yYGbb2DxekDFcUm9H2p3j2QFE8mTJ  AAsAGWsPCLyn3Gx5b6hPixYWc1vM67YogwDNgx3mXyon  
Environment variables loaded: { ENDLESS_NETWORK: 'testnet' }
✅ Asynchronous read succeeded: Read file contents from alice.json.
✅ Deserialization successful: Parsed alice.json contents into an object.
Transaction submitted, hash: 0x31e87d5694f572f586545910e40f42e5520c2e3ee2fb9320ffbbe11bf27e29ea

#weapon
#https://scan.endless.link/object/AAsAGWsPCLyn3Gx5b6hPixYWc1vM67YogwDNgx3mXyon/resources?network=testnet

Type:   0x1::object::ObjectCore
{
  "allow_ungated_transfer": true,
  "guid_creation_num": "1125899906842625",
  "owner": "H9ZVsV1rME62Fr8yYGbb2DxekDFcUm9H2p3j2QFE8mTJ",
  "transfer_events": {
    "counter": "0",
    "guid": {
      "id": {
        "addr": "AAsAGWsPCLyn3Gx5b6hPixYWc1vM67YogwDNgx3mXyon",
        "creation_num": "1125899906842624"
      }
    }
  }
}

#hero
#https://scan.endless.link/object/H9ZVsV1rME62Fr8yYGbb2DxekDFcUm9H2p3j2QFE8mTJ/resources?network=testnet

Type:   FK3J64indQEVV42Qz1a1s38o4bx6DaZxyWL4WygKvc7c::hero::Hero
{
  "armor": {
    "vec": []
  },
  "gender": "heroGender",
  "mutator_ref": {
    "self": "H9ZVsV1rME62Fr8yYGbb2DxekDFcUm9H2p3j2QFE8mTJ"
  },
  "race": "heroRace",
  "shield": {
    "vec": []
  },
  "weapon": {
    "vec": [
      {
        "inner": "AAsAGWsPCLyn3Gx5b6hPixYWc1vM67YogwDNgx3mXyon"
      }
    ]
  }
}

npx ts-node index.ts hero_unequip_weapon alice H9ZVsV1rME62Fr8yYGbb2DxekDFcUm9H2p3j2QFE8mTJ  AAsAGWsPCLyn3Gx5b6hPixYWc1vM67YogwDNgx3mXyon
Environment variables loaded: { ENDLESS_NETWORK: 'testnet' }
✅ Asynchronous read succeeded: Read file contents from alice.json.
✅ Deserialization successful: Parsed alice.json contents into an object.
Transaction submitted, hash: 0x4d38fd8d473ea1795848a2cd21796fee180451adfc0f83a879d739b2f6bac4a7

#weapon
#https://scan.endless.link/object/AAsAGWsPCLyn3Gx5b6hPixYWc1vM67YogwDNgx3mXyon/resources?network=testnet

Type:   0x1::object::ObjectCore
{
  "allow_ungated_transfer": true,
  "guid_creation_num": "1125899906842625",
  "owner": "8wTNScjbYY4Gz4CbRa3oYmjBGCbTRekWDHJr4sHTYahW",
  "transfer_events": {
    "counter": "0",
    "guid": {
      "id": {
        "addr": "AAsAGWsPCLyn3Gx5b6hPixYWc1vM67YogwDNgx3mXyon",
        "creation_num": "1125899906842624"
      }
    }
  }
}

#hero
#https://scan.endless.link/object/H9ZVsV1rME62Fr8yYGbb2DxekDFcUm9H2p3j2QFE8mTJ/resources?network=testnet

Type:   FK3J64indQEVV42Qz1a1s38o4bx6DaZxyWL4WygKvc7c::hero::Hero
{
  "armor": {
    "vec": []
  },
  "gender": "heroGender",
  "mutator_ref": {
    "self": "H9ZVsV1rME62Fr8yYGbb2DxekDFcUm9H2p3j2QFE8mTJ"
  },
  "race": "heroRace",
  "shield": {
    "vec": []
  },
  "weapon": {
    "vec": []
  }
}

npx ts-node index.ts weapon_unequip_gem alice AAsAGWsPCLyn3Gx5b6hPixYWc1vM67YogwDNgx3mXyon EiCX3rtKrhcXZsbeey1dqD5jeDPodcvqaWxG7JDKePoP
Environment variables loaded: { ENDLESS_NETWORK: 'testnet' }
✅ Asynchronous read succeeded: Read file contents from alice.json.
✅ Deserialization successful: Parsed alice.json contents into an object.
Transaction submitted, hash: 0x17652893b2abcc00fac2fbec1aea831bb5469c518c857cf72dca2f42ba2cdf98

#gem
#https://scan.endless.link/object/EiCX3rtKrhcXZsbeey1dqD5jeDPodcvqaWxG7JDKePoP/resources?network=testnet

Type:   0x1::object::ObjectCore
{
  "allow_ungated_transfer": true,
  "guid_creation_num": "1125899906842625",
  "owner": "8wTNScjbYY4Gz4CbRa3oYmjBGCbTRekWDHJr4sHTYahW",
  "transfer_events": {
    "counter": "0",
    "guid": {
      "id": {
        "addr": "EiCX3rtKrhcXZsbeey1dqD5jeDPodcvqaWxG7JDKePoP",
        "creation_num": "1125899906842624"
      }
    }
  }
}

#weapon
#https://scan.endless.link/object/AAsAGWsPCLyn3Gx5b6hPixYWc1vM67YogwDNgx3mXyon/resources?network=testnet

Type:  FK3J64indQEVV42Qz1a1s38o4bx6DaZxyWL4WygKvc7c::hero::Weapon
{
  "attack": "2000",
  "gem": {
    "vec": []
  },
  "weapon_type": "weaponType",
  "weight": "20"
}