env setup script

deploy/env.example

@@ -11,7 +11,9 @@ DEMO_ACCOUNT_ONE_MNEMONIC="//Dave"
 DEMO_ACCOUNT_TWO_MNEMONIC="//Eve"
 DEMO_ACCOUNT_THREE_MNEMONIC="//Ferdie"
 
+# Connection to the blockchain
 WS_PROVIDER_URL="ws://127.0.0.1:52279"
+DATAGATE_URL="http://127.0.0.1:18890"
 
 # Amount to transfer to app agents
-TRANSFER_AMOUNT=10
+TRANSFER_AMOUNT=1000

deploy/index.js

@@ -4,9 +4,11 @@ const dotenv = require("dotenv");
 const fs = require('fs');
 const path = require('path');
 const { create_app_agent } = require('./utils/app_agent');
-const { create_app_agent_fungible_token } = require('./utils/fungible');
-const { create_app_agent_nft_collection } = require('./utils/nft');
-const { create_app_agent_nft_token } = require('./utils/nft');
+const { create_fungible_tokens, set_metadata_and_mint_fungible_token, create_token_transfer } = require('./utils/fungible');
+const { create_nft_collections, set_metadata_and_mint_nft, create_nft_transfers } = require('./utils/nft');
+const { processSignedTransaction, processSignedBatchTransaction } = require('./utils/utils');
+
+const startTime = Date.now();
 
 const aws_s3_assets_path = path.join(__dirname, '..', 'aws_s3_assets');
 const game_a_path = path.join(aws_s3_assets_path, 'game-a/');
@@ -18,16 +20,16 @@ const game_folders = [game_a_path, game_b_path, game_c_path];
 dotenv.config();
 
 async function main() {
-    // Read WS_PROVIDER_URL from .env file
+    console.log("Read WS_PROVIDER_URL from .env file");
     const wsProviderUrl = process.env.WS_PROVIDER_URL;
     if (!wsProviderUrl) {
         throw new Error("WS_PROVIDER_URL is not set in the .env file");
     }
 
-    // Create a provider with the URL from .env
+    console.log("Create a provider with the URL from .env");
     const provider = new WsProvider(wsProviderUrl);
 
-    // Instantiate the API with the provider
+    console.log("Instantiate the API with the provider");
     const api = await ApiPromise.create({
         provider,
         types: {
@@ -44,148 +46,184 @@ async function main() {
         }
     });
 
-    // Construct the keyring
+    console.log("Construct the keyring");
     const keyring = new Keyring({ type: "sr25519" });
 
-    // Load accounts from .env file
+    console.log("Load accounts from .env file");
     const faucetAccount = keyring.addFromUri(process.env.FAUCET_ACCOUNT_MNEMONIC);
-    const appAgentOne = keyring.addFromUri(process.env.APP_AGENT_OWNER_ONE_MNEMONIC);
-    const appAgentTwo = keyring.addFromUri(process.env.APP_AGENT_OWNER_TWO_MNEMONIC);
-    const appAgentThree = keyring.addFromUri(process.env.APP_AGENT_OWNER_THREE_MNEMONIC);
-    const appAgentOwners = [appAgentOne, appAgentTwo, appAgentThree];
+    const appAgentOneOwner = keyring.addFromUri(process.env.APP_AGENT_OWNER_ONE_MNEMONIC);
+    const appAgentTwoOwner = keyring.addFromUri(process.env.APP_AGENT_OWNER_TWO_MNEMONIC);
+    const appAgentThreeOwner = keyring.addFromUri(process.env.APP_AGENT_OWNER_THREE_MNEMONIC);
+    const appAgentOwners = [appAgentOneOwner, appAgentTwoOwner, appAgentThreeOwner];
 
     const demo_user_one = keyring.addFromUri(process.env.DEMO_ACCOUNT_ONE_MNEMONIC);
     const demo_user_two = keyring.addFromUri(process.env.DEMO_ACCOUNT_TWO_MNEMONIC);
     const demo_user_three = keyring.addFromUri(process.env.DEMO_ACCOUNT_THREE_MNEMONIC);
 
     const transferAmount = parseInt(process.env.TRANSFER_AMOUNT) * 1e12;
+    const demotransferAmount = parseInt(process.env.TRANSFER_AMOUNT) * 1e10;
+
+    console.log("Start to initialise the owners of the app agents");
+    // const transfers = [
+    //     api.tx.balances.transferKeepAlive(appAgentOneOwner.address, transferAmount.toString()),
+    //     api.tx.balances.transferKeepAlive(appAgentTwoOwner.address, transferAmount.toString()),
+    //     api.tx.balances.transferKeepAlive(appAgentThreeOwner.address, transferAmount.toString()),
+    //     api.tx.balances.transferKeepAlive(demo_user_one.address, demotransferAmount.toString()),
+    //     api.tx.balances.transferKeepAlive(demo_user_two.address, demotransferAmount.toString()),
+    //     api.tx.balances.transferKeepAlive(demo_user_three.address, demotransferAmount.toString()),
+    // ];
+
+    // console.log("Send the batch of transfers");
+    // await processSignedBatchTransaction(api, faucetAccount, api.tx.utility.batchAll(transfers));
+    // await create_balance_transfers(api, demo_user_one, demo_user_two);
+    // await create_balance_transfers(api, demo_user_three, demo_user_one);
+
+    console.log("Traverse the game folders and collect entity data");
+    const gameData = collectGameData(game_folders);
+
+    // array of fungible ids
+    let fungibles = [];
+
+    // array of { collectionId: collectionId, tokenId: tokenId}
+    let collections = [];
+
+    console.log("Starting to process game data");
+    for (const [gameIndex, game] of gameData.entries()) {
+        console.log(`Processing game ${gameIndex + 1}`);
+        const appAgentOwner = appAgentOwners[gameIndex];
+
+        // Create app agent and set metadata
+        console.log(`Creating app agent for game ${gameIndex + 1}`);
+        const appAgentId = await create_app_agent(api, appAgentOwner, game.appAgent.metadataUrl);
+        console.log(`App agent created for game ${gameIndex + 1}: ${appAgentId}`);
+
+        // Create and configure fungible tokens
+        if (game.fungibles.length > 0) {
+            console.log(`Creating fungible tokens for game ${gameIndex + 1}`);
+            const fungibleIds = await create_fungible_tokens(api, appAgentOwner, appAgentId, game.fungibles.length);
+            fungibles = [...fungibles, ...fungibleIds];
+            console.log(`Setting metadata and minting fungible tokens for game ${gameIndex + 1}`);
+            await set_metadata_and_mint_fungible_token(api, appAgentOwner, appAgentId, fungibleIds, game.fungibles.map(f => f.metadataUrl), demo_user_one, game.fungibles.map(f => f.decimals));
+            console.log(`Fungible tokens created and configured for game ${gameIndex + 1}`);
+        }
 
-    // Create a batch of transfers
-    const transfers = [
-        api.tx.balances.transferKeepAlive(appAgentOne.address, transferAmount.toString()),
-        api.tx.balances.transferKeepAlive(appAgentTwo.address, transferAmount.toString()),
-        api.tx.balances.transferKeepAlive(appAgentThree.address, transferAmount.toString())
-    ];
-
-    // Send the batch of transfers
-    await new Promise((resolve, reject) => {
-        api.tx.utility
-            .batchAll(transfers)
-            .signAndSend(faucetAccount, ({ status, events }) => {
-                if (status.isInBlock || status.isFinalized) {
-                    events.forEach(({ event }) => {
-                        if (api.events.balances.Transfer.is(event)) {
-                            const [from, to, amount] = event.data;
-                            console.log(`Transferred ${amount.toNumber() / 1e12} tokens from ${from.toString()} to ${to.toString()}`);
-                        }
-                    });
-                    console.log("Initial transfers completed successfully");
-                    resolve();
-                }
-            })
-            .catch(reject);
-    });
-
-    // traverse the game folders and create app-agents and assets for each game
-    for (const [index, folder] of game_folders.entries()) {
-        console.log("folder:", folder);
-        let appagentId = null;
-        let appAgentOwner = appAgentOwners[index];
-
-        // Search for folders starting with app-agent- and print all files
-        const subFolders = fs.readdirSync(folder);
-
-        for (const subFolder of subFolders) {
-            console.log("subFolder:", subFolder);
-            if (subFolder.startsWith('app-agent-')) {
-                const folderPath = path.join(folder, subFolder);
-                console.log("folderPath:", folderPath);
+        // Create and configure NFT collections and tokens
+        console.log(`Creating NFT collections for game ${gameIndex + 1}`);
+        const collectionIds = await create_nft_collections(api, appAgentOwner, appAgentId, game.nftCollections.length);
+        console.log(`NFT collections created for game ${gameIndex + 1}:`, collectionIds);
+        for (let i = 0; i < game.nftCollections.length; i++) {
+            console.log(`Setting metadata and minting NFTs for collection ${collectionIds[i]} of game ${gameIndex + 1}`);
+            let nftInfo = await set_metadata_and_mint_nft(api, appAgentOwner, appAgentId, collectionIds[i], game.nftCollections[i], demo_user_one.address);
+            collections = [...collections, ...nftInfo];
+        }
+        console.log(`NFT collections created and configured for game ${gameIndex + 1}`);
+    }
 
-                let metadataUrl = readFilesInDirectory(folderPath);
-                console.log("metadataUrl:", metadataUrl);
+    console.log("All games processed. Fungibles:", fungibles);
+    console.log("Collections:", collections);
 
-                if (metadataUrl) {
-                    appagentId = await create_app_agent(api, appAgentOwner, metadataUrl);
-                    await new Promise(resolve => setTimeout(resolve, 10_000)); // wait for the previous tx to propogate
-                }
-            }
+    console.log("Create demo transfers for fungibles");
+    for (const fungible of fungibles) {
+        await create_token_transfer(api, fungible, demo_user_one, [demo_user_two, demo_user_three], 10);
+        await create_token_transfer(api, fungible, demo_user_two, [demo_user_one, demo_user_three], 5);
+    }
 
-            else if (subFolder.startsWith('fungible-')) {
-                console.log("fungible-token folder detected");
-                const folderPath = path.join(folder, subFolder);
-                console.log("folderPath:", folderPath);
+    console.log("Create demo transfers for NFTs");
+    for (const collection of collections) {
+        const recipient = Math.random() < 0.5 ? demo_user_three : demo_user_two;
+        await create_nft_transfers(api, collection.collectionId, collection.tokenId, demo_user_one, recipient);
+    }
+}
 
-                let metadataUrl = readFilesInDirectory(folderPath);
-                console.log("metadataUrl:", metadataUrl);
-                create_app_agent_fungible_token(api, appAgentOwner, appagentId, demo_user_one, demo_user_two, metadataUrl);
+function collectGameData(gameFolders) {
+    return gameFolders.map(gameFolder => {
+        const gameData = {
+            appAgent: null,
+            // array of { metadataUrl: metadataUrl, decimals: decimals }
+            fungibles: [],
+            // array of { metadataUrl: metadataUrl, tokens: [{ metadataUrl: metadataUrl}]}
+            nftCollections: []
+        };
 
-                await new Promise(resolve => setTimeout(resolve, 10_000)); // wait for the previous tx to propogate
-            }
+        const subFolders = fs.readdirSync(gameFolder);
 
-            if (subFolder.startsWith('nft-collection')) {
-                console.log("nft-collection folder detected");
-                const folderPath = path.join(folder, subFolder);
-                console.log("folderPath:", folderPath);
+        for (const subFolder of subFolders) {
+            const folderPath = path.join(gameFolder, subFolder);
 
+            if (subFolder.startsWith('app-agent-')) {
+                gameData.appAgent = { metadataUrl: getObjectMetadataURL(folderPath).url };
+            } else if (subFolder.startsWith('fungible-')) {
+                gameData.fungibles.push({ metadataUrl: getObjectMetadataURL(folderPath).url, decimals: getObjectMetadataURL(folderPath).decimals });
+            } else if (subFolder.startsWith('nft-collection')) {
+                const collection = { metadataUrl: null, tokens: [] };
                 const subsubFolders = fs.readdirSync(folderPath);
 
-                let collection_id = null;
-
                 for (const subsubFolder of subsubFolders) {
+                    const subFolderPath = path.join(folderPath, subsubFolder);
                     if (subsubFolder.startsWith('nft-collection')) {
-                        const nftCollectionPath = path.join(folderPath, subsubFolder);
-                        console.log("nftCollectionPath:", nftCollectionPath);
-                        let metadataUrl = readFilesInDirectory(nftCollectionPath);
-                        console.log("metadataUrl:", metadataUrl);
-
-                        collection_id = await create_app_agent_nft_collection(api, appAgentOwner, appagentId, metadataUrl);
-                    }
-
-                    else if (subsubFolder.startsWith('nft-token')) {
-                        const nftItemPath = path.join(folderPath, subsubFolder);
-                        console.log("nftItemPath:", nftItemPath);
-                        let metadataUrl = readFilesInDirectory(nftItemPath);
-                        console.log("metadataUrl:", metadataUrl);
-
-                        await create_app_agent_nft_token(api, appAgentOwner, appagentId, collection_id, metadataUrl, demo_user_one, demo_user_three);
+                        collection.metadataUrl = getObjectMetadataURL(subFolderPath).url;
+                    } else if (subsubFolder.startsWith('nft-token')) {
+                        collection.tokens.push({ metadataUrl: getObjectMetadataURL(subFolderPath).url });
                     }
                 }
 
-
-            }
-
-            else {
-                console.log("unknown folder detected, ignoring...");
+                gameData.nftCollections.push(collection);
             }
         }
-    }
+
+        return gameData;
+    });
 }
 
-// Function to read all files in a directory
-function readFilesInDirectory(directory) {
+/**
+ * Function searches for the json file with object metadata.
+ * And calculates the metadata URL based on the file path.
+ *
+ * @param {string} directory - The directory where the metadata file is stored.
+ * @return {string|null} The metadata URL if found, otherwise null.
+ */
+function getObjectMetadataURL(directory) {
     const files = fs.readdirSync(directory);
     const jsonFiles = files.filter(file => file.endsWith('.json'));
 
     for (const file of jsonFiles) {
         const filePath = path.join(directory, file);
         const stats = fs.statSync(filePath);
         if (stats.isFile()) {
-            console.log(`File: ${filePath}`);
+            const fileContent = fs.readFileSync(filePath, 'utf8');
+            const jsonData = JSON.parse(fileContent);
+            // get the decimals from the fungible metadata if it exists
+            let decimals = jsonData.traits.fungible ? jsonData.traits.fungible.decimals : null;
 
-            // Generate the URL based on the folder structure
             const relativePath = path.relative(aws_s3_assets_path, filePath);
             const url = `https://trait-wallet-demo-account.trait.tech/${relativePath.replace(/\\/g, '/')}`;
 
-            console.log(`Generated URL: ${url}`);
-
-            // Return the URL instead of reading the file content
-            return url;
+            // console.log(`Generated URL: ${url}`);
+            return { url, decimals };
         }
     }
 
     return null;
 }
 
+async function create_balance_transfers(api, token_recipient, token_recipient_two) {
+    console.log("Generate free transfers between the two users");
+
+    for (let i = 0; i < 2; i++) {
+        let tx = api.tx.playerTransfers.submitTransferBalances(
+            token_recipient_two.address,
+            1000000
+        );
+        await processSignedTransaction(token_recipient, tx);
+    }
+    console.log(`Free transfer created and confirmed`);
+}
+
 main()
     .catch(console.error)
-    .finally(() => process.exit());
+    .finally(() => {
+        const endTime = Date.now();
+        const executionTime = (endTime - startTime) / 1000; // Convert to seconds
+        console.log(`Total execution time: ${executionTime.toFixed(2)} seconds`);
+        process.exit();
+    });