Merge pull request #84 from mlabs-haskell/df/credential-improvements

Improve various aspects of credentials/hashes/assets

Author: rmgaray

addons/@mlabs-haskell/godot-cardano/src/address/address.gd

@@ -72,6 +72,10 @@ static func build(
 
 func payment_credential() -> Credential:
 	return Credential.new(_address.payment_credential())
-	
+## If the address contains staking credentials, return them.
+## Otherwise, return [code]null[/code].
 func stake_credential() -> Credential:
-	return Credential.new(_address.stake_credential())
+	var _cred = _address.stake_credential()
+	if _cred != null:
+		return Credential.new(_cred)
+	return null

addons/@mlabs-haskell/godot-cardano/src/address/credential.gd

@@ -6,8 +6,8 @@ class_name Credential
 var _credential: _Credential = null
 
 enum CredentialType {
-	PAYMENT = 0,
-	STAKE = 1,
+	KEY_HASH = 0,
+	SCRIPT_HASH = 1,
 }
 
 enum Status { SUCCESS = 0, INCORRECT_TYPE = 1 }

addons/@mlabs-haskell/godot-cardano/src/value/multi_asset.gd

@@ -57,6 +57,11 @@ func get_asset_quantity(asset: AssetClass) -> BigInt:
 		asset._asset_name._asset_name
 	))
 
+## Get a Dictionary mapping [class AssetName]s to [class BigInt]s under the 
+## given [param policy_id].
+func get_tokens(policy_id: PolicyId) -> Dictionary:
+	return _multi_asset._get_tokens(policy_id._policy_id)
+	
 ## Set the [param quantity] of the given [param asset].
 func set_asset_quantity(asset: AssetClass, quantity: BigInt) -> SetAssetResult:
 	return SetAssetResult.new(_multi_asset._set_asset_quantity(

addons/@mlabs-haskell/godot-cardano/src/value/policy_id.gd

@@ -3,13 +3,13 @@ class_name PolicyId
 
 ## An asset policy ID
 
-var _policy_id: _PolicyId
+var _policy_id: _ScriptHash
 
 enum Status { SUCCESS = 0, COULD_NOT_DECODE_HEX = 1 }
 
 ## WARNING: Do not use this constructor directly, use [method from_hex],
 ## [method from_script] or [method from_script_source] for safe building.
-func _init(policy_id: _PolicyId):
+func _init(policy_id: _ScriptHash):
 	_policy_id = policy_id
 
 class FromHexResult extends Result:
@@ -23,16 +23,16 @@ class FromHexResult extends Result:
 ## Try to parse a [PolicyId] from its minting policy's [param hash] encoded as
 ## hex.
 static func from_hex(hash: String) -> FromHexResult:
-	return FromHexResult.new(_PolicyId._from_hex(hash))
+	return FromHexResult.new(_ScriptHash._from_hex(hash))
 
 ## Obtain a [PolicyId] from the minting policy's [param script].
 static func from_script(script: PlutusScript) -> PolicyId:
-	var result = _PolicyId._from_hex(script.hash_as_hex())
+	var result = _ScriptHash._from_hex(script.hash_as_hex())
 	return new(result.unsafe_value())
 
 ## Obtain a [PolicyId] from the minting policy's [param script_source].
 static func from_script_source(script_source: PlutusScriptSource) -> PolicyId:
-	var result = _PolicyId._from_hex(script_source.hash().to_hex())
+	var result = _ScriptHash._from_hex(script_source.hash().to_hex())
 	return new(result.unsafe_value())
 
 ## Get the hex encoding of the minting policy's hash

libcsl_godot/src/ledger/transaction.rs

@@ -19,52 +19,7 @@ use godot::prelude::*;
 use crate::bigint::BigInt;
 use crate::gresult::{FailsWith, GResult};
 
-#[derive(GodotClass)]
-#[class(base=RefCounted, rename=_PolicyId)]
-pub struct PolicyId {
-    pub policy_id: CSL::PolicyID,
-}
-
-#[derive(Debug)]
-pub enum PolicyIdError {
-    CouldNotDecodeHex(String),
-}
-
-impl GodotConvert for PolicyIdError {
-    type Via = i64;
-}
-
-impl ToGodot for PolicyIdError {
-    fn to_godot(&self) -> Self::Via {
-        use PolicyIdError::*;
-        match self {
-            CouldNotDecodeHex(_) => 1,
-        }
-    }
-}
-
-impl FailsWith for PolicyId {
-    type E = PolicyIdError;
-}
-
-#[godot_api]
-impl PolicyId {
-    fn from_hex(policy_id: GString) -> Result<PolicyId, PolicyIdError> {
-        CSL::crypto::ScriptHash::from_hex(&policy_id.to_string())
-            .map_err(|_| PolicyIdError::CouldNotDecodeHex(policy_id.to_string()))
-            .map(|policy_id| Self { policy_id })
-    }
-
-    #[func]
-    fn _from_hex(policy_id: GString) -> Gd<GResult> {
-        Self::to_gresult_class(Self::from_hex(policy_id))
-    }
-
-    #[func]
-    fn to_hex(&self) -> GString {
-        self.policy_id.to_hex().into_godot()
-    }
-}
+pub type PolicyId = ScriptHash;
 
 #[derive(GodotClass)]
 #[class(base=RefCounted, rename=_AssetName)]
@@ -266,7 +221,7 @@ impl MultiAsset {
         quantity: Gd<BigInt>,
     ) -> Result<(), MultiAssetError> {
         self.assets.set_asset(
-            &policy_id.bind().policy_id,
+            &policy_id.bind().hash,
             &asset_name.bind().asset_name,
             BigNum::from_str(&quantity.bind().to_str())?,
         );
@@ -292,12 +247,35 @@ impl MultiAsset {
         Gd::from_object(
             BigInt::from_str(
                 self.assets
-                    .get_asset(&policy_id.bind().policy_id, &asset_name.bind().asset_name)
+                    .get_asset(&policy_id.bind().hash, &asset_name.bind().asset_name)
                     .to_str(),
             )
             .expect("Failed to convert asset quantity"),
         )
     }
+
+    #[func]
+    pub fn _get_tokens(&self, policy_id: Gd<PolicyId>) -> Dictionary {
+        let tokens = self.assets.get(&policy_id.bind().hash);
+        let mut dict = Dictionary::new();
+        match tokens {
+            Some(tokens_) => {
+                let asset_names = tokens_.keys();
+                for i in 0..asset_names.len() {
+                    let asset_name = asset_names.get(i);
+                    let quantity = match tokens_.get(&asset_name) {
+                        Some(quantity) => {
+                            Gd::from_object(BigInt::from_str(quantity.to_str()).unwrap())
+                        }
+                        None => BigInt::zero(),
+                    };
+                    dict.insert(asset_name.to_hex(), quantity);
+                }
+            }
+            None => {}
+        }
+        dict
+    }
 }
 
 #[derive(GodotClass)]
@@ -367,8 +345,8 @@ pub struct Credential {
 
 #[derive(Debug)]
 pub enum CredentialType {
-    Payment,
-    Stake,
+    KeyHash,
+    ScriptHash,
 }
 
 impl GodotConvert for CredentialType {
@@ -379,8 +357,8 @@ impl ToGodot for CredentialType {
     fn to_godot(&self) -> Self::Via {
         use CredentialType::*;
         match self {
-            Payment => 0,
-            Stake => 1,
+            KeyHash => 0,
+            ScriptHash => 1,
         }
     }
 }
@@ -389,8 +367,8 @@ impl FromGodot for CredentialType {
     fn try_from_godot(v: Self::Via) -> Result<Self, ConvertError> {
         use CredentialType::*;
         match v {
-            0 => Ok(Payment),
-            1 => Ok(Stake),
+            0 => Ok(KeyHash),
+            1 => Ok(ScriptHash),
             _ => Err(ConvertError::new()),
         }
     }
@@ -436,7 +414,10 @@ impl Credential {
 
     #[func]
     fn get_type(&self) -> CredentialType {
-        CredentialType::Payment
+        match self.credential.kind() {
+            CSL::address::StakeCredKind::Key => CredentialType::KeyHash,
+            CSL::address::StakeCredKind::Script => CredentialType::ScriptHash,
+        }
     }
 
     #[func]
@@ -461,23 +442,22 @@ impl Credential {
 
     #[func]
     fn to_bytes(&self) -> PackedByteArray {
-        let bytes = self
-            .credential
-            .to_keyhash()
-            .ok_or_else(|| self.credential.to_scripthash().map(|x| x.to_bytes()))
-            .map(|x| x.to_bytes())
-            .unwrap();
-        PackedByteArray::from(bytes.as_slice())
+        PackedByteArray::from(
+            match self.get_type() {
+                CredentialType::KeyHash => self.credential.to_keyhash().unwrap().to_bytes(),
+                CredentialType::ScriptHash => self.credential.to_scripthash().unwrap().to_bytes(),
+            }
+            .as_slice(),
+        )
     }
 
     #[func]
     fn to_hex(&self) -> GString {
-        self.credential
-            .to_keyhash()
-            .ok_or_else(|| self.credential.to_scripthash().map(|x| x.to_hex()))
-            .map(|x| x.to_hex())
-            .unwrap()
-            .into_godot()
+        match self.get_type() {
+            CredentialType::KeyHash => self.credential.to_keyhash().unwrap().to_hex(),
+            CredentialType::ScriptHash => self.credential.to_scripthash().unwrap().to_hex(),
+        }
+        .to_godot()
     }
 }