rename *Dapp type hierarchy to *Eip12;

Author: greenhat

bindings/ergo-lib-wasm/src/ergo_box.rs

@@ -24,7 +24,7 @@ use wasm_bindgen::prelude::*;
 
 use crate::ast::Constant;
 use crate::ergo_tree::ErgoTree;
-use crate::json::ErgoBoxJsonDapp;
+use crate::json::ErgoBoxJsonEip12;
 use crate::token::Tokens;
 use crate::utils::I64;
 use crate::{contract::Contract, transaction::TxId};
@@ -173,7 +173,7 @@ impl ErgoBox {
     /// JSON representation according to EIP-12 https://github.com/ergoplatform/eips/pull/23
     /// (similar to [`Self::to_json`], but with box value and token amount encoding as strings)
     pub fn to_js_eip12(&self) -> Result<JsValue, JsValue> {
-        let box_dapp: ErgoBoxJsonDapp = self.0.clone().into();
+        let box_dapp: ErgoBoxJsonEip12 = self.0.clone().into();
         JsValue::from_serde(&box_dapp).map_err(|e| JsValue::from_str(&format!("{}", e)))
     }
 

bindings/ergo-lib-wasm/src/json.rs

@@ -1,4 +1,4 @@
-//! JSON serialization using strings for BoxValue and TokenAmount
+//! JSON serialization according to EIP-12 (using strings for BoxValue and TokenAmount)
 
 use derive_more::FromStr;
 use ergo_lib::chain::ergo_box::BoxId;
@@ -17,7 +17,7 @@ use ergo_lib::ergotree_ir::ergo_tree::ErgoTree;
 use serde::Serialize;
 
 #[derive(Serialize, PartialEq, Debug, Clone)]
-pub(crate) struct TransactionJsonDapp {
+pub(crate) struct TransactionJsonEip12 {
     #[cfg_attr(feature = "json", serde(rename = "id"))]
     pub tx_id: TxId,
     /// inputs, that will be spent by this transaction.
@@ -29,12 +29,12 @@ pub(crate) struct TransactionJsonDapp {
     #[cfg_attr(feature = "json", serde(rename = "dataInputs"))]
     pub data_inputs: Vec<DataInput>,
     #[cfg_attr(feature = "json", serde(rename = "outputs"))]
-    pub outputs: Vec<ErgoBoxJsonDapp>,
+    pub outputs: Vec<ErgoBoxJsonEip12>,
 }
 
-impl From<Transaction> for TransactionJsonDapp {
+impl From<Transaction> for TransactionJsonEip12 {
     fn from(t: Transaction) -> Self {
-        TransactionJsonDapp {
+        TransactionJsonEip12 {
             tx_id: t.id(),
             inputs: t.inputs,
             data_inputs: t.data_inputs,
@@ -44,7 +44,7 @@ impl From<Transaction> for TransactionJsonDapp {
 }
 
 #[derive(Serialize, PartialEq, Debug, Clone)]
-pub(crate) struct UnsignedTransactionJsonDapp {
+pub(crate) struct UnsignedTransactionJsonEip12 {
     /// unsigned inputs, that will be spent by this transaction.
     #[cfg_attr(feature = "json", serde(rename = "inputs"))]
     pub inputs: Vec<UnsignedInput>,
@@ -55,28 +55,28 @@ pub(crate) struct UnsignedTransactionJsonDapp {
     pub data_inputs: Vec<DataInput>,
     /// box candidates to be created by this transaction
     #[cfg_attr(feature = "json", serde(rename = "outputs"))]
-    pub outputs: Vec<ErgoBoxCandidateJsonDapp>,
+    pub outputs: Vec<ErgoBoxCandidateJsonEip12>,
 }
 
-impl From<UnsignedTransaction> for UnsignedTransactionJsonDapp {
+impl From<UnsignedTransaction> for UnsignedTransactionJsonEip12 {
     fn from(_: UnsignedTransaction) -> Self {
         todo!()
     }
 }
 
 #[derive(Serialize, PartialEq, Eq, Debug, Clone)]
-pub(crate) struct ErgoBoxJsonDapp {
+pub(crate) struct ErgoBoxJsonEip12 {
     #[serde(rename = "boxId", alias = "id")]
     pub box_id: Option<BoxId>,
     /// amount of money associated with the box
     #[serde(rename = "value")]
-    pub value: BoxValueJsonDapp,
+    pub value: BoxValueJsonEip12,
     /// guarding script, which should be evaluated to true in order to open this box
     #[serde(rename = "ergoTree", with = "ergo_lib::chain::json::ergo_tree")]
     pub ergo_tree: ErgoTree,
     /// secondary tokens the box contains
     #[serde(rename = "assets")]
-    pub tokens: Vec<TokenJsonDapp>,
+    pub tokens: Vec<TokenJsonEip12>,
     ///  additional registers the box can carry over
     #[serde(rename = "additionalRegisters")]
     pub additional_registers: NonMandatoryRegisters,
@@ -93,9 +93,9 @@ pub(crate) struct ErgoBoxJsonDapp {
     pub index: u16,
 }
 
-impl From<ErgoBox> for ErgoBoxJsonDapp {
+impl From<ErgoBox> for ErgoBoxJsonEip12 {
     fn from(b: ErgoBox) -> Self {
-        ErgoBoxJsonDapp {
+        ErgoBoxJsonEip12 {
             box_id: b.box_id().into(),
             value: b.value.into(),
             ergo_tree: b.ergo_tree,
@@ -112,15 +112,15 @@ impl From<ErgoBox> for ErgoBoxJsonDapp {
 /// that will be calculated after full transaction formation.
 /// Use [`box_builder::ErgoBoxCandidateBuilder`] to create an instance.
 #[derive(Serialize, PartialEq, Eq, Clone, Debug)]
-pub(crate) struct ErgoBoxCandidateJsonDapp {
+pub(crate) struct ErgoBoxCandidateJsonEip12 {
     /// amount of money associated with the box
     #[serde(rename = "value")]
-    pub value: BoxValueJsonDapp,
+    pub value: BoxValueJsonEip12,
     /// guarding script, which should be evaluated to true in order to open this box
     #[serde(rename = "ergoTree", with = "ergo_lib::chain::json::ergo_tree")]
     pub ergo_tree: ErgoTree,
     #[serde(rename = "assets")]
-    pub tokens: Vec<TokenJsonDapp>,
+    pub tokens: Vec<TokenJsonEip12>,
     ///  additional registers the box can carry over
     #[serde(rename = "additionalRegisters")]
     pub additional_registers: NonMandatoryRegisters,
@@ -136,38 +136,38 @@ pub(crate) struct ErgoBoxCandidateJsonDapp {
     serde::Serialize, serde::Deserialize, PartialEq, Eq, Hash, Debug, Clone, Copy, FromStr,
 )]
 /// Box value in nanoERGs with bound checks
-pub(crate) struct BoxValueJsonDapp(#[serde_as(as = "serde_with::DisplayFromStr")] u64);
+pub(crate) struct BoxValueJsonEip12(#[serde_as(as = "serde_with::DisplayFromStr")] u64);
 
-impl From<BoxValue> for BoxValueJsonDapp {
+impl From<BoxValue> for BoxValueJsonEip12 {
     fn from(bv: BoxValue) -> Self {
-        BoxValueJsonDapp(*bv.as_u64())
+        BoxValueJsonEip12(*bv.as_u64())
     }
 }
 
 /// Token represented with token id paired with it's amount
 #[derive(Serialize, PartialEq, Eq, Debug, Clone)]
-pub struct TokenJsonDapp {
+pub struct TokenJsonEip12 {
     /// token id
     #[serde(rename = "tokenId")]
     pub token_id: TokenId,
     /// token amount
     #[serde(rename = "amount")]
-    pub amount: TokenAmountJsonDapp,
+    pub amount: TokenAmountJsonEip12,
 }
 
-impl From<Token> for TokenJsonDapp {
+impl From<Token> for TokenJsonEip12 {
     fn from(t: Token) -> Self {
-        TokenJsonDapp {
+        TokenJsonEip12 {
             token_id: t.token_id,
-            amount: TokenAmountJsonDapp(t.amount.as_u64()),
+            amount: TokenAmountJsonEip12(t.amount.as_u64()),
         }
     }
 }
 
 /// Token amount with bound checks
 #[serde_with::serde_as]
 #[derive(Serialize, PartialEq, Eq, Hash, Debug, Clone, Copy, PartialOrd, Ord)]
-pub struct TokenAmountJsonDapp(
+pub struct TokenAmountJsonEip12(
     // Encodes as string always
     #[serde_as(as = "serde_with::DisplayFromStr")] u64,
 );

bindings/ergo-lib-wasm/src/token.rs

@@ -8,7 +8,7 @@ use ergo_lib::chain::Digest32;
 use wasm_bindgen::prelude::*;
 
 use crate::ergo_box::BoxId;
-use crate::json::TokenJsonDapp;
+use crate::json::TokenJsonEip12;
 use crate::utils::I64;
 
 /// Token id (32 byte digest)
@@ -107,10 +107,10 @@ impl Token {
             .map_err(|e| JsValue::from_str(&format!("{}", e)))
     }
 
-    /// JSON representation (same as [`Self::to_json`],
-    /// but with box value and token amount encoding as strings)
-    pub fn to_json_dapp(&self) -> Result<JsValue, JsValue> {
-        let t_dapp: TokenJsonDapp = self.0.clone().into();
+    /// JSON representation according to EIP-12 https://github.com/ergoplatform/eips/pull/23
+    /// (similar to [`Self::to_json`], but with box value and token amount encoding as strings)
+    pub fn to_js_eip12(&self) -> Result<JsValue, JsValue> {
+        let t_dapp: TokenJsonEip12 = self.0.clone().into();
         JsValue::from_serde(&t_dapp).map_err(|e| JsValue::from_str(&format!("{}", e)))
     }
 }

bindings/ergo-lib-wasm/src/transaction.rs

@@ -4,8 +4,8 @@ use crate::box_coll::ErgoBoxCandidates;
 use crate::box_coll::ErgoBoxes;
 use crate::data_input::DataInputs;
 use crate::input::{Inputs, UnsignedInputs};
-use crate::json::TransactionJsonDapp;
-use crate::json::UnsignedTransactionJsonDapp;
+use crate::json::TransactionJsonEip12;
+use crate::json::UnsignedTransactionJsonEip12;
 use ergo_lib::chain;
 use std::convert::TryFrom;
 use std::convert::TryInto;
@@ -80,7 +80,7 @@ impl Transaction {
     /// JSON representation according to EIP-12 https://github.com/ergoplatform/eips/pull/23
     /// (similar to [`Self::to_json`], but with box value and token amount encoding as strings)
     pub fn to_js_eip12(&self) -> Result<JsValue, JsValue> {
-        let tx_dapp: TransactionJsonDapp = self.0.clone().into();
+        let tx_dapp: TransactionJsonEip12 = self.0.clone().into();
         JsValue::from_serde(&tx_dapp).map_err(|e| JsValue::from_str(&format!("{}", e)))
     }
 
@@ -155,7 +155,7 @@ impl UnsignedTransaction {
     /// JSON representation according to EIP-12 https://github.com/ergoplatform/eips/pull/23
     /// (similar to [`Self::to_json`], but with box value and token amount encoding as strings)
     pub fn to_js_eip12(&self) -> Result<JsValue, JsValue> {
-        let tx_dapp: UnsignedTransactionJsonDapp = self.0.clone().into();
+        let tx_dapp: UnsignedTransactionJsonEip12 = self.0.clone().into();
         JsValue::from_serde(&tx_dapp).map_err(|e| JsValue::from_str(&format!("{}", e)))
     }