Merge branch 'master' into ui

Author: James Bartnik

apps/cli/src/commands/xai-token/change-whitelist-status.ts

@@ -0,0 +1,39 @@
+import * as Vorpal from "vorpal";
+import { changeWhitelistStatus as coreChangeWhitelistStatus, getSignerFromPrivateKey } from "@xai-vanguard-node/core";
+
+/**
+ * Function to change the whitelist status of a list of wallets in the esXai contract.
+ * @param cli - Vorpal instance
+ */
+export function changeWhitelistStatus(cli: Vorpal) {
+    cli
+        .command('change-whitelist-status', 'Changes the whitelist status of a list of wallets in the esXai contract.')
+        .action(async function (this: Vorpal.CommandInstance) {
+            const walletsPrompt: Vorpal.PromptObject = {
+                type: 'input',
+                name: 'wallets',
+                message: 'Enter the wallets (comma-separated):'
+            };
+            const statusPrompt: Vorpal.PromptObject = {
+                type: 'confirm',
+                name: 'status',
+                message: 'Enter the whitelist status for all wallets (true or false):'
+            };
+            const privateKeyPrompt: Vorpal.PromptObject = {
+                type: 'password',
+                name: 'privateKey',
+                message: 'Enter the private key of an admin:'
+            };
+            const {wallets} = await this.prompt(walletsPrompt);
+            const {status} = await this.prompt(statusPrompt);
+            const {privateKey} = await this.prompt(privateKeyPrompt);
+            const walletsArray = wallets.split(',').map((wallet: string) => wallet.trim());
+            const walletsStatuses = walletsArray.reduce((acc: {[key: string]: typeof status}, wallet: string) => ({...acc, [wallet]: status}), {});
+            this.log(`Changing whitelist status for wallets: ${wallets}...`);
+            const { signer } = getSignerFromPrivateKey(privateKey);
+            await coreChangeWhitelistStatus(signer, walletsStatuses, (wallet: string, isWhitelisted: boolean) => {
+                this.log(`Wallet: ${wallet}, Whitelisted: ${isWhitelisted}`);
+            });
+            this.log(`Whitelist statuses changed.`);
+        });
+}

apps/cli/src/commands/xai-token/check-whitelist.ts

@@ -0,0 +1,25 @@
+import * as Vorpal from "vorpal";
+import { checkWhitelist as coreCheckWhitelist } from "@xai-vanguard-node/core";
+
+/**
+ * Function to check the whitelist status of a list of wallets in the esXai contract.
+ * @param cli - Vorpal instance
+ */
+export function checkWhitelist(cli: Vorpal) {
+    cli
+        .command('check-whitelist', 'Checks the whitelist status of a list of wallets in the esXai contract. Wallets should be provided as a comma-separated list.')
+        .action(async function (this: Vorpal.CommandInstance) {
+            const walletsPrompt: Vorpal.PromptObject = {
+                type: 'input',
+                name: 'wallets',
+                message: 'Enter the wallets (comma-separated):'
+            };
+            const {wallets} = await this.prompt(walletsPrompt);
+            const walletsArray = wallets.split(',').map((wallet: string) => wallet.trim());
+            this.log(`Checking whitelist status for wallets: ${wallets}...`);
+            await coreCheckWhitelist(walletsArray, (wallet: string, isWhitelisted: boolean) => {
+                this.log(`Wallet: ${wallet}, Whitelisted: ${isWhitelisted}`);
+            });
+            this.log(`Whitelist statuses retrieved.`);
+        });
+}

apps/cli/src/commands/xai-token/list-whitelist-addresses.ts

@@ -0,0 +1,18 @@
+import * as Vorpal from "vorpal";
+import { listWhitelistAddresses as coreListWhitelistAddresses } from "@xai-vanguard-node/core";
+
+/**
+ * Function to list all whitelisted addresses in the esXai contract.
+ * @param cli - Vorpal instance
+ */
+export function listWhitelistAddresses(cli: Vorpal) {
+    cli
+        .command('list-whitelist-addresses', 'Lists all whitelisted addresses in the esXai contract.')
+        .action(async function (this: Vorpal.CommandInstance) {
+            this.log(`Fetching all whitelisted addresses...`);
+            const whitelistAddresses = await coreListWhitelistAddresses((address: string) => {
+                this.log(`Address: ${address}`);
+            });
+            this.log(`Whitelisted addresses retrieved.`);
+        });
+}

apps/cli/src/index.ts

@@ -29,6 +29,8 @@ import { setKycStatus } from './commands/kyc/set-kyc-status';
 import { totalSupply } from './commands/xai-token/total-supply';
 import { getBalancesForAddresses } from './commands/xai-token/get-balances';
 import { getAllContractAddresses } from './commands/get-contract-addresses';
+import { checkWhitelist } from './commands/xai-token/check-whitelist';
+import { changeWhitelistStatus } from './commands/xai-token/change-whitelist-status';
 
 const cli = new Vorpal();
 
@@ -63,6 +65,8 @@ setRollupAddress(cli);
 toggleAssertionChecking(cli);
 totalSupply(cli);
 getAllContractAddresses(cli);
+checkWhitelist(cli);
+changeWhitelistStatus(cli);
 
 cli
     .delimiter('vanguard-node$')

packages/core/src/abis/esXaiAbi.ts

@@ -353,6 +353,39 @@ export const esXaiAbi = [
       }
     ]
   },
+  {
+    "type": "function",
+    "name": "getWhitelistCount",
+    "constant": true,
+    "stateMutability": "view",
+    "payable": false,
+    "inputs": [],
+    "outputs": [
+      {
+        "type": "uint256",
+        "name": ""
+      }
+    ]
+  },
+  {
+    "type": "function",
+    "name": "getWhitelistedAddressAtIndex",
+    "constant": true,
+    "stateMutability": "view",
+    "payable": false,
+    "inputs": [
+      {
+        "type": "uint256",
+        "name": "index"
+      }
+    ],
+    "outputs": [
+      {
+        "type": "address",
+        "name": ""
+      }
+    ]
+  },
   {
     "type": "function",
     "name": "grantRole",

packages/core/src/config.ts

@@ -2,9 +2,9 @@ export const config = {
   "arbitrumBlockExplorer": "https://arbiscan.io",
   "arbitrumGoerliBlockExplorer": "https://goerli.arbiscan.io",
   "defaultRpcUrl": "https://goerli-rollup.arbitrum.io/rpc",
-  "esXaiAddress": "0x79Bf74A93D86dce235471751a7d359c65bF67862",
-  "nodeLicenseAddress": "0x465EEF81240A8620e645660678a9E0304C606c6f",
-  "refereeAddress": "0xB934633A8A082c1c9b6172eF2888b8A5fD10E556",
+  "esXaiAddress": "0x022D5be65285Df414Ea40AA41b1e85b63f5466F6",
+  "nodeLicenseAddress": "0x8e56484b39293fd74B43F11DB815eED9d1Ba0062",
+  "refereeAddress": "0xf927CD82CE6a488f78AA63f2a8dcdd96aE9FAb40",
   "rollupAddress": "0x082742561295f6e1b43c4f5d1e2d52d7FfE082f1",
-  "xaiAddress": "0xEF8BcCC86E4864ccEc6EBdA0f14279f2C5535B5d"
+  "xaiAddress": "0x4B5591e65307b09AeabDEE680AD7b6bb90D513f8"
 };

packages/core/src/xai-token/changeWhitelistStatus.ts

@@ -0,0 +1,41 @@
+import { ethers } from "ethers";
+import { esXaiAbi } from "../abis";
+import { config } from "../config";
+
+/**
+ * Changes the whitelist status of an object of wallets in the esXai contract.
+ *
+ * @param signer - The signer with DEFAULT_ADMIN_ROLE.
+ * @param walletsStatuses - Object with wallet addresses as keys and their whitelist status as values.
+ * @param callback - Optional callback function to handle wallets and their whitelist status as they are processed.
+ * @returns An array of objects, each containing a wallet address and its new whitelist status.
+ */
+export async function changeWhitelistStatus(
+    signer: ethers.Signer,
+    walletsStatuses: { [wallet: string]: boolean },
+    callback?: (wallet: string, isWhitelisted: boolean) => void
+): Promise<{wallet: string, isWhitelisted: boolean}[]> {
+
+    // Create a contract instance
+    const contract = new ethers.Contract(config.esXaiAddress, esXaiAbi, signer);
+
+    // Change the whitelist status of each wallet
+    const whitelistStatuses = [];
+    for (const wallet in walletsStatuses) {
+        const status = walletsStatuses[wallet];
+        const currentStatus = await contract.isWhitelisted(wallet);
+        if (status !== currentStatus) {
+            if (status) {
+                await contract.addToWhitelist(wallet);
+            } else {
+                await contract.removeFromWhitelist(wallet);
+            }
+            whitelistStatuses.push({wallet, isWhitelisted: status});
+            if (callback) {
+                callback(wallet, status);
+            }
+        }
+    }
+
+    return whitelistStatuses;
+}

packages/core/src/xai-token/checkWhitelist.ts

@@ -0,0 +1,35 @@
+import { ethers } from 'ethers';
+import { esXaiAbi } from '../abis';
+import { config } from '../config';
+import { getProvider } from '../utils/getProvider';
+
+/**
+ * Checks if the provided addresses are in the whitelist.
+ * @param addresses - The addresses to check.
+ * @param callback - Optional callback function to handle addresses and their whitelist status as they are retrieved.
+ * @returns An array of objects, each containing an address and its whitelist status.
+ */
+export async function checkWhitelist(
+    addresses: string[],
+    callback?: (address: string, isWhitelisted: boolean) => void
+): Promise<{address: string, isWhitelisted: boolean}[]> {
+
+    // Get the provider
+    const provider = getProvider();
+
+    // Create an instance of the esXai contract
+    const esXaiContract = new ethers.Contract(config.esXaiAddress, esXaiAbi, provider);
+
+    // Check the whitelist status of all addresses
+    const whitelistStatuses = [];
+    for (let i = 0; i < addresses.length; i++) {
+        const address = addresses[i];
+        const isWhitelisted = await esXaiContract.isWhitelisted(address);
+        whitelistStatuses.push({address, isWhitelisted});
+        if (callback) {
+            callback(address, isWhitelisted);
+        }
+    }
+
+    return whitelistStatuses;
+}

packages/core/src/xai-token/index.ts

@@ -1,2 +1,5 @@
 export * from "./totalSupply";
-export * from "./balance";
+export * from "./balance";
+export * from "./checkWhitelist";
+export * from "./changeWhitelistStatus";
+export * from "./listWhitelistAddresses";

packages/core/src/xai-token/listWhitelistAddresses.ts

@@ -0,0 +1,36 @@
+import { ethers } from "ethers";
+import { getProvider } from "../utils/getProvider";
+import { config } from "../config";
+import { esXaiAbi } from "../abis";
+
+/**
+ * Lists all whitelisted addresses in the esXai contract.
+ *
+ * @param callback - Optional callback function to handle whitelisted addresses as they are retrieved.
+ * @returns An array of whitelisted addresses.
+ */
+export async function listWhitelistAddresses(
+    callback?: (address: string) => void
+): Promise<string[]> {
+
+    // Get the provider
+    const provider = getProvider();
+
+    // Create a contract instance
+    const contract = new ethers.Contract(config.esXaiAddress, esXaiAbi, provider);
+
+    // Get the number of whitelisted addresses
+    const whitelistCount = await contract.getWhitelistCount();
+
+    // Get all whitelisted addresses
+    const whitelistAddresses = [];
+    for (let i = 0; i < whitelistCount; i++) {
+        const address = await contract.getWhitelistedAddressAtIndex(i);
+        whitelistAddresses.push(address);
+        if (callback) {
+            callback(address);
+        }
+    }
+
+    return whitelistAddresses;
+}