buy and list node licenses

Author: Christopher Powroznik

apps/cli/src/commands/get-node-license-address.ts

@@ -0,0 +1,15 @@
+import * as Vorpal from "vorpal";
+import { config } from "@xai-vanguard-node/core";
+
+/**
+ * Function to get the node license contract address from the config and log it in the console.
+ * @param {Vorpal} cli - The Vorpal instance to attach the command to.
+ */
+export function getNodeLicenseContractAddress(cli: Vorpal) {
+    cli
+        .command('get-node-license-contract-address', 'Fetches the node license contract address.')
+        .action(async function (this: Vorpal.CommandInstance) {
+            const nodeLicenseContractAddress = config.nodeLicenseAddress;
+            this.log(`Node License Contract Address: ${nodeLicenseContractAddress}`);
+        });
+}

apps/cli/src/commands/list-node-licenses.ts

@@ -0,0 +1,23 @@
+import * as Vorpal from "vorpal";
+import { listNodeLicenses as listNodeLicensesCore } from "@xai-vanguard-node/core";
+
+/**
+ * Function to list all NodeLicense token IDs owned by a particular address.
+ * @param cli - Vorpal instance
+ */
+export function listNodeLicenses(cli: Vorpal) {
+    cli
+        .command('list-node-licenses', 'Lists all NodeLicense token IDs owned by a particular address.')
+        .action(async function (this: Vorpal.CommandInstance) {
+            const {address} = await this.prompt({
+                type: 'input',
+                name: 'address',
+                message: 'Please enter the address to list NodeLicense token IDs for:'
+            });
+            this.log(`Fetching all NodeLicense token IDs for address ${address}...`);
+            await listNodeLicensesCore(address, (tokenId: bigint) => {
+                this.log(`Token ID: ${tokenId}`);
+            });
+            this.log(`NodeLicense token IDs retrieved.`);
+        });
+}

apps/cli/src/commands/mint-node-licenses.ts

@@ -0,0 +1,52 @@
+import * as Vorpal from "vorpal";
+import { ethers } from "ethers";
+import { getSignerFromPrivateKey, mintNodeLicenses as coreMintNodeLicenses } from "@xai-vanguard-node/core";
+
+export function mintNodeLicenses(cli: Vorpal) {
+    cli
+        .command('mint-node-licenses', 'Mints NodeLicense tokens if the signer has enough balance and the amount is less than the maximum mint amount.')
+        .action(async function (this: Vorpal.CommandInstance) {
+            const amountPrompt: Vorpal.PromptObject = {
+                type: 'input',
+                name: 'amount',
+                message: 'Enter the amount of tokens to mint:',
+            };
+            const { amount } = await this.prompt(amountPrompt);
+
+            const privateKeyPrompt: Vorpal.PromptObject = {
+                type: 'password',
+                name: 'privateKey',
+                message: 'Enter the private key of the wallet:',
+                mask: '*'
+            };
+            const { privateKey } = await this.prompt(privateKeyPrompt);
+
+            this.log(`Minting ${amount} NodeLicense tokens...`);
+
+            // get a signer of the private key
+            const {signer} = getSignerFromPrivateKey(privateKey);
+
+            try {
+                const { mintedNftIds, txReceipt, pricePaid } = await coreMintNodeLicenses(
+                    Number(amount),
+                    signer,
+                );
+
+                this.log(`Tokens successfully minted. Here are the details:`);
+                mintedNftIds.forEach((id, index) => {
+                    this.log(`Minted ID: ${id}`);
+                });
+                
+                
+
+                // Convert pricePaid from wei to eth using ethers utils
+                const pricePaidInEth = ethers.formatEther(pricePaid);
+                this.log(`Price Paid for Minting (in ETH): ${pricePaidInEth}`);
+                
+
+            } catch (error) {
+                this.log(`Error minting tokens: ${(error as Error).message}`);
+            }
+        });
+}
+

apps/cli/src/commands/toggle-assertion-checking.ts

@@ -1,11 +1,11 @@
 import * as Vorpal from "vorpal";
-import { getSignerFromPrivateKey, toggleAssertionChecking } from "@xai-vanguard-node/core";
+import { getSignerFromPrivateKey, toggleAssertionChecking as coreToggleAssertionChecking } from "@xai-vanguard-node/core";
 
 /**
  * Function to toggle the assertion checking in the Referee contract.
  * @param {Vorpal} cli - The Vorpal instance to attach the command to.
  */
-export function toggleAssertionCheckingCommand(cli: Vorpal) {
+export function toggleAssertionChecking(cli: Vorpal) {
     cli
         .command('toggle-assertion-checking', 'Toggles the assertion checking.')
         .action(async function (this: Vorpal.CommandInstance) {
@@ -20,7 +20,7 @@ export function toggleAssertionCheckingCommand(cli: Vorpal) {
             const { signer } = getSignerFromPrivateKey(privateKey);
 
             // Call the toggleAssertionChecking function
-            await toggleAssertionChecking(signer);
+            await coreToggleAssertionChecking(signer);
 
             this.log(`Assertion checking toggled.`);
         });

apps/cli/src/index.ts

@@ -14,10 +14,13 @@ import { manuallyChallengeAssertion } from './commands/manually-challenge-assert
 import { removeAdmin } from './commands/access-control/remove-admin';
 import { removeChallenger } from './commands/access-control/remove-challenger';
 import { setChallengerPublicKey } from './commands/set-challenger-public-key';
-import { toggleAssertionCheckingCommand } from './commands/toggle-assertion-checking';
+import { toggleAssertionChecking } from './commands/toggle-assertion-checking';
 import { addOperator } from './commands/operator-control/add-operator';
 import { removeOperator } from './commands/operator-control/remove-operator';
 import { listOperators } from './commands/operator-control/list-operators';
+import { mintNodeLicenses } from "./commands/mint-node-licenses";
+import { getNodeLicenseContractAddress } from './commands/get-node-license-address';
+import { listNodeLicenses } from './commands/list-node-licenses';
 
 const cli = new Vorpal();
 
@@ -40,7 +43,10 @@ removeAdmin(cli);
 removeChallenger(cli);
 removeOperator(cli);
 setChallengerPublicKey(cli);
-toggleAssertionCheckingCommand(cli);
+toggleAssertionChecking(cli);
+mintNodeLicenses(cli);
+getNodeLicenseContractAddress(cli);
+listNodeLicenses(cli);
 
 cli
     .delimiter('vanguard-node$')

package.json

@@ -14,7 +14,7 @@
   "author": "",
   "license": "UNLICENSED",
   "dependencies": {
-    "@openzeppelin/contracts": "^4.9.3"
+    "ethers": "^6.7.1"
   },
   "devDependencies": {
     "@typescript-eslint/eslint-plugin": "^6.6.0",

packages/core/package.json

@@ -13,10 +13,10 @@
   "author": "",
   "license": "UNLICENSED",
   "dependencies": {
-    "@noble/curves": "^1.2.0",
-    "ethers": "^6.7.1"
+    "@noble/curves": "^1.2.0"
   },
   "devDependencies": {
     "@types/node": "^20.6.0"
   }
 }
+

packages/core/src/node-license/index.ts

@@ -1 +1,2 @@
-export * from "./mintNodeLicenses";
+export * from "./mintNodeLicenses";
+export * from "./listNodeLicenses";

packages/core/src/node-license/listNodeLicenses.ts

@@ -0,0 +1,39 @@
+import { ethers } from 'ethers';
+import { NodeLicenseAbi } from '../abis';
+import { config } from '../config';
+import { getProvider } from '../utils/getProvider';
+
+/**
+ * Fetches all NodeLicense token IDs owned by a given address.
+ * @param ownerAddress - The address of the owner.
+ * @param callback - Optional callback function to handle token IDs as they are retrieved.
+ * @returns An array of token IDs.
+ */
+export async function listNodeLicenses(
+    ownerAddress: string,
+    callback?: (tokenId: bigint) => void
+): Promise<bigint[]> {
+
+    // Get the provider
+    const provider = getProvider();
+
+    // Create an instance of the NodeLicense contract
+    const nodeLicenseContract = new ethers.Contract(config.nodeLicenseAddress, NodeLicenseAbi, provider);
+
+    // Get the balance of the owner's address
+    const balance = await nodeLicenseContract.balanceOf(ownerAddress);
+
+    // Initialize an array to store the token IDs
+    const tokenIds: bigint[] = [];
+
+    // Loop through the balance and fetch each token ID
+    for (let i = 0; i < balance; i++) {
+        const tokenId = await nodeLicenseContract.tokenOfOwnerByIndex(ownerAddress, i);
+        tokenIds.push(tokenId);
+        if (callback) {
+            callback(tokenId);
+        }
+    }
+
+    return tokenIds;
+}

packages/core/src/node-license/mintNodeLicenses.ts

@@ -6,12 +6,12 @@ import { config } from '../config';
  * Mints NodeLicense tokens if the signer has enough balance and the amount is less than the maximum mint amount.
  * @param amount - The amount of tokens to mint.
  * @param signer - The signer to interact with the contract.
- * @returns An array of minted NFT IDs and the transaction receipt.
+ * @returns An object containing an array of minted NFT IDs, the transaction receipt, and the price paid.
  */
 export async function mintNodeLicenses(
     amount: number,
     signer: ethers.Signer
-): Promise<{ mintedNftIds: number[], txReceipt: ethers.TransactionReceipt }> {
+): Promise<{ mintedNftIds: bigint[], txReceipt: ethers.TransactionReceipt, pricePaid: bigint }> {
 
     // Create an instance of the NodeLicense contract
     const nodeLicenseContract = new ethers.Contract(config.nodeLicenseAddress, NodeLicenseAbi, signer);
@@ -47,19 +47,30 @@ export async function mintNodeLicenses(
     }
 
     // Mint the tokens, passing the price as the msg.value
-    const mintTx = await nodeLicenseContract.mint({ value: price }, amount);
-
+    const mintTx = await nodeLicenseContract.mint(amount, { value: price },);
     // Wait for the transaction to be mined and get the receipt
     const txReceipt = await mintTx.wait();
 
-    // Get the minted NFT IDs from the "Transfer" events in the transaction receipt
-    const mintedNftIds = txReceipt.events
-        ?.map((event: ethers.Log) => nodeLicenseContract.interface.parseLog({
-            ...event,
+    // Get the "Transfer" events from the transaction receipt logs
+    const transferEvents = txReceipt.logs.filter((log: ethers.Log) => log.topics[0] === ethers.id("Transfer(address,address,uint256)"));
+
+    // Extract the mintedNftIds from the transfer events
+    const mintedNftIds = transferEvents.map((event: ethers.EventLog) => {
+        // Parse the event log using the contract interface
+        const parsedLog = nodeLicenseContract.interface.parseLog({
             topics: [...event.topics],
-        }))
-        .filter((event: ethers.LogDescription) => event.name === 'Transfer')
-        .map((event: ethers.LogDescription) => event.args?.tokenId.toNumber()) ?? [];
+            data: event.data
+        });
+
+        // Check if parsedLog is not null before accessing args
+        if (parsedLog) {
+            // Return the tokenId from the parsed log
+            return parsedLog.args.tokenId;
+        }
+
+        // Return a default value or throw an error if parsedLog is null
+        throw new Error('Failed to parse log. Please double check your transaction when through on chain.');
+    });
 
-    return { mintedNftIds, txReceipt };
+    return { mintedNftIds, txReceipt, pricePaid: price };
 }