rust: rename asset_tag to asset_id

Per the previous commit asset_tag is unused for single sig.

Author: jgriffiths

subprojects/gdk_rust/gdk_common/src/model.rs

@@ -90,7 +90,7 @@ impl ExchangeRateOk {
 pub struct AddressAmount {
     pub address: String, // could be bitcoin or elements
     pub satoshi: u64,
-    pub asset_tag: Option<String>,
+    pub asset_id: Option<String>,
 }
 
 #[derive(Serialize, Deserialize, Debug, Clone, Default)]
@@ -422,8 +422,8 @@ impl Default for Settings {
 
 impl AddressAmount {
     pub fn asset(&self) -> Option<AssetId> {
-        if let Some(asset_tag) = self.asset_tag.as_ref() {
-            let vec = hex::decode(asset_tag).ok();
+        if let Some(asset_id) = self.asset_id.as_ref() {
+            let vec = hex::decode(asset_id).ok();
             if let Some(mut vec) = vec {
                 vec.reverse();
                 return (&vec[..]).try_into().ok();

subprojects/gdk_rust/gdk_electrum/src/account.rs

@@ -189,7 +189,7 @@ impl Account {
                     addressees.push(AddressAmount {
                         address: address.unwrap_or_else(|| "".to_string()),
                         satoshi: 0, // apparently not needed in list_tx addressees
-                        asset_tag: None,
+                        asset_id: None,
                     });
                 }
             }
@@ -731,7 +731,7 @@ pub fn create_tx(
 
     let network = &account.network;
 
-    // TODO put checks into CreateTransaction::validate, add check asset_tag are valid asset hex
+    // TODO put checks into CreateTransaction::validate, add check asset_id are valid asset hex
     // eagerly check for address validity
     for address in request.addressees.iter().map(|a| &a.address) {
         match network.id() {
@@ -793,7 +793,7 @@ pub fn create_tx(
                 match network.id() {
                     NetworkId::Bitcoin(_) => return Err(Error::InvalidAmount),
                     NetworkId::Elements(_) => {
-                        if address_amount.asset_tag == network.policy_asset {
+                        if address_amount.asset_id == network.policy_asset {
                             // we apply dust rules for liquid bitcoin as elements do
                             return Err(Error::InvalidAmount);
                         }
@@ -804,7 +804,7 @@ pub fn create_tx(
     }
 
     if let NetworkId::Elements(_) = network.id() {
-        if request.addressees.iter().any(|a| a.asset_tag.is_none()) {
+        if request.addressees.iter().any(|a| a.asset_id.is_none()) {
             return Err(Error::AssetEmpty);
         }
     }
@@ -833,7 +833,7 @@ pub fn create_tx(
         if request.addressees.len() != 1 {
             return Err(Error::SendAll);
         }
-        let asset = request.addressees[0].asset_tag.as_deref().unwrap_or("btc");
+        let asset = request.addressees[0].asset_id.as_deref().unwrap_or("btc");
         let all_utxos: Vec<&(BEOutPoint, UTXOInfo)> =
             utxos.iter().filter(|(_, i)| i.asset == asset).collect();
         let total_amount_utxos: u64 = all_utxos.iter().map(|(_, i)| i.value).sum();
@@ -845,7 +845,7 @@ pub fn create_tx(
             }
             let out = &request.addressees[0]; // safe because we checked we have exactly one recipient
             dummy_tx
-                .add_output(&out.address, out.satoshi, out.asset_tag.clone())
+                .add_output(&out.address, out.satoshi, out.asset_id.clone())
                 .map_err(|_| Error::InvalidAddress)?;
             // estimating 2 satoshi more as estimating less would later result in InsufficientFunds
             let estimated_fee = dummy_tx.estimated_fee(fee_rate, 0, account.script_type) + 2;
@@ -867,7 +867,7 @@ pub fn create_tx(
 
     // STEP 1) add the outputs requested for this transactions
     for out in request.addressees.iter() {
-        tx.add_output(&out.address, out.satoshi, out.asset_tag.clone())
+        tx.add_output(&out.address, out.satoshi, out.asset_id.clone())
             .map_err(|_| Error::InvalidAddress)?;
     }
 

subprojects/gdk_rust/gdk_electrum/src/error.rs

@@ -54,7 +54,7 @@ impl Display for Error {
             Error::InvalidAmount => write!(f, "invalid amount"),
             Error::InvalidHeaders => write!(f, "invalid headers"),
             Error::EmptyAddressees => write!(f, "addressees cannot be empty"),
-            Error::AssetEmpty => write!(f, "asset_tag cannot be empty in liquid"),
+            Error::AssetEmpty => write!(f, "asset_id cannot be empty in liquid"),
             Error::InvalidSubaccount(sub) => write!(f, "invalid subaccount {}", sub),
             Error::AccountGapsDisallowed => {
                 write!(f, "cannot create a new subaccount while the last one is unused")

subprojects/gdk_rust/tests/integration.rs

@@ -82,7 +82,7 @@ fn liquid() {
     test_session.send_tx(&node_address, 10_000, Some(assets[0].clone()), None, None, None);
     test_session.send_tx(&node_address, 100, Some(assets[0].clone()), None, None, None); // asset should send below dust limit
     test_session.send_all(&node_address, Some(assets[0].to_string()));
-    test_session.send_all(&node_address, test_session.asset_tag());
+    test_session.send_all(&node_address, test_session.asset_id());
     test_session.mine_block();
     let assets = test_session.fund(100_000_000, Some(3));
     test_session.send_multi(3, 100_000, &vec![]);
@@ -336,7 +336,7 @@ fn labels() {
     create_opt.addressees.push(AddressAmount {
         address: test_session.get_receive_address(account2.account_num).address,
         satoshi: 50000,
-        asset_tag: None,
+        asset_id: None,
     });
     create_opt.memo = Some("Foo, Bar Foo".into());
     let tx = test_session.session.create_transaction(&mut create_opt).unwrap();

subprojects/gdk_rust/tests/test_session.rs

@@ -352,14 +352,14 @@ impl TestSession {
     }
 
     /// send all of the balance of the  tx from the gdk session to the specified address
-    pub fn send_all(&mut self, address: &str, asset_tag: Option<String>) {
-        self.send_all_from_account(0, address, asset_tag);
+    pub fn send_all(&mut self, address: &str, asset_id: Option<String>) {
+        self.send_all_from_account(0, address, asset_id);
     }
     pub fn send_all_from_account(
         &mut self,
         subaccount: u32,
         address: &str,
-        asset_tag: Option<String>,
+        asset_id: Option<String>,
     ) -> String {
         //let init_sat = self.balance_gdk();
         //let init_sat_addr = self.balance_addr(address);
@@ -370,7 +370,7 @@ impl TestSession {
         create_opt.addressees.push(AddressAmount {
             address: address.to_string(),
             satoshi: 0,
-            asset_tag: asset_tag.clone(),
+            asset_id: asset_id.clone(),
         });
         create_opt.send_all = Some(true);
         let tx = self.session.create_transaction(&mut create_opt).unwrap();
@@ -381,7 +381,7 @@ impl TestSession {
         self.wait_account_tx(subaccount, &txid);
         //let end_sat_addr = self.balance_addr(address);
         //assert_eq!(init_sat_addr + init_sat - tx.fee, end_sat_addr);
-        assert_eq!(self.balance_account(subaccount, asset_tag, None), 0);
+        assert_eq!(self.balance_account(subaccount, asset_id, None), 0);
 
         assert!(tx.create_transaction.unwrap().send_all.unwrap());
         assert!(signed_tx.create_transaction.unwrap().send_all.unwrap());
@@ -409,7 +409,7 @@ impl TestSession {
         create_opt.addressees.push(AddressAmount {
             address: address.to_string(),
             satoshi,
-            asset_tag: asset.clone().or(self.asset_tag()),
+            asset_id: asset.clone().or(self.asset_id()),
         });
         create_opt.memo = memo;
         create_opt.utxos = unspent_outputs;
@@ -478,7 +478,7 @@ impl TestSession {
         create_opt.addressees.push(AddressAmount {
             address: address.to_string(),
             satoshi,
-            asset_tag: asset.clone().or(self.asset_tag()),
+            asset_id: asset.clone().or(self.asset_id()),
         });
         let tx = self.session.create_transaction(&mut create_opt).unwrap();
         let signed_tx = self.session.sign_transaction(&tx).unwrap();
@@ -551,7 +551,7 @@ impl TestSession {
     }
 
     /// send a tx with multiple recipients with same amount from the gdk session to generated
-    /// node's addressees, if `assets` contains values, they are used as asset_tag cyclically
+    /// node's addressees, if `assets` contains values, they are used as asset_id cyclically
     pub fn send_multi(&mut self, recipients: u8, amount: u64, assets: &Vec<String>) {
         let init_sat = self.balance_gdk(None);
         let init_assets_sat = self.balance_gdk_all();
@@ -563,8 +563,8 @@ impl TestSession {
         let mut tags = vec![];
         for _ in 0..recipients {
             let address = self.node_getnewaddress(None);
-            let asset_tag = if assets.is_empty() {
-                self.asset_tag()
+            let asset_id = if assets.is_empty() {
+                self.asset_id()
             } else {
                 let current = assets_cycle.next().unwrap().to_string();
                 tags.push(current.clone());
@@ -574,7 +574,7 @@ impl TestSession {
             create_opt.addressees.push(AddressAmount {
                 address: address.to_string(),
                 satoshi: amount,
-                asset_tag,
+                asset_id,
             });
             addressees.push(address);
         }
@@ -656,7 +656,7 @@ impl TestSession {
         create_opt.addressees.push(AddressAmount {
             address: node_address.to_string(),
             satoshi: init_sat, // not enough to pay the fee with confidential utxos only
-            asset_tag: self.asset_tag(),
+            asset_id: self.asset_id(),
         });
         create_opt.confidential_utxos_only = Some(true);
         assert!(matches!(
@@ -708,7 +708,7 @@ impl TestSession {
         create_opt.addressees.push(AddressAmount {
             address: address.to_string(),
             satoshi,
-            asset_tag: self.asset_tag(),
+            asset_id: self.asset_id(),
         });
         let tx = self.session.create_transaction(&mut create_opt).unwrap();
         let signed_tx = self.session.sign_transaction(&tx).unwrap();
@@ -731,7 +731,7 @@ impl TestSession {
         create_opt.addressees.push(AddressAmount {
             address: address.to_string(),
             satoshi: 0,
-            asset_tag: self.asset_tag(),
+            asset_id: self.asset_id(),
         });
         assert!(matches!(
             self.session.create_transaction(&mut create_opt),
@@ -975,7 +975,7 @@ impl TestSession {
         Amount::from_btc(balance_btc).unwrap().as_sat()
     }
 
-    pub fn asset_tag(&self) -> Option<String> {
+    pub fn asset_id(&self) -> Option<String> {
         match self.network_id {
             NetworkId::Bitcoin(_) => None,
             NetworkId::Elements(_) => self.network.policy_asset.clone(),