Introduce the AssetId type

docs/reference/src/code/operations/asset_operations/src/lib.sw

@@ -25,7 +25,7 @@ use std::token::transfer_to_address;
 use std::token::force_transfer_to_contract;
 // ANCHOR_END: force_transfer_to_contract_import
 
-use std::constants::ZERO_B256;
+use std::constants::{BASE_ASSET_ID, ZERO_B256};
 
 fn minting() {
     // ANCHOR: mint
@@ -77,7 +77,7 @@ fn transferring_to_address() {
     // ANCHOR: transfer_to_address
     let amount = 10;
     let address = 0x0000000000000000000000000000000000000000000000000000000000000001;
-    let asset = ZERO_B256;
+    let asset = BASE_ASSET_ID;
     let user = Address::from(address);
 
     transfer_to_address(user, asset, amount);
@@ -88,7 +88,7 @@ fn transferring_to_contract() {
     // ANCHOR: force_transfer_to_contract
     let amount = 10;
     let address = 0x0000000000000000000000000000000000000000000000000000000000000001;
-    let asset = ZERO_B256;
+    let asset = BASE_ASSET_ID;
     let pool = ContractId::from(address);
 
     force_transfer_to_contract(pool, asset, amount);
@@ -99,7 +99,7 @@ fn transferring_to() {
     // ANCHOR: transfer
     let amount = 10;
     let address = 0x0000000000000000000000000000000000000000000000000000000000000001;
-    let asset = ZERO_B256;
+    let asset = BASE_ASSET_ID;
     let user = Identity::Address(Address::from(address));
     let pool = Identity::ContractId(ContractId::from(address));
 

examples/liquidity_pool/src/main.sw

@@ -19,7 +19,9 @@ abi LiquidityPool {
     fn withdraw(recipient: Address);
 }
 
-const BASE_TOKEN = 0x9ae5b658754e096e4d681c548daf46354495a437cc61492599e33fc64dcdc30c;
+const BASE_TOKEN: AssetId = AssetId {
+    value: 0x9ae5b658754e096e4d681c548daf46354495a437cc61492599e33fc64dcdc30c,
+};
 
 impl LiquidityPool for Contract {
     fn deposit(recipient: Address) {
@@ -34,7 +36,7 @@ impl LiquidityPool for Contract {
     }
 
     fn withdraw(recipient: Address) {
-        let asset_id = sha256((contract_id(), ZERO_B256));
+        let asset_id = AssetId::default(contract_id());
         assert(msg_asset_id() == asset_id);
         assert(msg_amount() > 0);
 

examples/native_token/src/main.sw

@@ -5,10 +5,10 @@ use std::{constants::ZERO_B256, context::*, token::*};
 abi NativeAssetToken {
     fn mint_coins(mint_amount: u64);
     fn burn_coins(burn_amount: u64);
-    fn force_transfer_coins(coins: u64, asset_id: b256, target: ContractId);
-    fn transfer_coins_to_output(coins: u64, asset_id: b256, recipient: Address);
+    fn force_transfer_coins(coins: u64, asset_id: AssetId, target: ContractId);
+    fn transfer_coins_to_output(coins: u64, asset_id: AssetId, recipient: Address);
     fn deposit();
-    fn get_balance(target: ContractId, asset_id: b256) -> u64;
+    fn get_balance(target: ContractId, asset_id: AssetId) -> u64;
     fn mint_and_send_to_contract(amount: u64, destination: ContractId);
     fn mint_and_send_to_address(amount: u64, recipient: Address);
 }
@@ -25,17 +25,17 @@ impl NativeAssetToken for Contract {
     }
 
     /// Transfer coins to a target contract.
-    fn force_transfer_coins(coins: u64, asset_id: b256, target: ContractId) {
+    fn force_transfer_coins(coins: u64, asset_id: AssetId, target: ContractId) {
         force_transfer_to_contract(target, asset_id, coins);
     }
 
     /// Transfer coins to a transaction output to be spent later.
-    fn transfer_coins_to_output(coins: u64, asset_id: b256, recipient: Address) {
+    fn transfer_coins_to_output(coins: u64, asset_id: AssetId, recipient: Address) {
         transfer_to_address(recipient, asset_id, coins);
     }
 
     /// Get the internal balance of a specific coin at a specific contract.
-    fn get_balance(target: ContractId, asset_id: b256) -> u64 {
+    fn get_balance(target: ContractId, asset_id: AssetId) -> u64 {
         balance_of(target, asset_id)
     }
 

sway-lib-std/src/address.sw

@@ -1,8 +1,9 @@
 //! A wrapper around the `b256` type to help enhance type-safety.
 library;
 
-use ::alias::{AssetId, SubId};
+use ::alias::SubId;
 use ::call_frames::contract_id;
+use ::contract_id::AssetId;
 use ::convert::From;
 use ::hash::*;
 use ::error_signals::FAILED_TRANSFER_TO_ADDRESS_SIGNAL;
@@ -105,7 +106,7 @@ impl Address {
         while index < number_of_outputs {
             if let Output::Variable = output_type(index) {
                 if output_amount(index) == 0 {
-                    asm(r1: self.value, r2: index, r3: amount, r4: asset_id) {
+                    asm(r1: self.value, r2: index, r3: amount, r4: asset_id.value) {
                         tro r1 r2 r3 r4;
                     };
                     return;
@@ -141,7 +142,7 @@ impl Address {
         asm(r1: amount, r2: sub_id) {
             mint r1 r2;
         };
-        self.transfer(sha256((contract_id(), sub_id)), amount);
+        self.transfer(AssetId::new(contract_id(), sub_id), amount);
     }
 }
 

sway-lib-std/src/alias.sw

@@ -1,6 +1,4 @@
 library;
 
-/// The `AssetId` type is simply an alias for `b256` that represents the ID of a native asset.
-pub type AssetId = b256;
 /// The `SubId` type is simply an alias for `b256` that represents the sub identifier of a native asset.
 pub type SubId = b256;

sway-lib-std/src/call_frames.sw

@@ -2,10 +2,9 @@
 //! [Call frames](https://fuellabs.github.io/fuel-specs/master/vm#call-frames) store metadata across untrusted inter-contract calls.
 library;
 
-use ::alias::AssetId;
-use ::registers::frame_ptr;
-use ::contract_id::ContractId;
+use ::contract_id::{AssetId, ContractId};
 use ::intrinsics::is_reference_type;
+use ::registers::frame_ptr;
 
 // Note that everything when serialized is padded to word length.
 //
@@ -63,9 +62,13 @@ pub fn contract_id() -> ContractId {
 /// }
 /// ```
 pub fn msg_asset_id() -> AssetId {
-    asm(asset_id) {
-        addi asset_id fp i32;
-        asset_id: b256
+    AssetId { 
+        value: { 
+            asm(asset_id) {
+                addi asset_id fp i32;
+                asset_id: b256
+            }
+        }
     }
 }
 

sway-lib-std/src/constants.sw

@@ -1,7 +1,7 @@
 //! Base asset and zero address constants.
 library;
 
-use ::contract_id::ContractId;
+use ::contract_id::AssetId;
 
 /// The `BASE_ASSET_ID` represents the base asset of a chain.
 ///
@@ -18,7 +18,7 @@ use ::contract_id::ContractId;
 ///     assert(BASE_ASSET_ID == msg_asset_id());
 /// }
 /// ```
-pub const BASE_ASSET_ID = ZERO_B256;
+pub const BASE_ASSET_ID: AssetId = AssetId::from(ZERO_B256);
 
 /// A B256 of zero value.
 ///

sway-lib-std/src/context.sw

@@ -1,9 +1,8 @@
 //! Functionality for accessing context-specific information about the current contract or message.
 library;
 
-use ::alias::AssetId;
-use ::contract_id::ContractId;
 use ::call_frames::contract_id;
+use ::contract_id::{AssetId, ContractId};
 use ::registers::balance;
 
 /// Get the balance of coin `asset_id` for the current contract.
@@ -52,7 +51,7 @@ pub fn this_balance(asset_id: AssetId) -> u64 {
 /// }
 /// ```
 pub fn balance_of(target: ContractId, asset_id: AssetId) -> u64 {
-    asm(balance, token: asset_id, id: target.value) {
+    asm(balance, token: asset_id.value, id: target.value) {
         bal balance token id;
         balance: u64
     }