integration test

Author: alexytsu

Cargo.toml

@@ -4,5 +4,5 @@ members = [
   "fvm_dispatch",
   "fil_token",
   "testing/integration",
-  "testing/integration/actors/fil_token_actor",
+  "testing/integration/actors/wfil_token_actor",
 ]

fil_token/src/runtime/fvm.rs

@@ -0,0 +1,18 @@
+use super::Runtime;
+
+use anyhow::{anyhow, Result};
+use fvm_sdk as sdk;
+use sdk::actor;
+use sdk::message;
+
+pub struct FvmRuntime {}
+
+impl Runtime for FvmRuntime {
+    fn caller(&self) -> u64 {
+        message::caller()
+    }
+
+    fn resolve_address(&self, addr: &fvm_shared::address::Address) -> Result<u64> {
+        actor::resolve_address(addr).ok_or_else(|| anyhow!("Failed to resolve address"))
+    }
+}

fil_token/src/runtime/mod.rs

@@ -1,3 +1,6 @@
+mod fvm;
+pub use fvm::*;
+
 use anyhow::Result;
 use fvm_shared::address::Address;
 

fil_token/src/token/mod.rs

@@ -28,9 +28,6 @@ macro_rules! abort {
 
 /// A standard fungible token interface allowing for on-chain transactions
 pub trait Token {
-    /// Constructs the token
-    fn constructor(&self, params: ConstructorParams) -> Result<()>;
-
     /// Returns the name of the token
     fn name(&self) -> String;
 
@@ -86,8 +83,15 @@ where
     BS: IpldStore + Copy,
     FVM: Runtime,
 {
-    fn load_state(&self) -> TokenState {
-        TokenState::load(&self.bs)
+    pub fn new(bs: BS, fvm: FVM) -> Self {
+        Self { bs, fvm }
+    }
+
+    /// Constructs the token
+    pub fn init_state(&self, params: ConstructorParams) -> Result<()> {
+        let init_state = TokenState::new(&self.bs, &params.name, &params.symbol)?;
+        init_state.save(&self.bs);
+        Ok(())
     }
 
     // Utility function for token-authors to mint supply
@@ -99,26 +103,15 @@ where
         let mut state = self.load_state();
         let mut balances = state.get_balance_map(&self.bs);
 
-        let holder = match self.fvm.resolve_address(&params.initial_holder) {
-            Ok(id) => id,
-            Err(_) => {
-                return Ok(MintReturn {
-                    newly_minted: TokenAmount::zero(),
-                    successful: false,
-                    total_supply: state.supply,
-                })
-            }
-        };
-
         // Mint the tokens into a specified account
         let balance = balances
-            .delete(&holder)?
+            .delete(&params.initial_holder)?
             .map(|de| de.1 .0)
             .unwrap_or_else(TokenAmount::zero);
         let new_balance = balance
             .checked_add(&params.value)
             .ok_or_else(|| ActorError::Arithmetic(String::from("Minting into caused overflow")))?;
-        balances.set(holder, BigIntDe(new_balance))?;
+        balances.set(params.initial_holder, BigIntDe(new_balance))?;
 
         // set the global supply of the contract
         let new_supply = state.supply.checked_add(&params.value).ok_or_else(|| {
@@ -135,19 +128,18 @@ where
             total_supply: state.supply,
         })
     }
+
+    /// Helper function that loads the root of the state tree related to token-accounting
+    fn load_state(&self) -> TokenState {
+        TokenState::load(&self.bs)
+    }
 }
 
 impl<BS, FVM> Token for TokenHelper<BS, FVM>
 where
     BS: IpldStore + Copy,
     FVM: Runtime,
 {
-    fn constructor(&self, params: ConstructorParams) -> Result<()> {
-        let init_state = TokenState::new(&self.bs, &params.name, &params.symbol)?;
-        init_state.save(&self.bs);
-        Ok(())
-    }
-
     fn name(&self) -> String {
         let state = self.load_state();
         state.name

fil_token/src/token/types.rs

@@ -3,6 +3,7 @@ use fvm_ipld_encoding::{Cbor, RawBytes};
 use fvm_shared::address::Address;
 use fvm_shared::bigint::bigint_ser;
 use fvm_shared::econ::TokenAmount;
+use fvm_shared::ActorID;
 
 #[derive(Serialize_tuple, Deserialize_tuple)]
 pub struct ConstructorParams {
@@ -14,7 +15,7 @@ pub struct ConstructorParams {
 /// Called during construction of the token actor to set a supply
 #[derive(Serialize_tuple, Deserialize_tuple)]
 pub struct MintParams {
-    pub initial_holder: Address,
+    pub initial_holder: ActorID,
     #[serde(with = "bigint_ser")]
     pub value: TokenAmount,
 }

testing/integration/actors/fil_token_actor/src/lib.rs

@@ -1,10 +1,12 @@
 [package]
-name = "fil_token_actor"
+name = "wfil_token_actor"
 version = "0.1.0"
 repository = "https://github.com/helix-collective/filecoin"
 edition = "2021"
 
 [dependencies]
+anyhow = { version = "1.0.56" }
+fvm_ipld_encoding = { version = "0.2.2" }
 fvm_sdk = { version = "1.0.0 "}
 fvm_shared = { version = "0.8.0" }
 fil_token = { version = "0.1.0", path = "../../../../fil_token" }

testing/integration/actors/fil_token_actor/Cargo.toml renamed to testing/integration/actors/wfil_token_actor/Cargo.toml

@@ -0,0 +1,155 @@
+use anyhow::Result;
+use fil_token::blockstore::Blockstore;
+use fil_token::runtime::FvmRuntime;
+use fil_token::token::types::*;
+use fil_token::token::{Token, TokenHelper};
+use fvm_ipld_encoding::{RawBytes, DAG_CBOR};
+use fvm_sdk as sdk;
+use fvm_shared::bigint::bigint_ser::BigIntSer;
+use fvm_shared::econ::TokenAmount;
+use sdk::NO_DATA_BLOCK_ID;
+
+struct WfilToken {
+    /// Default token helper impl
+    util: TokenHelper<Blockstore, FvmRuntime>,
+}
+
+// TODO: Wrapper is unecessary?
+// Instead expose a
+impl Token for WfilToken {
+    fn name(&self) -> String {
+        String::from("Wrapped FIL")
+    }
+
+    fn symbol(&self) -> String {
+        String::from("WFIL")
+    }
+
+    fn total_supply(&self) -> TokenAmount {
+        self.util.total_supply()
+    }
+
+    fn balance_of(
+        &self,
+        params: fvm_shared::address::Address,
+    ) -> Result<fvm_shared::econ::TokenAmount> {
+        self.util.balance_of(params)
+    }
+
+    fn increase_allowance(&self, params: ChangeAllowanceParams) -> Result<AllowanceReturn> {
+        self.util.increase_allowance(params)
+    }
+
+    fn decrease_allowance(&self, params: ChangeAllowanceParams) -> Result<AllowanceReturn> {
+        self.util.decrease_allowance(params)
+    }
+
+    fn revoke_allowance(&self, params: RevokeAllowanceParams) -> Result<AllowanceReturn> {
+        self.util.revoke_allowance(params)
+    }
+
+    fn allowance(&self, params: GetAllowanceParams) -> Result<AllowanceReturn> {
+        self.util.allowance(params)
+    }
+
+    fn burn(&self, params: BurnParams) -> Result<BurnReturn> {
+        self.util.burn(params)
+    }
+
+    fn transfer_from(&self, params: TransferParams) -> Result<TransferReturn> {
+        self.util.transfer_from(params)
+    }
+}
+
+/// Placeholder invoke for testing
+#[no_mangle]
+pub fn invoke(params: u32) -> u32 {
+    // Conduct method dispatch. Handle input parameters and return data.
+    let method_num = sdk::message::method_number();
+
+    let token_actor = WfilToken {
+        util: TokenHelper::new(Blockstore {}, FvmRuntime {}),
+    };
+
+    //TODO: this internal dispatch can be pushed as a library function into the fil_token crate
+    // - it should support a few different calling-conventions
+    // - it should also handle deserialization of raw_params into the expected IPLD types
+    let res = match method_num {
+        // Actor constructor
+        1 => constructor(),
+        // Standard token interface
+        2 => {
+            token_actor.name();
+            // TODO: store and return CID
+            NO_DATA_BLOCK_ID
+        }
+        3 => {
+            token_actor.symbol();
+            // TODO: store and return CID
+            NO_DATA_BLOCK_ID
+        }
+        4 => {
+            token_actor.total_supply();
+            // TODO: store and return CID
+            NO_DATA_BLOCK_ID
+        }
+        5 => {
+            // balance of
+            let params = sdk::message::params_raw(params).unwrap().1;
+            let params = RawBytes::new(params);
+            let params = params.deserialize().unwrap();
+            let res = token_actor.balance_of(params).unwrap();
+            let res = RawBytes::new(fvm_ipld_encoding::to_vec(&BigIntSer(&res)).unwrap());
+            let cid = sdk::ipld::put_block(DAG_CBOR, res.bytes()).unwrap();
+            cid
+        }
+        6 => {
+            // increase allowance
+            NO_DATA_BLOCK_ID
+        }
+        7 => {
+            // decrease allowance
+            NO_DATA_BLOCK_ID
+        }
+        8 => {
+            // revoke_allowance
+            NO_DATA_BLOCK_ID
+        }
+        9 => {
+            // allowance
+            NO_DATA_BLOCK_ID
+        }
+        10 => {
+            // burn
+            NO_DATA_BLOCK_ID
+        }
+        11 => {
+            // transfer_from
+            NO_DATA_BLOCK_ID
+        }
+        // Custom actor interface
+        12 => {
+            // Mint
+            let params = MintParams {
+                initial_holder: sdk::message::caller(),
+                value: sdk::message::value_received(),
+            };
+            let res = token_actor.util.mint(params).unwrap();
+            let res = RawBytes::new(fvm_ipld_encoding::to_vec(&res).unwrap());
+            let cid = sdk::ipld::put_block(DAG_CBOR, res.bytes()).unwrap();
+            cid
+        }
+        _ => {
+            sdk::vm::abort(
+                fvm_shared::error::ExitCode::USR_ILLEGAL_ARGUMENT.value(),
+                Some("Unknown method number"),
+            );
+        }
+    };
+
+    res
+}
+
+fn constructor() -> u32 {
+    0_u32
+}