update map name/methods and clients

Author: Omarabdul3ziz

clients/tfchain-client-go/events.go

@@ -100,6 +100,13 @@ type TwinEntityRemoved struct {
 	Topics []types.Hash
 }
 
+type MyceliumTwinUpdated struct {
+	Phase      types.Phase
+	MyceliumPk []byte    `json:"mycelium_pk"`
+	TwinId     types.U32 `json:"twin_id"`
+	Topics     []types.Hash
+}
+
 type TwinAccountBounded struct {
 	Phase   types.Phase
 	Twin    types.U32 `json:"twin_id"`
@@ -414,12 +421,13 @@ type EventRecords struct {
 	TfgridModule_EntityDeleted []EntityDeleted //nolint:stylecheck,golint
 
 	// twin events
-	TfgridModule_TwinStored         []TwinStored         //nolint:stylecheck,golint
-	TfgridModule_TwinUpdated        []TwinStored         //nolint:stylecheck,golint
-	TfgridModule_TwinDeleted        []TwinDeleted        //nolint:stylecheck,golint
-	TfgridModule_TwinEntityStored   []TwinEntityStored   //nolint:stylecheck,golint
-	TfgridModule_TwinEntityRemoved  []TwinEntityRemoved  //nolint:stylecheck,golint
-	TfgridModule_TwinAccountBounded []TwinAccountBounded //nolint:stylecheck,golint
+	TfgridModule_TwinStored          []TwinStored          //nolint:stylecheck,golint
+	TfgridModule_TwinUpdated         []TwinStored          //nolint:stylecheck,golint
+	TfgridModule_TwinDeleted         []TwinDeleted         //nolint:stylecheck,golint
+	TfgridModule_TwinEntityStored    []TwinEntityStored    //nolint:stylecheck,golint
+	TfgridModule_TwinEntityRemoved   []TwinEntityRemoved   //nolint:stylecheck,golint
+	TfgridModule_TwinAccountBounded  []TwinAccountBounded  //nolint:stylecheck,golint
+	TfgridModule_MyceliumTwinUpdated []MyceliumTwinUpdated //nolint:stylecheck,golint
 
 	// policy events
 	TfgridModule_PricingPolicyStored []PricingPolicyStored //nolint:stylecheck,golint

clients/tfchain-client-go/twin.go

@@ -183,52 +183,68 @@ func (s *Substrate) UpdateTwin(identity Identity, relay string, pk []byte) (uint
 	return s.GetTwinByPubKey(identity.PublicKey())
 }
 
-// SetTwinMyceliumPK sets the mycelium PK for a twin
-func (s *Substrate) SetTwinMyceliumPK(identity Identity, twinID uint32, myceliumPK []byte) error {
+// SetMyceliumTwin sets the mycelium public key mapping for a twin
+//
+// Parameters:
+//   - identity: The identity for signing the transaction
+//   - myceliumPK: The mycelium public key (hex string), ip will work as well
+//   - twinID: The twin ID to map to the mycelium public key
+//
+// Returns:
+//   - error: nil on success, error on failure
+func (s *Substrate) SetMyceliumTwin(identity Identity, myceliumPK string, twinID uint32) error {
 	cl, meta, err := s.GetClient()
 	if err != nil {
 		return err
 	}
 
-	c, err := types.NewCall(meta, "TfgridModule.set_twin_mycelium_pk", twinID, myceliumPK)
+	bytes := []byte(myceliumPK)
+	c, err := types.NewCall(meta, "TfgridModule.set_mycelium_twin", bytes, twinID)
 	if err != nil {
 		return errors.Wrap(err, "failed to create call")
 	}
 
 	if _, err := s.Call(cl, meta, identity, c); err != nil {
-		return errors.Wrap(err, "failed to set twin mycelium pk")
+		return errors.Wrap(err, "failed to set mycelium twin")
 	}
 
 	return nil
 }
 
-// GetTwinIdByMyceliumPK gets twin id by mycelium PK
-func (s *Substrate) GetTwinIdByMyceliumPK(myceliumPK []byte) (*Twin, error) {
+// GetMyceliumTwin gets the twin ID associated with a mycelium public key
+//
+// Parameters:
+//   - myceliumPK: The mycelium public key (hex string)
+//
+// Returns:
+//   - uint32: The twin ID associated with the mycelium public key
+//   - error: nil on success, error on failure (including ErrNotFound if no twin is found)
+func (s *Substrate) GetMyceliumTwin(myceliumPK string) (uint32, error) {
 	cl, meta, err := s.GetClient()
 	if err != nil {
-		return nil, err
+		return 0, err
 	}
 
 	// must use encode to convert byte slice to encoded format
 	bytes, err := Encode(myceliumPK)
 	if err != nil {
-		return nil, errors.Wrap(err, "substrate: encoding error building query arguments")
+		return 0, errors.Wrap(err, "substrate: encoding error building query arguments")
 	}
 
-	key, err := types.CreateStorageKey(meta, "TfgridModule", "TwinByMyceliumPk", bytes, nil)
+	key, err := types.CreateStorageKey(meta, "TfgridModule", "MyceliumTwin", bytes, nil)
 	if err != nil {
-		return nil, errors.Wrap(err, "failed to create substrate query key")
+		return 0, errors.Wrap(err, "failed to create substrate query key")
 	}
 
 	var twinID types.U32
 	ok, err := cl.RPC.State.GetStorageLatest(key, &twinID)
 	if err != nil {
-		return nil, errors.Wrap(err, "failed to lookup twin by mycelium pk")
+		return 0, errors.Wrap(err, "failed to lookup twin by mycelium pk")
 	}
 
 	if !ok || twinID == 0 {
-		return nil, errors.Wrap(ErrNotFound, "twin not found for mycelium pk")
+		return 0, errors.Wrap(ErrNotFound, "twin not found for mycelium pk")
 	}
 
-	return s.GetTwin(uint32(twinID))
+	return uint32(twinID), nil
 }

clients/tfchain-client-js/lib/client.js

@@ -11,7 +11,7 @@ const {
 const {
   createTwin, getTwin, getTwinIdByAccountId, updateTwin,
   deleteTwin, addTwinEntity, deleteTwinEntity, listTwins,
-  setTwinMyceliumPK, getTwinByMyceliumPK
+  setMyceliumTwin, getMyceliumTwin
 } = require('./twin')
 const {
   createFarm, getFarm, deleteFarm,
@@ -162,12 +162,24 @@ class Client {
     return deleteTwinEntity(this, twinID, entityID, callback)
   }
 
-  async setTwinMyceliumPK(twinId, myceliumPk, callback) {
-    return setTwinMyceliumPK(this, twinId, myceliumPk, callback)
-  }
-
-  async getTwinByMyceliumPK(myceliumPk) {
-    return getTwinByMyceliumPK(this, myceliumPk)
+  /**
+   * Sets the mycelium public key mapping for a twin
+   * @param {string} myceliumPk - The mycelium public key (hex string)
+   * @param {number} twinId - The twin ID to map to the mycelium public key
+   * @param {Function} callback - Optional callback function
+   * @returns {Promise} Transaction result
+   */
+  async setMyceliumTwin(myceliumPk, twinId, callback) {
+    return setMyceliumTwin(this, myceliumPk, twinId, callback)
+  }
+
+  /**
+   * Gets the twin ID associated with a mycelium public key
+   * @param {string} myceliumPk - The mycelium public key (hex string)
+   * @returns {Promise<number>} The twin ID associated with the mycelium public key
+   */
+  async getMyceliumTwin(myceliumPk) {
+    return getMyceliumTwin(this, myceliumPk)
   }
 
   async createFarm(name, certificationType, publicIPs, callback) {

clients/tfchain-client-js/lib/twin.js

@@ -92,26 +92,38 @@ async function deleteTwin (self, id, callback) {
     .signAndSend(self.key, { nonce }, callback)
 }
 
-// setTwinMyceliumPK sets the mycelium public key for a twin
-async function setTwinMyceliumPK (self, twinId, myceliumPk, callback) {
-  const setMyceliumPk = self.api.tx.tfgridModule.setTwinMyceliumPk(twinId, myceliumPk)
+/**
+ * Sets the mycelium public key mapping for a twin
+ * @param {Object} self - The client instance
+ * @param {string} myceliumPk - The mycelium public key (hex string)
+ * @param {number} twinId - The twin ID to map to the mycelium public key
+ * @param {Function} callback - Optional callback function
+ * @returns {Promise} Transaction result
+ */
+async function setMyceliumTwin (self, myceliumPk, twinId, callback) {
+  const setMyceliumTx = self.api.tx.tfgridModule.setMyceliumTwin(myceliumPk, twinId)
   const nonce = await self.api.rpc.system.accountNextIndex(self.address)
 
-  return setMyceliumPk.signAndSend(self.key, { nonce }, callback)
+  return setMyceliumTx.signAndSend(self.key, { nonce }, callback)
 }
 
-// getTwinByMyceliumPK gets a twin by mycelium public key
-async function getTwinByMyceliumPK (self, myceliumPk) {
-  // First, get the twin ID from the mycelium PK mapping
-  const twinIdResult = await self.api.query.tfgridModule.twinByMyceliumPk(myceliumPk)
+/**
+ * Gets the twin ID associated with a mycelium public key
+ * @param {Object} self - The client instance
+ * @param {string} myceliumPk - The mycelium public key (hex string)
+ * @returns {Promise<number>} The twin ID associated with the mycelium public key
+ * @throws {Error} If no twin is found for the given mycelium public key
+ */
+async function getMyceliumTwin (self, myceliumPk) {
+  // Get the twin ID from the mycelium PK mapping using the storage getter
+  const twinIdResult = await self.api.query.tfgridModule.myceliumTwin(myceliumPk)
   const twinId = twinIdResult.toJSON()
 
   if (!twinId || twinId === 0) {
     throw Error(`Couldn't find a twin for mycelium pk: ${myceliumPk}`)
   }
 
-  // Now get the full twin object using the twin ID
-  return getTwin(self, twinId)
+  return twinId
 }
 
 module.exports = {
@@ -123,6 +135,6 @@ module.exports = {
   addTwinEntity,
   deleteTwinEntity,
   listTwins,
-  setTwinMyceliumPK,
-  getTwinByMyceliumPK
+  setMyceliumTwin,
+  getMyceliumTwin
 }

clients/tfchain-client-rs/src/client.rs

@@ -152,24 +152,36 @@ impl Client {
         current::get_twin_id_by_account(self, account).await
     }
 
-    // Sets mycelium public key for a twin and checks for success, blockhash is returned on success
-    pub async fn set_twin_mycelium_pk(
+    /// Sets the mycelium public key mapping for a twin
+    ///
+    /// # Arguments
+    /// * `kp` - The keypair for signing the transaction
+    /// * `mycelium_pk` - The mycelium public key (as bytes)
+    /// * `twin_id` - The twin ID to map to the mycelium public key
+    ///
+    /// # Returns
+    /// * `Result<Hash, Error>` - The block hash on success
+    pub async fn set_mycelium_twin(
         &self,
         kp: &KeyPair,
-        twin_id: u32,
         mycelium_pk: Vec<u8>,
+        twin_id: u32,
     ) -> Result<Hash, Error> {
-        current::set_twin_mycelium_pk(self, kp, twin_id, mycelium_pk).await
+        current::set_mycelium_twin(self, kp, mycelium_pk, twin_id).await
     }
 
-    // Gets a twin by mycelium public key and returns the full twin object
-    pub async fn get_twin_by_mycelium_pk(
+    /// Gets the twin ID associated with a mycelium public key
+    ///
+    /// # Arguments
+    /// * `mycelium_pk` - The mycelium public key (as bytes)
+    ///
+    /// # Returns
+    /// * `Result<Option<u32>, Error>` - The twin ID if found, None otherwise
+    pub async fn get_mycelium_twin(
         &self,
         mycelium_pk: Vec<u8>,
-    ) -> Result<Option<Twin>, Error> {
-        // We pass a dummy keypair since it's not used in the implementation
-        let dummy_kp = KeyPair::Sr25519(sr25519::Pair::from_seed(&[0u8; 32]));
-        current::get_twin_by_mycelium_pk(self, &dummy_kp, mycelium_pk).await
+    ) -> Result<Option<u32>, Error> {
+        current::get_mycelium_twin(self, mycelium_pk).await
     }
 
     pub async fn get_farm_by_id(&self, id: u32) -> Result<Option<Farm>, Error> {

clients/tfchain-client-rs/src/runtimes/current.rs

@@ -202,47 +202,42 @@ pub async fn get_balance(
         .await?)
 }
 
-pub async fn set_twin_mycelium_pk(
+pub async fn set_mycelium_twin(
     cl: &Client,
     kp: &KeyPair,
-    twin_id: u32,
     mycelium_pk: Vec<u8>,
+    twin_id: u32,
 ) -> Result<H256, Error> {
-    let set_mycelium_pk_tx = current::tx().tfgrid_module().set_twin_mycelium_pk(
-        twin_id,
+    let set_mycelium_tx = current::tx().tfgrid_module().set_mycelium_twin(
         BoundedVec(mycelium_pk),
+        twin_id,
     );
 
     let signer = kp.signer();
 
-    let set_mycelium_pk = cl
+    let set_mycelium = cl
         .api
         .tx()
-        .sign_and_submit_then_watch_default(&set_mycelium_pk_tx, &signer)
+        .sign_and_submit_then_watch_default(&set_mycelium_tx, &signer)
         .await?
         .wait_for_finalized_success()
         .await?;
 
-    Ok(set_mycelium_pk.block_hash())
+    Ok(set_mycelium.block_hash())
 }
 
-pub async fn get_twin_by_mycelium_pk(
+pub async fn get_mycelium_twin(
     cl: &Client,
-    _kp: &KeyPair,
     mycelium_pk: Vec<u8>,
-) -> Result<Option<Twin>, Error> {
+) -> Result<Option<u32>, Error> {
     // Query the storage directly using the mycelium pk to get twin ID
     let twin_id = cl
         .api
         .storage()
         .at_latest()
         .await?
-        .fetch(&current::storage().tfgrid_module().twin_by_mycelium_pk(BoundedVec(mycelium_pk)))
+        .fetch(&current::storage().tfgrid_module().mycelium_twin(BoundedVec(mycelium_pk)))
         .await?;
 
-    if let Some(id) = twin_id {
-        get_twin_by_id(cl, id).await
-    } else {
-        Ok(None)
-    }
+    Ok(twin_id)
 }

substrate-node/pallets/pallet-tfgrid/src/benchmarking.rs

@@ -737,15 +737,15 @@ benchmarks! {
         assert_last_event::<T>(Event::NodeUptimeReported(node_id, now, uptime).into());
     }
 
-    // set_twin_mycelium_pk
-    set_twin_mycelium_pk {
+    // set_mycelium_twin
+    set_mycelium_twin {
         let caller: T::AccountId = whitelisted_caller();
         _create_twin::<T>(caller.clone());
-        let twin_id = 1;
         let mycelium_pk = get_mycelium_pk_input(b"some_mycelium_pk");
-    }: _(RawOrigin::Signed(caller), twin_id, mycelium_pk.clone())
+        let twin_id = 1;
+    }: _(RawOrigin::Signed(caller), mycelium_pk.clone(), twin_id)
     verify {
-        assert_eq!(TfgridModule::<T>::twin_by_mycelium_pk(&mycelium_pk), Some(twin_id));
+        assert_eq!(TfgridModule::<T>::get_mycelium_twin(&mycelium_pk), Some(twin_id));
     }
 
     // Calling the `impl_benchmark_test_suite` macro inside the `benchmarks`
@@ -1033,3 +1033,7 @@ pub(crate) fn get_pub_config_gw6_input(gw6_input: &[u8]) -> Gw6Input {
 pub(crate) fn get_pub_config_domain_input(domain_input: &[u8]) -> DomainInput {
     BoundedVec::try_from(domain_input.to_vec()).expect("Invalid domain input.")
 }
+
+pub(crate) fn get_mycelium_pk_input(mycelium_pk_input: &[u8]) -> MyceliumPkInput {
+    BoundedVec::try_from(mycelium_pk_input.to_vec()).expect("Invalid mycelium pk input.")
+}

substrate-node/pallets/pallet-tfgrid/src/lib.rs

@@ -266,8 +266,8 @@ pub mod pallet {
     >;
 
     #[pallet::storage]
-    #[pallet::getter(fn twin_by_mycelium_pk)]
-    pub type TwinByMyceliumPk<T: Config> = StorageMap<
+    #[pallet::getter(fn get_mycelium_twin)]
+    pub type MyceliumTwin<T: Config> = StorageMap<
         _,
         Blake2_128Concat,
         MyceliumPkInput, // key is mycelium pk
@@ -423,7 +423,7 @@ pub mod pallet {
         TwinEntityRemoved(u32, u32),
         TwinDeleted(u32),
         TwinAccountBounded(u32, T::AccountId),
-        TwinMyceliumPkSet(u32, MyceliumPkInput),
+        MyceliumTwinUpdated(MyceliumPkInput, u32),
 
         PricingPolicyStored(types::PricingPolicy<T::AccountId>),
         // CertificationCodeStored(types::CertificationCodes),
@@ -1253,25 +1253,14 @@ pub mod pallet {
         // #[pallet::weight(<T as Config>::WeightInfo::set_node_gpu_status())]
 
         #[pallet::call_index(40)]
-        #[pallet::weight(<T as Config>::WeightInfo::set_twin_mycelium_pk())]
-        pub fn set_twin_mycelium_pk(
+        #[pallet::weight(<T as Config>::WeightInfo::set_mycelium_twin())]
+        pub fn set_mycelium_twin(
             origin: OriginFor<T>,
-            twin_id: u32,
             mycelium_pk: MyceliumPkInput,
+            twin_id: u32,
         ) -> DispatchResultWithPostInfo {
             let account_id = ensure_signed(origin)?;
-
-            // Ensure the caller owns this twin
-            let twin = Twins::<T>::get(twin_id).ok_or(Error::<T>::TwinNotExists)?;
-            ensure!(twin.account_id == account_id, Error::<T>::UnauthorizedToUpdateTwin);
-
-            // Store the mapping
-            TwinByMyceliumPk::<T>::insert(&mycelium_pk, twin_id);
-
-            // Emit event that mycelium-twin mapping is updated
-            Self::deposit_event(Event::TwinMyceliumPkSet(twin_id, mycelium_pk));
-            
-            Ok(().into())
+            Self::_set_mycelium_twin(account_id, mycelium_pk, twin_id)
         }
     }
 }