private flow for register in entropy class WIP

src/index.ts

@@ -7,7 +7,7 @@
 import { isValidPair } from './keys'
 import { Signer, Address } from './types'
 import ProgramManager from './programs'
-
+import { runDkgProtocol, ValidatorInfo, fromHex } from '@entropyxyz/entropy-protocol-nodejs'
 export interface EntropyAccount {
   sigRequestKey?: Signer
   programModKey?: Signer | string
@@ -33,21 +33,21 @@
  *
  * @example
  * ```typescript
- * const signer = await getWallet(charlieStashSeed);
+ * const signer = await getWallet(charlieStashSeed)
  *
  * const entropyAccount: EntropyAccount = {
  *   sigRequestKey: signer,
  *   programModKey: signer,
- * };
+ * }
  *
- * const entropy = new Entropy({ account: entropyAccount });
- * await entropy.ready;
+ * const entropy = new Entropy({ account: entropyAccount })
+ * await entropy.ready
  *
- * await entropy.register({ 
- *   programModAccount: '5Gw3s7q9...', 
- *   keyVisibility: 'Permissioned', 
- *   freeTx: false 
- * });
+ * await entropy.register({
+ *   programModAccount: '5Gw3s7q9...',
+ *   keyVisibility: 'Permissioned',
+ *   freeTx: false
+ * })
  * ```
  * @alpha
  */
@@ -79,7 +79,6 @@
    * @param {Adapter[]} [opts.adapters] - A collection of signing adapters for handling various transaction types.
    */
 
-
   constructor (opts: EntropyOpts) {
     this.ready = new Promise((resolve, reject) => {
       this.#ready = resolve
@@ -101,23 +100,37 @@
 
     this.registrationManager = new RegistrationManager({
       substrate: this.substrate,
-      signer: {wallet: this.account.sigRequestKey.wallet, pair: this.account.sigRequestKey.pair},
+      signer: {
+        wallet: this.account.sigRequestKey.wallet,
+        pair: this.account.sigRequestKey.pair,
+      },
     })
     this.signingManager = new SignatureRequestManager({
-      signer: {wallet: this.account.sigRequestKey.wallet, pair: this.account.sigRequestKey.pair},
+      signer: {
+        wallet: this.account.sigRequestKey.wallet,
+        pair: this.account.sigRequestKey.pair,
+      },
       substrate: this.substrate,
       adapters: opts.adapters,
       crypto,
     })
 
-    const programModKeyPair = isValidPair(this.account.programModKey as Signer) ? this.account.programModKey : undefined
+    const programModKeyPair = isValidPair(this.account.programModKey as Signer)
+      ? this.account.programModKey
+      : undefined
 
     this.programs = new ProgramManager({
       substrate: this.substrate,
-      programModKey: programModKeyPair as Signer || this.account.sigRequestKey,
-      programDeployKey: this.account.programDeployKey
+      programModKey:
+        (programModKeyPair as Signer) || this.account.sigRequestKey,
+      programDeployKey: this.account.programDeployKey,
     })
-    if (this.#programReadOnly || this.#allReadOnly) this.programs.set = async () => { throw new Error('Programs is in a read only state: Must pass a valid key pair in initialization.') }
+    if (this.#programReadOnly || this.#allReadOnly)
+      this.programs.set = async () => {
+        throw new Error(
+          'Programs is in a read only state: Must pass a valid key pair in initialization.'
+        )
+      }
     this.#ready(true)
     this.isRegistered = this.registrationManager.checkRegistrationStatus.bind(
       this.registrationManager
@@ -141,10 +154,9 @@
     }
   }
 
-
   /** @internal */
   #setReadOnlyStates (): void {
-  // the readOnly state will not allow for write functions
+    // the readOnly state will not allow for write functions
     this.#programReadOnly = false
     this.#allReadOnly = false
 
@@ -154,11 +166,17 @@
       this.#allReadOnly = true
     }
 
-
     if (typeof this.account.sigRequestKey !== 'object') {
       throw new Error('AccountTypeError: sigRequestKey can not be a string')
-    } else if (!isValidPair({ wallet: this.account.sigRequestKey.wallet, pair: this.account.sigRequestKey.pair})) {
-      throw new Error('AccountTypeError: sigRequestKey not a valid signing pair')
+    } else if (
+      !isValidPair({
+        wallet: this.account.sigRequestKey.wallet,
+        pair: this.account.sigRequestKey.pair,
+      })
+    ) {
+      throw new Error(
+        'AccountTypeError: sigRequestKey not a valid signing pair'
+      )
     }
 
     if (typeof this.account.programModKey === 'string') {
@@ -169,7 +187,6 @@
     }
   }
 
-
   /**
    * Registers an address with Entropy using the provided parameters.
    *
@@ -187,7 +204,10 @@
     params: RegistrationParams & { account?: EntropyAccount }
   ): Promise<void> {
     await this.ready
-    if (this.#allReadOnly) throw new Error('Initialized in read only state: can not use write functions')
+    if (this.#allReadOnly)
+      throw new Error(
+        'Initialized in read only state: can not use write functions'
+      )
     const account = params.account || this.account
 
     if (!account) {
@@ -198,26 +218,128 @@
       params.programModAccount &&
       !isValidSubstrateAddress(params.programModAccount)
     ) {
-      throw new TypeError('Incompatible address type')
+      throw new TypeError('Incompatible address type') 
     }
-    await this.registrationManager.register(params)
-    this.account.verifyingKey = await this.getVerifyingKey(this.account.sigRequestKey.wallet.address)
 
+    if (params.keyVisibility === 'Private') {
+      await this.participateInDkgForPrivateVisibility(
+        this.account.sigRequestKey.wallet.address
+      )
+
+      await this.registrationManager.register(params)
+      this.account.verifyingKey = await this.getVerifyingKey(
+        this.account.sigRequestKey.wallet.address
+      )
+    } 
   }
 
+  async participateInDkgForPrivateVisibility (address: string): Promise<void> {
+    console.log("PRIVATE REGISTER")
+    const blockNumber = await this.substrate.rpc.chain.getHeader().then((header) => header.number.toNumber())
+    console.log("block", blockNumber)
+    const validatorsInfo = await this.getDKGCommittee(blockNumber + 1)
+    if (validatorsInfo.length === 0) {
+      throw new Error('No validators info available for DKG.')
+    }
+
+    const selectedValidatorAccountId = await this.selectValidatorFromSubgroup(0, blockNumber)
+    const selectedValidatorInfo = validatorsInfo.find(v => v.getTssAccount().toString() === selectedValidatorAccountId)
+
+    if (!selectedValidatorInfo) {
+      throw new Error('Selected validator info not found.')
+    }
+
+    await runDkgProtocol([selectedValidatorInfo], this.account.sigRequestKey.pair.secretKey)
+    console.log('DKG Protocol completed for address:', address)
+  }
+
+  async getDKGCommittee (blockNumber: number): Promise<ValidatorInfo[]> {
+    console.log("GET DKG COMMITTEE")
+    const validatorsInfo: ValidatorInfo[] = []
+    const SIGNING_PARTY_SIZE = 2
+
+    for (let i = 0; i < SIGNING_PARTY_SIZE; i++) {
+      try {
+        const accountId = await this.selectValidatorFromSubgroup(i, blockNumber)
+        console.log({accountId})
+        const serverInfoOption = await this.substrate.query.stakingExtension.thresholdServers(accountId)
+
+        if (serverInfoOption.isNone) {
+          throw new Error("Stash Fetch Error")
+        }
+
+        console.log("pre server info")
+
+        const serverInfo = serverInfoOption.unwrap()
+        console.log("PubKey", serverInfo.x25519PublicKey.toString())
+        console.log("endpoint", serverInfo.endpoint.toString())
+        console.log("tss", serverInfo.tssAccount.toString())
+        validatorsInfo.push(new ValidatorInfo(fromHex(serverInfo.x25519PublicKey.toString()), serverInfo.endpoint.toString(), serverInfo.tssAccount))
+      } catch (error) {
+        console.error(`Error fetching validator info: ${error}`)
+        throw error
+      }
+    }
+    console.log("ABOUT TO CONSOLE VALIDATOR INFO")
+
+    return validatorsInfo
+  }
+  async selectValidatorFromSubgroup (signingGroup: number, blockNumber: number): Promise<string> {
+    try {
+      const subgroupInfo = await this.substrate.query.stakingExtension.signingGroups(signingGroup)
+      if (subgroupInfo.isNone || subgroupInfo.unwrap().isEmpty) {
+        throw new Error("Subgroup information not available or empty.")
+      }
+      const subgroupAddresses = subgroupInfo.unwrap().toArray() 
+
+      while (subgroupAddresses.length > 0) {
+        const selectionIndex = blockNumber % subgroupAddresses.length
+        const address = subgroupAddresses[selectionIndex]
+
+        try {
+          const isSynced = await this.substrate.query.stakingExtension.isValidatorSynced(address)
+
+          if (isSynced) {
+            console.log(`Address ${address.toString()} is synced.`)
+            return address.toString()
+          } else {
+            subgroupAddresses.splice(selectionIndex, 1) 
+            blockNumber++
+            console.log(`Address ${address.toString()} is not synced. Trying next validator.`)
+          }
+        } catch (error) {
+          console.error(`Error checking sync status for address ${address.toString()}:`, error)
+          subgroupAddresses.splice(selectionIndex, 1)
+        }
+      }
+      throw new Error("No synced validators found in the subgroup.")
+    } catch (error) {
+      console.error("Failed to select a validator:", error)
+      throw error
+    }
+  }
   /**
    * Retrieves the verifying key associated with the given address's registration record.
    *
    * @param {Address} address - The address for which the verifying key is needed.
    * @returns {Promise<string>} - A promise resolving to the verifying key.
    */
-  
+
   async getVerifyingKey (address: Address): Promise<string> {
-    const registeredInfo = await this.substrate.query.relayer.registered(address)
+    const registeredInfo = await this.substrate.query.relayer.registered(
+      address
+    )
     // @ts-ignore: next line
     return registeredInfo.toHuman().verifyingKey
   }
 
+  async getKeyVisibility ( address: Address): Promise<string> {
+    const registeredInfo = await this.substrate.query.relayer.registered(address)
+
+    // @ts-ignore: next line
+    return registeredInfo.toHuman().keyVisibility 
+  }
+
   /**
    * Signs a given transaction based on the provided parameters.
    *
@@ -239,10 +361,24 @@
 
   async signTransaction (params: SigTxOps): Promise<unknown> {
     await this.ready
-    if (this.#allReadOnly) throw new Error('Initialized in read only state: can not use write functions')
-    return this.signingManager.signTransaction(params)
+    if (this.#allReadOnly)
+      throw new Error(
+        'Initialized in read only state: can not use write functions'
+      )
+
+    const keyVisibilityInfo = await this.getKeyVisibility(this.account.sigRequestKey.wallet.address) 
+
+    if (keyVisibilityInfo === 'Private') {
+      return this.signingManager.privateSign(params)
+    } else {
+      return this.signingManager.signTransaction(params)
+    }
   }
 
+
+
+
+
   /**
    * Signs a signature request hash. This method involves various steps including validator
    * selection, transaction request formatting, and submission of these requests to validators
@@ -258,7 +394,12 @@
 
   async sign (params: SigOps): Promise<Uint8Array> {
     await this.ready
-    if (this.#allReadOnly) throw new Error('Initialized in read only state: can not use write functions')
+    if (this.#allReadOnly)
+      throw new Error(
+        'Initialized in read only state: can not use write functions'
+      )
+
+
     return this.signingManager.sign(params)
   }
 }

src/registration/index.ts

@@ -59,7 +59,7 @@
   async register ({
     freeTx = false,
     initialPrograms = [],
-    keyVisibility = 'Permissioned',
+    keyVisibility,
     programModAccount,
   }: RegistrationParams): Promise<RegisteredInfo> {
     const programModificationAccount = programModAccount
@@ -99,11 +99,11 @@
                 const registeredData = await this.substrate.query.relayer.registered(
                   this.signer.wallet.address
                 )
                 // @ts-ignore: next line
                 if (!registeredData.isSome) {
                   throw new Error('Registration information not found')
                 }
                 // @ts-ignore: next line
                 const data = registeredData.unwrap()
                 resolve({
                   keyVisibility: data.keyVisibility.toJSON() as KeyVisibilityInfo,
@@ -134,6 +134,8 @@
     return registered
   }
 
+
+
   /**
    * Verifies the registration status of an address.
    *