show David

Author: Daanvdplas

integration-tests/contracts/assets/Cargo.toml

@@ -6,7 +6,7 @@ version = "0.1.0"
 
 # ink! abi required for multiple constructors (fungibles)
 [package.metadata.ink-lang]
-abi = "sol"
+abi = "all"
 
 [workspace]
 

integration-tests/contracts/assets/lib.rs

@@ -1,6 +1,6 @@
 #![cfg_attr(not(feature = "std"), no_std, no_main)]
 
-use ink::{abi::Sol, sol::SolErrorDecode, env::DefaultEnvironment, Address, U256, contract_ref};
+use ink::{prelude::string::String, abi::Sol, env::DefaultEnvironment, Address, U256, contract_ref};
 
 /// Asset Hub ERC20 precompile index
 pub const PRECOMPILE_INDEX: u16 = 0x0120;
@@ -30,6 +30,10 @@ pub fn prefixed_address(n: u16, prefix: u32) -> Address {
     Address::from(address_bytes)
 }
 
+#[derive(ink::SolErrorDecode, ink::SolErrorEncode)]
+#[ink::scale_derive(Encode, Decode, TypeInfo)]
+pub struct Error(pub(crate) String);
+
 /// Asset Hub precompile interface.
 #[ink::contract]
 pub mod asset_hub_precompile {
@@ -47,17 +51,23 @@ pub mod asset_hub_precompile {
         fn balanceOf(&self, account: Address) -> U256;
 
         #[ink(message)]
-        fn transfer(&mut self, to: Address, value: U256) -> bool;
+        fn transfer(&mut self, to: Address, value: U256) -> Result<bool, Error>;
 
         #[ink(message)]
         fn allowance(&self, owner: Address, spender: Address) -> U256;
 
         #[ink(message)]
-        fn approve(&mut self, spender: Address, value: U256) -> bool;
+        fn approve(&mut self, spender: Address, value: U256) -> Result<bool, Error>;
 
         #[ink(message)]
         #[allow(non_snake_case)]
-        fn transferFrom(&mut self, from: Address, to: Address, value: U256) -> bool;
+        fn transferFrom(&mut self, from: Address, to: Address, value: U256) -> Result<bool, Error>;
+    }
+
+    #[ink::event]
+    #[cfg_attr(feature = "std", derive(Debug))]
+    pub struct Created {
+        pub id: AssetId,
     }
 
     #[ink(storage)]
@@ -68,7 +78,9 @@ pub mod asset_hub_precompile {
     impl AssetHubPrecompile {
         #[ink(constructor, payable)]
         pub fn create(asset_id: AssetId) -> Self {
-            Self { asset_id }
+            let contract = Self { asset_id };
+            contract.env().emit_event(Created { id: asset_id });
+            contract
         }
 
         #[ink(message)]
@@ -86,14 +98,14 @@ pub mod asset_hub_precompile {
         }
 
         #[ink(message)]
-        pub fn transfer(&mut self, to: Address, amount: U256) -> bool {
+        pub fn transfer(&mut self, to: Address, amount: U256) -> Result<bool, Error> {
             let precompile_address = prefixed_address(PRECOMPILE_INDEX, self.asset_id);
             let mut precompile: contract_ref!(Erc20, DefaultEnvironment, Sol) = precompile_address.into();
             precompile.transfer(to, amount)
         }
 
         #[ink(message)]
-        pub fn approve(&mut self, spender: Address, amount: U256) -> bool {
+        pub fn approve(&mut self, spender: Address, amount: U256) -> Result<bool, Error> {
             let precompile_address = prefixed_address(PRECOMPILE_INDEX, self.asset_id);
             let mut precompile: contract_ref!(Erc20, DefaultEnvironment, Sol) = precompile_address.into();
             precompile.approve(spender, amount)
@@ -107,11 +119,17 @@ pub mod asset_hub_precompile {
         }
 
         #[ink(message)]
-        pub fn transferFrom(&mut self, from: Address, to: Address, amount: U256) -> bool {
+        pub fn transferFrom(&mut self, from: Address, to: Address, amount: U256) -> Result<bool, Error> {
             let precompile_address = prefixed_address(PRECOMPILE_INDEX, self.asset_id);
             let mut precompile: contract_ref!(Erc20, DefaultEnvironment, Sol) = precompile_address.into();
             precompile.transferFrom(from, to, amount)
         }
+
+        #[ink(message)]
+        pub fn assetId(&self) -> AssetId {
+            self.asset_id
+            // 42
+        }
     }
 }
 

integration-tests/interfaces/IERC20.sol

@@ -27,6 +27,11 @@ interface IERC20 {
      */
     function totalSupply() external view returns (uint256);
 
+    /**
+     * @dev Returns the value of tokens in existence.
+     */
+    function assetId() external view returns (uint32);
+
     /**
      * @dev Returns the value of tokens owned by `account`.
      */

integration-tests/src/assets.rs

@@ -1,10 +1,12 @@
+use frame_support::traits::fungible::Inspect as _;
 use frame_support::{
 	assert_noop,
-	pallet_prelude::Encode,
+	pallet_prelude::{Decode, Encode},
 	traits::fungibles::{
 		approvals::Inspect as _, metadata::Inspect as _, roles::Inspect as _, Inspect as _,
 	},
 };
+use pallet_revive::precompiles::alloy::alloy_sol_types::SolValue;
 use sp_io::hashing::twox_256;
 
 use super::*;
@@ -17,18 +19,42 @@ pallet_revive::precompiles::alloy::sol!(
 	"interfaces/IERC20.sol"
 );
 
+#[cfg_attr(feature = "std", derive(Debug, Encode))]
+pub struct Created {
+	pub id: AssetId,
+}
+
+#[test]
+fn asset_id_works() {
+	let token = 42;
+	let endowment = 100 * UNIT;
+	ExtBuilder::new()
+		.with_assets(vec![(token, ALICE, false, 1)])
+		.with_asset_balances(vec![(token, BOB, endowment)])
+		.build()
+		.execute_with(|| {
+			let contract = Contract::new(&BOB, 0, token);
+
+			// Test that asset_id returns the correct token ID
+			assert_eq!(contract.asset_id(), token);
+		});
+}
+
 #[test]
 fn total_supply_works() {
-	let token = 1;
-	let endowment = 100;
+	let token = 2;
+	let endowment = 100 * UNIT;
 	ExtBuilder::new()
 		.with_assets(vec![(token, ALICE, false, 1)])
 		.with_asset_balances(vec![(token, BOB, endowment)])
 		.build()
 		.execute_with(|| {
 			let contract = Contract::new(&BOB, 0, token);
 
+			assert!(Assets::asset_exists(token));
+
 			// Tokens in circulation.
+			assert_eq!(total_supply_precompile(token), Assets::total_supply(token).into());
 			assert_eq!(contract.total_supply(), Assets::total_supply(token).into());
 			assert_eq!(contract.total_supply(), endowment.into());
 
@@ -45,8 +71,56 @@ struct Contract {
 	creator: AccountId,
 }
 
+/// Calculates the address of a precompile at index `n` and with some additional prefix.
+#[inline]
+pub fn fixed_address(n: u16) -> H160 {
+	let shifted = (n as u32) << 16;
+
+	let suffix = shifted.to_be_bytes();
+	let mut address = [0u8; 20];
+	let mut i = 16;
+	while i < address.len() {
+		address[i] = suffix[i - 16];
+		i = i + 1;
+	}
+	H160::from(address)
+}
+
+/// Calculates the address of a precompile at index `n` and with some additional prefix.
+#[inline]
+pub fn prefixed_address(n: u16, prefix: u32) -> H160 {
+	let address = fixed_address(n);
+	let mut address_bytes: [u8; 20] = address.into();
+	address_bytes[..4].copy_from_slice(&prefix.to_be_bytes());
+	H160::from(address_bytes)
+}
+
+fn total_supply_precompile(token: AssetId) -> U256 {
+	let call = totalSupplyCall {};
+	U256::from_little_endian(call_precompile(&BOB, call, 0, token).as_le_slice())
+}
+
+fn call_precompile<T: SolCall>(
+	origin: &AccountId,
+	call: T,
+	value: Balance,
+	token: AssetId,
+) -> T::Return {
+	let origin = RuntimeOrigin::signed(origin.clone());
+	let dest = prefixed_address(0x0120, token);
+	// let dest = self.address.clone();
+	let data = call.abi_encode();
+	let result = bare_call(origin, dest, value, GAS_LIMIT, STORAGE_DEPOSIT_LIMIT, data)
+		.expect("should work");
+
+	match result.did_revert() {
+		true => panic!("Contract call reverted: {:?}", String::from_utf8_lossy(&result.data)),
+		false => T::abi_decode_returns(&result.data).expect("unable to decode success value"),
+	}
+}
+
 impl Contract {
-	// Create a new instance of the contract through on-chain instantiation.
+	// Create a new instance of the contract through on-chain instantiation (ink! style).
 	fn new(origin: &AccountId, value: Balance, token: AssetId) -> Self {
 		let data = [blake_selector("create").to_vec(), token.encode()].concat();
 		let salt = twox_256(&value.to_le_bytes());
@@ -61,6 +135,14 @@ impl Contract {
 		U256::from_little_endian(self.call(&self.creator, call, 0).as_le_slice())
 	}
 
+	fn asset_id(&self) -> AssetId {
+		let call = assetIdCall {};
+		let data = self.call(&self.creator, call, 0);
+		// let bytes: [u8; 4] = data.as_slice().try_into().expect("Expected 4 bytes for u32");
+		// let result = u32::from_le_bytes(bytes);
+		AssetId::from(data)
+	}
+
 	fn account_id(&self) -> AccountId {
 		to_account_id(&self.address)
 	}

integration-tests/src/lib.rs

@@ -4,7 +4,7 @@ use std::path::Path;
 
 use frame_support::{assert_ok, weights::Weight};
 use ink_parachain_runtime::{
-	AccountId, Assets, Balance, Revive, Runtime, RuntimeOrigin, System, UNIT,
+	AccountId, Assets, Balance, Balances, Revive, Runtime, RuntimeOrigin, System, UNIT,
 };
 use pallet_assets::{Instance1, NextAssetId};
 use pallet_revive::{