feat: Update SRC20 example to reflect emitted events

examples/predicate/src/main.sw

@@ -21,7 +21,7 @@ configurable {
 }
 
 fn input_output_checks() -> bool {
-    if (100 >= input_amount(0).unwrap() && 100 >= output_amount(0)) {
+    if (100 >= input_amount(0).unwrap() && 100 >= output_amount(0).unwrap()) {
         return true
     }
     return false

examples/predicate_multisig/src/main.sw

@@ -31,7 +31,7 @@ fn verify_signature(i: u64) -> u64 {
     let mut j = 0;
 
     while j < 3 {
-        let current_signature = tx_witness_data::<B512>(j);
+        let current_signature = tx_witness_data::<B512>(j).unwrap();
 
         let current_address = ec_recover_address(current_signature, tx_hash).unwrap();
 

examples/src20/Forc.lock

@@ -1,6 +1,6 @@
 [[package]]
 name = "core"
-source = "path+from-root-2AB5BCE55EAAEFF4"
+source = "path+from-root-EF1196EF955CE54B"
 
 [[package]]
 name = "src20"
@@ -12,10 +12,10 @@ dependencies = [
 
 [[package]]
 name = "standards"
-source = "git+https://github.com/FuelLabs/sway-standards?tag=v0.5.2#270350e69bd7455b7e99f0aae2e29a94d42324bd"
+source = "git+https://github.com/FuelLabs/sway-standards?tag=v0.6.0#65e09f95ea8b9476b171a66c8a47108f352fa32c"
 dependencies = ["std"]
 
 [[package]]
 name = "std"
-source = "git+https://github.com/fuellabs/sway?tag=v0.62.0#efda0397c7bee77de73bd726ec0b732d57614973"
+source = "git+https://github.com/fuellabs/sway?tag=v0.63.3#f55c81cce61aac31913ac0e87306cbaed7da679a"
 dependencies = ["core"]

examples/src20/Forc.toml

@@ -5,4 +5,4 @@ license = "Apache-2.0"
 name = "src20"
 
 [dependencies]
-standards = { git = "https://github.com/FuelLabs/sway-standards", tag = "v0.5.2" }
+standards = { git = "https://github.com/FuelLabs/sway-standards", tag = "v0.6.0" }

examples/src20/src/main.sw

@@ -1,7 +1,7 @@
 contract;
 
-use standards::src20::SRC20;
-use std::string::String;
+use standards::src20::{SetDecimalsEvent, SetNameEvent, SetSymbolEvent, SRC20, TotalSupplyEvent,};
+use std::{auth::msg_sender, string::String};
 
 configurable {
     /// The total supply of coins for the asset minted by this contract.
@@ -164,4 +164,40 @@ impl SRC20 for Contract {
             None
         }
     }
+}
+
+abi EmitSRC20Events {
+    fn emit_src20_events();
+}
+
+impl EmitSRC20Events for Contract {
+    fn emit_src20_events() {
+        // Metadata that is stored as a configurable should only be emitted once.
+        let asset = AssetId::default();
+        let sender = msg_sender().unwrap();
+
+        log(SetNameEvent {
+            asset,
+            name: Some(String::from_ascii_str(from_str_array(NAME))),
+            sender,
+        });
+
+        log(SetSymbolEvent {
+            asset,
+            symbol: Some(String::from_ascii_str(from_str_array(SYMBOL))),
+            sender,
+        });
+
+        log(SetDecimalsEvent {
+            asset,
+            decimals: DECIMALS,
+            sender,
+        });
+
+        log(TotalSupplyEvent {
+            asset,
+            supply: TOTAL_SUPPLY,
+            sender,
+        });
+    }
 }

examples/verify_signature/src/main.sw

@@ -7,35 +7,35 @@ use std::b512::B512;
 use std::constants::ZERO_B256;
 
 abi VerifySignature {
-    fn get_message_hash(_to: b256, _amount: u64, _message: str, _nonce: u64) -> b256;
-    fn get_eth_signed_message_hash(_message_hash: b256) -> b256;
-    fn recover_signer(_eth_signed_message_hash: b256, _signature: B512) -> b256;
-    fn verify(_signer: b256, _to: b256, _amount: u64, _message: str, _nonce: u64, _signature: B512) -> bool;
+    fn GetMessageHash(to: b256, amount: u64, message: str, nonce: u64) -> b256;
+    fn GetEthSignedMessageHash(message_hash: b256) -> b256;
+    fn RecoverSigner(eth_signed_message_hash: b256, signature: B512) -> b256;
+    fn verify(signer: b256, to: b256, amount: u64, message: str, nonce: u64, signature: B512) -> bool;
 
 }
 
-fn get_message_hash(_to: b256, _amount: u64, _message: str, _nonce: u64) -> b256 {
+fn GetMessageHash(to: b256, amount: u64, message: str, nonce: u64) -> b256 {
         keccak256({
         let mut bytes = Bytes::new();
-        bytes.append(Bytes::from(core::codec::encode(_to)));
-        bytes.append(Bytes::from(core::codec::encode(_amount)));
-        bytes.append(Bytes::from(core::codec::encode(_message)));
-        bytes.append(Bytes::from(core::codec::encode(_nonce)));
+        bytes.append(Bytes::from(core::codec::encode(to)));
+        bytes.append(Bytes::from(core::codec::encode(amount)));
+        bytes.append(Bytes::from(core::codec::encode(message)));
+        bytes.append(Bytes::from(core::codec::encode(nonce)));
         bytes
     })
     }
 
-    fn get_eth_signed_message_hash(_message_hash: b256) -> b256 {
+    fn GetEthSignedMessageHash(message_hash: b256) -> b256 {
         keccak256({
         let mut bytes = Bytes::new();
         bytes.append(Bytes::from(core::codec::encode("\x19Fuel Signed Message:\n32")));
-        bytes.append(Bytes::from(core::codec::encode(_message_hash)));
+        bytes.append(Bytes::from(core::codec::encode(message_hash)));
         bytes
     })
     }
 
-    fn recover_signer(_eth_signed_message_hash: b256, _signature: B512) -> b256 {
-        match ec_recover_address(_signature, _eth_signed_message_hash) {
+    fn RecoverSigner(eth_signed_message_hash: b256, signature: B512) -> b256 {
+        match ec_recover_address(signature, eth_signed_message_hash) {
             Ok(address) => address.bits(),
             Err(_) => ZERO_B256,
         }
@@ -44,22 +44,22 @@ fn get_message_hash(_to: b256, _amount: u64, _message: str, _nonce: u64) -> b256
 impl VerifySignature for Contract {
 
 
-    fn get_message_hash(_to: b256, _amount: u64, _message: str, _nonce: u64) -> b256{
-        ::get_message_hash(_to, _amount, _message, _nonce)
+    fn GetMessageHash(to: b256, amount: u64, message: str, nonce: u64) -> b256{
+        ::GetMessageHash(to, amount, message, nonce)
     }
 
-    fn get_eth_signed_message_hash(_message_hash: b256) -> b256 {
-        ::get_eth_signed_message_hash(_message_hash)
+    fn GetEthSignedMessageHash(message_hash: b256) -> b256 {
+        ::GetEthSignedMessageHash(message_hash)
     }
 
-    fn recover_signer(_eth_signed_message_hash: b256, _signature: B512) -> b256{
-        ::recover_signer(_eth_signed_message_hash, _signature)
+    fn RecoverSigner(eth_signed_message_hash: b256, signature: B512) -> b256{
+        ::RecoverSigner(eth_signed_message_hash, signature)
     }
 
-   fn verify(_signer: b256, _to: b256, _amount: u64, _message: str, _nonce: u64, _signature: B512) -> bool {   
-        let message_hash = get_message_hash(_to, _amount, _message, _nonce);
-        let eth_signed_message_hash = get_eth_signed_message_hash(message_hash);
-        let recovered_signer = recover_signer(eth_signed_message_hash, _signature);
-        recovered_signer == _signer
+   fn verify(signer: b256, to: b256, amount: u64, message: str, nonce: u64, signature: B512) -> bool {   
+        let MessageHash = GetMessageHash(to, amount, message, nonce);
+        let EthSignedMessage = GetEthSignedMessageHash(MessageHash);
+        let RecoverSigner = RecoverSigner(EthSignedMessage, signature);
+        RecoverSigner == signer
     }
 }