[NayNay] Registration verifying keys being stripped at Keyring

package.json

@@ -56,6 +56,7 @@
     "build:watch": "tsup --watch",
     "build:node": "tsup --platform node ",
     "build:browser": "tsup --platform browser",
+    "build:link": "yarn build && yarn unlink && yarn link",
     "find-deadcode": "ts-prune",
     "generate:types": "dev/bin/generate-types.sh",
     "prepare": "husky",

src/index.ts

@@ -78,6 +78,7 @@ export default class Entropy {
       signer: this.keyring.getLazyLoadAccountProxy(ChildKey.registration),
     })
     this.signingManager = new SignatureRequestManager({
+      keyring: this.keyring,
       signer: this.keyring.getLazyLoadAccountProxy(ChildKey.deviceKey),
       substrate: this.substrate,
       adapters: opts.adapters,
@@ -130,15 +131,11 @@ export default class Entropy {
 
     const verifyingKey = await this.registrationManager.register(params)
     // fuck frankie TODO: Make legit function
-    const vk = this.keyring.accounts[ChildKey.registration].verifyingKeys || []
-    this.keyring.accounts[ChildKey.registration].verifyingKeys = [
-      ...vk,
-      verifyingKey,
-    ]
-    this.keyring.accounts[ChildKey.deviceKey].verifyingKeys = [
-      ...vk,
-      verifyingKey,
-    ]
+    const admin = this.keyring.getLazyLoadAccountProxy(ChildKey.registration)
+    const vk = admin.verifyingKeys || []
+    // HACK: these assignments trigger important `account-update` flows via the Proxy 
+    admin.verifyingKeys = [...vk, verifyingKey]
+    deviceKey.verifyingKeys = [verifyingKey, ...vk]
     return verifyingKey
   }
 

src/keys/index.ts

@@ -1,4 +1,5 @@
 import EventEmitter from 'node:events'
+import { deepCopy } from '../utils/housekeeping'
 import * as utils from './utils'
 import { EntropyAccount, KeyMaterial, PairMaterial } from './types/json'
 import {
@@ -33,6 +34,7 @@ export default class Keyring {
    */
 
   constructor (account: KeyMaterial) {
+    // this repersents keys that are used by the user
     this.#used = ['admin', ChildKey.registration]
     Object.keys(account).forEach((key) => {
       if (typeof account[key] === 'object' && account[key].userContext) {
@@ -51,49 +53,47 @@ export default class Keyring {
     }
     const accountsJson = this.#formatAccounts(account)
     this.accounts = this.#createFunctionalAccounts(accountsJson)
+    this.accounts.masterAccountView = accountsJson
   }
 
-  /**
-   * Retrieves the current account information.
-   *
-   * @returns An object containing the Entropy account details.
-   */
+  #formatAccounts (accounts: EntropyAccount): EntropyAccount {
 
-  // IMPORTANT!! WE SHOULD DECIDE IF WE WILL ALWAYS BE GENERATING UUID FOR ACCOUNTS OR IF WE
-  // WILL ALLOW USERS TO PASS THEIR OWN STRINGS
+    const { seed, type, admin } = accounts
+    const debug = true
+    const entropyAccountsJson = {
+      debug,
+      // previously was seed ? seed : utils.seedFromMnemonic(mnemonic) but this has already been derived in the constructor
+      // @frankie correct if im wrong here
+      seed: this.#seed,
+      type,
+      admin,
+    }
 
-  getAccount (): EntropyAccount {
-    const { debug, seed, type, verifyingKeys } = this.accounts.masterAccountView
-    const entropyAccount: EntropyAccount = { debug, seed, type, verifyingKeys }
-    this.#used.forEach((accountName) => {
-      entropyAccount[accountName] = this.accounts.masterAccountView[accountName]
-    })
-    entropyAccount.admin = this.accounts.registration
-    return entropyAccount
-  }
 
-  #createFunctionalAccounts (
-    masterAccountView: EntropyAccount
-  ): AccountsEmitter {
-    const accounts = new EventEmitter() as AccountsEmitter
-    accounts.type = accounts.type || EntropyAccountType.MIXED_ACCOUNT
-    Object.keys(masterAccountView).forEach((name) => {
-      if (name) {
-        if (typeof masterAccountView[name] !== 'object') return
-        const { seed, path } = masterAccountView[name]
-        if (!seed) return
-        const { pair, address } = utils.generateKeyPairFromSeed(seed, path)
-        const functionalAccount = {
-          seed,
-          path,
-          address,
-          pair,
+    Object.keys(accounts)
+      .concat(ACCOUNTS)
+      .forEach((key) => {
+
+        let account: PairMaterial
+        if (entropyAccountsJson[key]) return
+        if (key === ChildKey.registration && admin?.seed) {
+          if (accounts[key]) {
+            account = { ...admin, ...accounts[key] }
+          } else {
+            account = admin
+          }
+
+          entropyAccountsJson[key] = this.#jsonAccountCreator(account, debug)
+          return
         }
-        accounts[name] = functionalAccount
-      }
-    })
-    accounts.masterAccountView = masterAccountView
-    return accounts
+        if (accounts[key] && accounts[key].userContext) account = accounts[key]
+        else if (ChildKey[key]) account = { type: ChildKey[key], seed }
+        if (!account) return
+        entropyAccountsJson[key] = this.#jsonAccountCreator(account, debug)
+      })
+    if (!admin) entropyAccountsJson.admin = entropyAccountsJson[ChildKey.registration]
+
+    return entropyAccountsJson as EntropyAccount
   }
 
   /**
@@ -129,34 +129,50 @@ export default class Keyring {
     return jsonAccount
   }
 
-  #formatAccounts (accounts: EntropyAccount): EntropyAccount {
-    const { seed, mnemonic, type, admin } = accounts
-    // this is because stuff is broken outside of debug mode so making it true always
-    const debug = true
-    const entropyAccountsJson = {
-      debug,
-      seed: seed ? seed : utils.seedFromMnemonic(mnemonic),
-      type,
-      admin,
-    }
+  #createFunctionalAccounts (
+    masterAccountView: EntropyAccount
+  ): AccountsEmitter {
 
-    Object.keys(accounts)
-      .concat(ACCOUNTS)
-      .forEach((key) => {
-        let account: PairMaterial
-        if (entropyAccountsJson[key]) return
-        if (key === ChildKey.registration && admin?.seed) {
-          account = admin
-          entropyAccountsJson[key] = this.#jsonAccountCreator(account, debug)
-          return
+    const accounts = new EventEmitter() as AccountsEmitter
+    accounts.type = accounts.type || EntropyAccountType.MIXED_ACCOUNT
+    Object.keys(masterAccountView).forEach((name) => {
+      if (name) {
+        if (typeof masterAccountView[name] !== 'object') return
+        const { seed, path, ...accountData } = masterAccountView[name]
+        if (!seed) return
+        const { pair, address } = utils.generateKeyPairFromSeed(seed, path)
+        const functionalAccount = {
+          ...accountData,
+          seed,
+          path,
+          address,
+          pair,
         }
-        if (accounts[key] && accounts[key].userContext) account = accounts[key]
-        else if (ChildKey[key]) account = { type: ChildKey[key], seed }
-        if (!account) return
-        entropyAccountsJson[key] = this.#jsonAccountCreator(account, debug)
-      })
+        accounts[name] = functionalAccount
+      }
+    })
+    accounts.masterAccountView = masterAccountView
+    return accounts
+  }
 
-    return entropyAccountsJson as EntropyAccount
+  /**
+   * Retrieves the current account information.
+   *
+   * @returns An object containing the Entropy account details.
+   */
+
+  // IMPORTANT!! WE SHOULD DECIDE IF WE WILL ALWAYS BE GENERATING UUID FOR ACCOUNTS OR IF WE
+  // WILL ALLOW USERS TO PASS THEIR OWN STRINGS
+
+  getAccount (): EntropyAccount {
+    const { debug, seed, type, verifyingKeys } = this.accounts.masterAccountView
+    const entropyAccount: EntropyAccount = { debug, seed, type, verifyingKeys }
+    this.#used.forEach((accountName) => {
+      if (this.accounts[accountName] === undefined) return
+      entropyAccount[accountName] = deepCopy(this.accounts[accountName] as PairMaterial)
+    })
+    entropyAccount.admin = entropyAccount.registration
+    return entropyAccount
   }
 
   /**
@@ -178,8 +194,12 @@ export default class Keyring {
           this.#used.push(childKey)
         }
         this.accounts[childKey][k] = v
-        this.accounts.emit(`#account-update`, this.getAccount())
         this.accounts.masterAccountView[childKey][k] = v
+        // DO NOT REMOVE setTimeout UNLESS YOU SOLVED THE RACE CONDITION
+        setTimeout(
+          () => this.accounts.emit(`account-update`, this.getAccount()),
+          10
+        )
         return v
       },
     })

src/keys/utils.ts

@@ -23,6 +23,8 @@ export const keysCryptoWaitReady = cryptoWaitReady()
  */
 
 export function seedFromMnemonic (m) {
+  // If this is returned as a Uint8Array would it be beneficial to convert back to a string and just use strings everywhere?
+  // it will reduce the use of force casting to a specific type
   return mnemonicToMiniSecret(m)
 }
 

src/signing/index.ts

@@ -6,8 +6,10 @@ import { EncMsg, ValidatorInfo } from '../types/internal'
 import { stripHexPrefix, sendHttpPost, toHex } from '../utils'
 import { crypto } from '../utils/crypto'
 import { CryptoLib } from '../utils/crypto/types'
+import Keyring from '../keys'
 
 export interface Config {
+  keyring: Keyring
   signer: Signer
   substrate: ApiPromise
   adapters: { [key: string | number]: Adapter }
@@ -51,6 +53,7 @@ export interface UserSignatureRequest {
  * Constructs a SignatureRequestManager instance.
  *
  * @param {Config} config - The configuration for the SignatureRequestManager.
+ * @param {Keyring} config.keyring - The full keyring
  * @param {Signer} config.signer - The Signer instance.
  * @param {ApiPromise} config.substrate - The Substrate API instance.
  * @param {Adapter} config.adapters - The adapters for handling different types of transactions.
@@ -60,20 +63,23 @@ export interface UserSignatureRequest {
 export default class SignatureRequestManager {
   adapters: { [key: string | number]: Adapter }
   crypto: CryptoLib
+  keyring: Keyring
   signer: Signer
   substrate: ApiPromise
 
   /**
    * Initializes a new instance of `SignatureRequestManager`.
    *
    * @param {Config} config - Configuration settings for the manager.
+   * @param {Keyring} config.keyring - The full keyring
    * @param {Signer} config.signer - The signer for authorizing transactions.
    * @param {ApiPromise} config.substrate - Instance of the Polkadot/Substrate API.
    * @param {Adapter[]} config.adapters - Set of adapters for handling different types of transactions.
    * @param {CryptoLib} config.crypto - Instance of CryptoLib for cryptographic operations.
    */
 
-  constructor ({ signer, substrate, adapters, crypto }: Config) {
+  constructor ({ keyring, signer, substrate, adapters, crypto }: Config) {
+    this.keyring = keyring
     this.signer = signer
     this.substrate = substrate
     this.crypto = crypto
@@ -90,7 +96,12 @@ export default class SignatureRequestManager {
    */
 
   get verifyingKey () {
-    return this.signer.verifyingKeys ? this.signer.verifyingKeys[0] : undefined
+    let key = this.signer?.verifyingKeys?.[0]
+    // Returning verifying key from regsitration account if device key keys do not exist
+    if (!key) {
+      key = this.keyring.accounts.registration.verifyingKeys[0]
+    }
+    return key
   }
 
   /*
@@ -137,6 +148,7 @@ export default class SignatureRequestManager {
         return adapter.preSign(this.signer, msg)
       })
     )
+
     // [AuxData[], ...]
     const auxiliaryDataCollection = results.map(({ auxilary_data }) => {
       return auxilary_data
@@ -247,8 +259,8 @@ export default class SignatureRequestManager {
 
         // TODO: auxilaryData full implementation
         if (auxiliaryData) {
-          txRequestData.auxilary_data = auxiliaryData.map((signleAuxData) =>
-            toHex(JSON.stringify(signleAuxData))
+          txRequestData.auxilary_data = auxiliaryData.map((singleAuxData) =>
+            toHex(JSON.stringify(singleAuxData))
           )
         }
         // TODO handle array here
@@ -302,10 +314,12 @@ export default class SignatureRequestManager {
       txReq.map(async (message: EncMsg) => {
         // Extract the required fields from parsedMsg
         const parsedMsg = JSON.parse(message.msg)
+
         const payload = {
           ...parsedMsg,
           msg: parsedMsg.msg,
         }
+
         const sigProof = (await sendHttpPost(
           `http://${message.url}/user/sign_tx`,
           JSON.stringify(payload)

src/utils/housekeeping/index.ts

@@ -0,0 +1,13 @@
+
+
+
+
+// maybe lodash maybe not?
+// keep in mind registering can take over 20 seconds
+// if we
+
+/**
+ * returns a deep copy of the object */
+export function deepCopy (thing: any): any {
+  return JSON.parse(JSON.stringify(thing))
+}

tests/end-to-end.test.ts

@@ -35,8 +35,9 @@ test('End To End', async (t) => {
 
   await run('wasm', wasmGlobalsReady())
 
-  let store = {}
   const keyring = new Keyring({ seed: charlieStashSeed, debug: true })
+  let store = keyring.getAccount()
+  t.equal(store.admin.address, keyring.accounts.registration.pair.address, 'admin account should have an address and for now it should match registrations address')
   keyring.accounts.on('account-update', (fullAccount) => {
     store = fullAccount
   })
@@ -69,12 +70,43 @@ test('End To End', async (t) => {
   // t.equal(typeof pointer, 'string', 'valid pointer')
 
   // register
-  const verifyingKeyFromRegistration = await run('register', entropy.register())
+  let verifyingKeyFromRegistration
+  const emitterTest = run(
+    'keyring.accounts.once#account-update',
+    new Promise((res, reject) => {
+      // TODO remove event listener if it hangs
+      keyring.accounts.on('account-update', (fullAccountView) => {
+        if (!verifyingKeyFromRegistration) return
+        if (!fullAccountView.admin) reject('no admin account')
+        if (!fullAccountView.registration) reject('no registration account')
+        if (!fullAccountView.deviceKey) reject('no deviceKey account')
+        if (!fullAccountView.registration.verifyingKeys)
+          reject('no registration.verifyingKeys ')
+        if (!fullAccountView.registration.verifyingKeys[0])
+          reject(
+            'no registration.verifyingKeys[0] this means their were no keys added'
+          )
+        const last = fullAccountView.registration.verifyingKeys.pop()
+        if (!last === verifyingKeyFromRegistration)
+          reject('verifyingKey returned in registration does not match')
+        if (!last === fullAccountView.deviceKey.verifyingKeys[0])
+          reject(
+            'verifyingKey on registration does not match device keys verifyingKeys[0]'
+          )
+        return res(fullAccountView)
+      })
+    })
+  )
+  verifyingKeyFromRegistration = await run('register', entropy.register())
+
   t.equal(
     verifyingKeyFromRegistration,
     entropy.keyring.accounts.registration.verifyingKeys[0],
     'verifyingKeys match after registration'
   )
+  // tests the once function as well as what is
+  // considered to be necessary changes to the full account after emitting
+  await emitterTest
 
   //
   // sign some data