Work in progress, case sensitivity is going to be tricky

package.json

@@ -10,14 +10,17 @@
     "better-sqlite3": "^7.6.2",
     "csv-parser": "^3.0.0",
     "csv-writer": "^1.6.0",
+    "discord.js": "^14.9.0",
+    "node-fetch": "^2.6.9",
     "sourcecred": "^0.11.2"
   },
   "scripts": {
     "clean": "rimraf cache site",
     "clean-all": "yarn clean && rimraf output",
     "load": "dotenv sourcecred load",
     "start": "dotenv -- sourcecred go --no-load && sourcecred serve",
-    "grain": "sourcecred grain"
+    "grain": "sourcecred grain",
+    "update-ledger-from-chain": "dotenv node scripts/update-ledger-from-chain.js"
   },
   "devDependencies": {
     "dotenv-cli": "^6.0.0",

scripts/config.js

@@ -0,0 +1,7 @@
+module.exports = {
+    discordGuildId: "690584551239581708",
+    repo: "nation3/sourcecred-instance", 
+    branch: "automated-ledger-update", 
+    chainId: "1", 
+    tokenAddress: "0x333A4823466879eeF910A04D473505da62142069"
+}

scripts/discord-utils.js

@@ -0,0 +1,134 @@
+const { Client, GatewayIntentBits } = require('discord.js');
+const sc = require('sourcecred').sourcecred;
+const scUtils = require('./sourcecred-utils');
+
+module.exports = {
+    getDiscordMembers: async (guildId) => {
+        const token = process.env.SOURCECRED_DISCORD_TOKEN;
+        const client = new Client({ 
+            intents: [GatewayIntentBits.Guilds, GatewayIntentBits.GuildMembers] 
+        });
+
+        client.once('ready', () => {
+            console.log('Discord Bot is Go!');
+        });
+
+        await client.login(token);
+
+        const discordMembers = new Map();
+
+        const guild = client.guilds.resolve(guildId);
+
+        const rawMembers = await guild.members.fetch();
+
+        rawMembers.forEach((member) => {
+            discordMembers.set(`${member.user.username}#${member.user.discriminator}`, member.id);
+        });
+
+        client.destroy();
+
+        return discordMembers;        
+    },
+
+    testAndUpdateDiscordAccount: async (ledgerManager, lowerAccountToIdentityMap, discordMemberMap, passportData, chainId, tokenAddress) => {
+        const {passport_id, owner_address, discord_username,discord_username_ens} = passportData;
+
+        console.info(`Reading Discord data for: ${passport_id}`);
+
+        if ((!discord_username) && (!discord_username_ens)) {
+            console.info(`No Discord username for passport ${passport_id}`)
+            return;
+        }
+
+        //get just the username from one of the two columns
+        let discordUsernameAndDiscriminator = cleanDiscordUsername(discord_username);
+        if (!discordUsernameAndDiscriminator) {
+            discordUsernameAndDiscriminator = cleanDiscordUsername(discord_username_ens);
+        }
+
+        if (!discordUsernameAndDiscriminator) {
+            console.info(`Invalid Discord username ${discord_username}/${discord_username_ens} provided, skipping Discord for passport ${passport_id}`)
+            return;
+        }
+
+        //Discord idenitity is stored using the ID of the account, which we do not have, so have to have a Bot which can find it
+        //N\u0000sourcecred\u0000discord\u0000MEMBER\u0000user\u0000976148126308122644\u0000
+
+        const discordUserId = discordMemberMap.get(`${discordUsernameAndDiscriminator[0]}#${discordUsernameAndDiscriminator[1]}`);
+
+        if(!discordUserId) {
+            console.log(`No Discord Member found in Nation3 Discord with Username ${discordUsernameAndDiscriminator[0]}#${discordUsernameAndDiscriminator[1]} not setting Discord Identity for ${passport_id}`);
+            return;
+        }
+
+        const dAddress = scUtils.createDiscordIdentity(discordUsernameAndDiscriminator, discordUserId);
+
+        const hasAccount = lowerAccountToIdentityMap.has(dAddress.toLowerCase());
+        if(hasAccount) {
+            scUtils.testAndUpdateAccountPayoutAddress(
+                ledgerManager, 
+                lowerAccountToIdentityMap, 
+                dAddress, 
+                'discord', 
+                discordUsernameAndDiscriminator, 
+                passport_id, 
+                owner_address,
+                chainId,
+                tokenAddress);              
+        }
+        else {
+            addDiscordIdentityAndSetPayoutAddress(
+                ledgerManager, 
+                dAddress, 
+                discordUsernameAndDiscriminator, 
+                passport_id, 
+                owner_address, 
+                chainId,
+                tokenAddress);
+        }
+    }
+}
+
+function addDiscordIdentityAndSetPayoutAddress(ledgerManager, scAddress, dUsername, passport_id, owner_address, chainId, tokenAddress) {
+    console.log(`Creating a new SourceCred identity for ${dUsername} for passport ${passport_id}`)
+
+    const baseIdentityProposal = scUtils.createDiscordIdentityProposal(scAddress, dUsername);
+
+    const baseIdentityId = sc.ledger.utils.ensureIdentityExists(
+        ledgerManager.ledger,
+        baseIdentityProposal,
+    );
+
+    console.log(`Base Identity ID ${JSON.stringify(baseIdentityId)}`);
+
+    console.log(`Setting payout address for Discord for passport ${passport_id} - discordUsername ${dUsername}`)
+
+    ledgerManager.ledger.setPayoutAddress(baseIdentityId, owner_address , chainId, tokenAddress);
+
+    console.log(`Updated payout address to ${owner_address} for passport ${passport_id} - discordUsername ${dUsername}`)
+}
+
+function cleanDiscordUsername(dUsername) {
+    //https://discord.gg/grbsArn
+    //Adelaide Isla#3410
+    let processing = dUsername;
+
+    if(!processing || processing.indexOf('#') < 0) {
+        return null;
+    }
+
+    if(dUsername.indexOf('/') >= 0) {
+        const regex = /.*\/(.*)/gm;
+        processing = processing.replace(regex, '$1');
+    }
+
+    if(processing.startsWith('@')) {
+        processing = processing.substring(0);
+    }
+
+    const hash = processing.lastIndexOf('#');
+    const username = processing.substring(0, hash);
+    const discriminator = processing.substring(hash + 1);
+
+    return [username, discriminator];
+}

scripts/discourse-utils.js

@@ -0,0 +1,63 @@
+const sc = require('sourcecred').sourcecred;
+const scUtils = require('./sourcecred-utils');
+
+module.exports = {
+    //exists - {"action":{"alias":{"address":"N\u0000sourcecred\u0000discourse\u0000user\u0000https://forum.nation3.org\u0000aahna\u0000","description":"discourse/[@aahna](https://forum.nation3.org/u/aahna/)"}
+    //new    - {"action":{"alias":{"address":"N\u0000sourcecred\u0000dicourse\u0000user\u0000https://forum.nation3.org\u0000aahna\u0000","description":"discourse/[@aahna](https://forum.nation3.org/u/aahna)"}
+    testAndUpdateDiscourseAccount: async (ledgerManager, lowerAccountToIdentityMap, passportData, chainId, tokenAddress) => {
+        const {passport_id, owner_address, discourse_username} = passportData;
+
+        console.info(`Reading Discourse data for: ${passport_id}`);
+
+        if ((!discourse_username)) {
+            console.info(`No Discourse username for passport ${passport_id}`)
+            return;
+        }
+
+        //construct identity
+        const discourseAddress = scUtils.createDiscourseIdentity(discourse_username);
+
+        const hasAccount = lowerAccountToIdentityMap.has(discourseAddress.toLowerCase());
+        if(hasAccount) {
+            scUtils.testAndUpdateAccountPayoutAddress(
+                ledgerManager, 
+                lowerAccountToIdentityMap, 
+                discourseAddress, 
+                'discourse', 
+                discourse_username, 
+                passport_id, 
+                owner_address, 
+                chainId, 
+                tokenAddress);              
+        }
+        else {
+            addDiscourseIdentityAndSetPayoutAddress(
+                ledgerManager, 
+                discourseAddress, 
+                discourse_username, 
+                passport_id, 
+                owner_address, 
+                chainId, 
+                tokenAddress);
+        }
+    }
+}
+
+function addDiscourseIdentityAndSetPayoutAddress(ledgerManager, scAddress, dUsername, passport_id, owner_address, chainId, tokenAddress) {
+    console.log(`Creating a new SourceCred identity for ${dUsername} for passport ${passport_id}`)
+
+    const baseIdentityProposal = scUtils.createDiscourseIdentityProposal(scAddress, dUsername);
+
+    const baseIdentityId = sc.ledger.utils.ensureIdentityExists(
+        ledgerManager.ledger,
+        baseIdentityProposal,
+    );
+
+    console.log(`Base Identity ID ${JSON.stringify(baseIdentityId)}`);
+
+    console.log(`Setting payout address for GitHub for passport ${passport_id} - gitHubUsername ${dUsername}`)
+
+    ledgerManager.ledger.setPayoutAddress(baseIdentityId, owner_address ,chainId, tokenAddress);
+
+    console.log(`Updated payout address to ${owner_address} for passport ${passport_id} - gitHubUsername ${dUsername}`)
+}

scripts/github-utils.js

@@ -0,0 +1,82 @@
+const sc = require('sourcecred').sourcecred;
+const scUtils = require('./sourcecred-utils');
+
+module.exports = {
+    testAndUpdateGithubAccount: async (ledgerManager, lowerAccountToIdentityMap, passportData, chainId, tokenAddress) => {
+        const {passport_id, owner_address, github_username, github_username_ens} = passportData;
+
+        console.info(`Reading GitHub data for: ${passport_id}`);
+
+        if ((!github_username) && (!github_username_ens)) {
+            console.info(`No GitHub username for passport ${passport_id}`)
+            return;
+        }
+
+        //get just the username from one of the two columns
+        const tidiedGithubUsername = github_username && github_username.length > 0
+        ? cleanGithubUsername(github_username)
+        : cleanGithubUsername(github_username_ens);
+
+        //construct identity
+        const ghAddress = scUtils.createGitHubIdentity(tidiedGithubUsername);
+
+        const hasAccount = lowerAccountToIdentityMap.has(ghAddress.toLowerCase());
+        if(hasAccount) {
+            scUtils.testAndUpdateAccountPayoutAddress(
+                ledgerManager, 
+                lowerAccountToIdentityMap, 
+                ghAddress, 
+                'github', 
+                tidiedGithubUsername, 
+                passport_id, 
+                owner_address, 
+                chainId, 
+                tokenAddress);              
+        }
+        else {
+            addGitHubIdentityAndSetPayoutAddress(
+                ledgerManager, 
+                ghAddress, 
+                tidiedGithubUsername, 
+                passport_id, 
+                owner_address, 
+                chainId, 
+                tokenAddress);
+        }
+    }
+}
+
+function addGitHubIdentityAndSetPayoutAddress(ledgerManager, scAddress, ghUsername, passport_id, owner_address, chainId, tokenAddress) {
+    console.log(`Creating a new SourceCred identity for ${ghUsername} for passport ${passport_id}`)
+
+    const baseIdentityProposal = scUtils.createGitHubIdentityProposal(scAddress, ghUsername);
+
+    const baseIdentityId = sc.ledger.utils.ensureIdentityExists(
+        ledgerManager.ledger,
+        baseIdentityProposal,
+    );
+
+    console.log(`Base Identity ID ${JSON.stringify(baseIdentityId)}`);
+
+    console.log(`Setting payout address for GitHub for passport ${passport_id} - gitHubUsername ${ghUsername}`)
+
+    ledgerManager.ledger.setPayoutAddress(baseIdentityId, owner_address, chainId, tokenAddress);
+
+    console.log(`Updated payout address to ${owner_address} for passport ${passport_id} - gitHubUsername ${ghUsername}`)
+}
+
+function cleanGithubUsername(ghUsername) {
+    //https://github.com/luisivan
+    //@adelaideisla
+    let processing = ghUsername;
+    if(ghUsername.indexOf('/') >= 0) {
+        const regex = /.*\/(.*)/gm;
+        processing = processing.replace(regex, '$1');
+    }
+
+    if(processing.startsWith('@')) {
+        processing = processing.substring(0);
+    }
+
+    return processing;
+}