Merge api/program into single units (#7061)

programs/move_loader/.gitignore

@@ -0,0 +1 @@
+/target/

programs/move_loader/Cargo.toml

@@ -0,0 +1,39 @@
+[package]
+name = "solana-move-loader-program"
+version = "0.21.0"
+description = "Solana Move loader"
+authors = ["Solana Maintainers <maintainers@solana.com>"]
+repository = "https://github.com/solana-labs/solana"
+license = "Apache-2.0"
+homepage = "https://solana.com/"
+edition = "2018"
+
+[dependencies]
+bincode = "1.2.0"
+byteorder = "1.3.2"
+indexmap = "1.1.0"
+libc = "0.2.65"
+log = "0.4.8"
+serde = "1.0.102"
+serde_bytes = "0.11"
+serde_derive = "1.0.102"
+serde_json = "1.0.41"
+solana-logger = { path = "../../logger", version = "0.21.0" }
+solana-sdk = { path = "../../sdk", version = "0.21.0" }
+
+bytecode_verifier = { version = "0.0.1-sol4", package = "solana_libra_bytecode_verifier" }
+canonical_serialization = { version = "0.0.1-sol4", package = "solana_libra_canonical_serialization" }
+compiler = { version = "0.0.1-sol4", package = "solana_libra_compiler" }
+failure = { version = "0.0.1-sol4", package = "solana_libra_failure_ext" }
+language_e2e_tests = { version = "0.0.1-sol4", package = "solana_libra_language_e2e_tests" }
+state_view = { version = "0.0.1-sol4", package = "solana_libra_state_view" }
+stdlib = { version = "0.0.1-sol4", package = "solana_libra_stdlib" }
+types = { version = "0.0.1-sol4", package = "solana_libra_types" }
+vm = { version = "0.0.1-sol4", package = "solana_libra_vm" }
+vm_cache_map = { version = "0.0.1-sol4", package = "solana_libra_vm_cache_map" }
+vm_runtime = { version = "0.0.1-sol4", package = "solana_libra_vm_runtime" }
+vm_runtime_types = { version = "0.0.1-sol4", package = "solana_libra_vm_runtime_types" }
+
+[lib]
+crate-type = ["lib", "cdylib"]
+name = "solana_move_loader_program"

programs/move_loader/src/account_state.rs

@@ -0,0 +1,201 @@
+use crate::data_store::DataStore;
+use crate::error_mappers::*;
+use bytecode_verifier::VerifiedModule;
+use compiler::Compiler;
+use serde_derive::{Deserialize, Serialize};
+use solana_sdk::{instruction::InstructionError, pubkey::Pubkey};
+use std::convert::TryInto;
+use stdlib::stdlib_modules;
+use types::{
+    account_address::AccountAddress,
+    account_config,
+    identifier::Identifier,
+    transaction::{Module, Script},
+    write_set::{WriteOp, WriteSet},
+};
+use vm::{
+    access::ModuleAccess, file_format::CompiledModule, transaction_metadata::TransactionMetadata,
+};
+use vm_cache_map::Arena;
+use vm_runtime::{
+    code_cache::{
+        module_adapter::FakeFetcher,
+        module_cache::{BlockModuleCache, VMModuleCache},
+    },
+    data_cache::BlockDataCache,
+    txn_executor::{TransactionExecutor, ACCOUNT_MODULE, BLOCK_MODULE, COIN_MODULE},
+};
+use vm_runtime_types::value::Value;
+
+// Helper function that converts a Solana Pubkey to a Libra AccountAddress (WIP)
+pub fn pubkey_to_address(key: &Pubkey) -> AccountAddress {
+    AccountAddress::new(*to_array_32(key.as_ref()))
+}
+fn to_array_32(array: &[u8]) -> &[u8; 32] {
+    array.try_into().expect("slice with incorrect length")
+}
+
+#[derive(Clone, Debug, Deserialize, Eq, PartialEq, Serialize)]
+pub struct ModuleBytes {
+    #[serde(with = "serde_bytes")]
+    pub bytes: Vec<u8>,
+}
+
+/// Type of Libra account held by a Solana account
+#[derive(Clone, Debug, Deserialize, Eq, PartialEq, Serialize)]
+pub enum LibraAccountState {
+    /// No data for this account yet
+    Unallocated,
+    /// Json string representation of types::transaction::Module
+    CompiledScript(String),
+    /// Json string representation of types::transaction::Script
+    CompiledModule(String),
+    /// Serialized verified script bytes
+    VerifiedScript {
+        #[serde(with = "serde_bytes")]
+        script_bytes: Vec<u8>,
+    },
+    // Write set containing the published module
+    PublishedModule(WriteSet),
+    /// Associated genesis account and the write set containing the Libra account data
+    User(Pubkey, WriteSet),
+    /// Write sets containing the mint and stdlib modules
+    Genesis(WriteSet),
+}
+impl LibraAccountState {
+    pub fn create_unallocated() -> Self {
+        Self::Unallocated
+    }
+
+    fn create_compiler(sender_address: &AccountAddress, deps: Vec<&Vec<u8>>) -> Compiler {
+        // Compiler needs all the dependencies and the dependency module's account's
+        // data into `VerifiedModules`
+        let mut extra_deps: Vec<VerifiedModule> = vec![];
+        for dep in deps {
+            let state: Self = bincode::deserialize(&dep).unwrap();
+            if let Self::PublishedModule(write_set) = state {
+                for (_, write_op) in write_set.iter() {
+                    if let WriteOp::Value(raw_bytes) = write_op {
+                        let v =
+                            VerifiedModule::new(CompiledModule::deserialize(&raw_bytes).unwrap())
+                                .unwrap();
+                        extra_deps.push(v);
+                    }
+                }
+            }
+        }
+
+        Compiler {
+            address: *sender_address,
+            extra_deps,
+            ..Compiler::default()
+        }
+    }
+
+    pub fn create_script(sender_address: &AccountAddress, code: &str, deps: Vec<&Vec<u8>>) -> Self {
+        let compiler = Self::create_compiler(sender_address, deps);
+        let compiled_script = compiler.into_script(code).expect("Failed to compile");
+
+        let mut script_bytes = vec![];
+        compiled_script
+            .serialize(&mut script_bytes)
+            .expect("Unable to serialize script");
+
+        // TODO args?
+        Self::CompiledScript(serde_json::to_string(&Script::new(script_bytes, vec![])).unwrap())
+    }
+
+    pub fn create_module(sender_address: &AccountAddress, code: &str, deps: Vec<&Vec<u8>>) -> Self {
+        let compiler = Self::create_compiler(sender_address, deps);
+        let compiled_module = compiler
+            .into_compiled_module(code)
+            .expect("Failed to compile");
+
+        let mut module_bytes = vec![];
+        compiled_module
+            .serialize(&mut module_bytes)
+            .expect("Unable to serialize script");
+
+        Self::CompiledModule(serde_json::to_string(&Module::new(module_bytes)).unwrap())
+    }
+
+    pub fn create_user(owner: &Pubkey, write_set: WriteSet) -> Self {
+        Self::User(*owner, write_set)
+    }
+
+    pub fn create_genesis(mint_balance: u64) -> Result<(Self), InstructionError> {
+        let modules = stdlib_modules();
+        let arena = Arena::new();
+        let state_view = DataStore::default();
+        let vm_cache = VMModuleCache::new(&arena);
+        let genesis_addr = account_config::association_address();
+
+        let write_set = {
+            let fake_fetcher =
+                FakeFetcher::new(modules.iter().map(|m| m.as_inner().clone()).collect());
+            let data_cache = BlockDataCache::new(&state_view);
+            let block_cache = BlockModuleCache::new(&vm_cache, fake_fetcher);
+
+            let mut txn_data = TransactionMetadata::default();
+            txn_data.sender = genesis_addr;
+
+            let mut txn_executor = TransactionExecutor::new(&block_cache, &data_cache, txn_data);
+            txn_executor.create_account(genesis_addr).unwrap();
+            txn_executor
+                .create_account(account_config::core_code_address())
+                .map_err(map_err_vm_status)?;
+            txn_executor
+                .execute_function(
+                    &BLOCK_MODULE,
+                    &Identifier::new("initialize").unwrap(),
+                    vec![],
+                )
+                .map_err(map_err_vm_status)?;
+            txn_executor
+                .execute_function(
+                    &COIN_MODULE,
+                    &Identifier::new("initialize").unwrap(),
+                    vec![],
+                )
+                .map_err(map_err_vm_status)?;
+
+            txn_executor
+                .execute_function(
+                    &ACCOUNT_MODULE,
+                    &Identifier::new("mint_to_address").unwrap(),
+                    vec![Value::address(genesis_addr), Value::u64(mint_balance)],
+                )
+                .map_err(map_err_vm_status)?;
+
+            // Bump the sequence number for the Association account. If we don't do this and a
+            // subsequent transaction (e.g., minting) is sent from the Association account, a problem
+            // arises: both the genesis transaction and the subsequent transaction have sequence
+            // number 0
+            txn_executor
+                .execute_function(
+                    &ACCOUNT_MODULE,
+                    &Identifier::new("epilogue").unwrap(),
+                    vec![],
+                )
+                .map_err(map_err_vm_status)?;
+
+            let mut stdlib_modules = vec![];
+            for module in modules.iter() {
+                let mut buf = vec![];
+                module.serialize(&mut buf).map_err(map_failure_error)?;
+                stdlib_modules.push((module.self_id(), buf));
+            }
+
+            txn_executor
+                .make_write_set(stdlib_modules, Ok(()))
+                .map_err(map_err_vm_status)?
+                .write_set()
+                .clone()
+                .into_mut()
+        }
+        .freeze()
+        .map_err(map_failure_error)?;
+
+        Ok(Self::Genesis(write_set))
+    }
+}

programs/move_loader/src/data_store.rs

@@ -0,0 +1,178 @@
+use bytecode_verifier::verifier::VerifiedModule;
+use canonical_serialization::SimpleDeserializer;
+use failure::prelude::*;
+use indexmap::IndexMap;
+use log::*;
+use state_view::StateView;
+use types::{
+    access_path::AccessPath,
+    account_address::AccountAddress,
+    account_config::{self, AccountResource},
+    write_set::{WriteOp, WriteSet, WriteSetMut},
+};
+use vm::access::ModuleAccess;
+use vm::errors::VMResult;
+use vm_runtime::{data_cache::RemoteCache, identifier::create_access_path};
+
+/// An in-memory implementation of [`StateView`] and [`RemoteCache`] for the VM.
+#[derive(Debug, Default)]
+pub struct DataStore {
+    data: IndexMap<AccessPath, Vec<u8>>,
+}
+
+impl DataStore {
+    /// Creates a new `DataStore` with the provided initial data.
+    pub fn new(data: IndexMap<AccessPath, Vec<u8>>) -> Self {
+        Self { data }
+    }
+
+    /// Applies a [`WriteSet`] to this data store.
+    pub fn apply_write_set(&mut self, write_set: &WriteSet) {
+        for (access_path, write_op) in write_set {
+            match write_op {
+                WriteOp::Value(value) => {
+                    self.set(access_path.clone(), value.clone());
+                }
+                WriteOp::Deletion => {
+                    self.remove(access_path);
+                }
+            }
+        }
+    }
+
+    /// Returns a `WriteSet` for each account in the `DataStore`
+    pub fn into_write_sets(mut self) -> Result<IndexMap<AccountAddress, WriteSet>> {
+        let mut write_set_muts: IndexMap<AccountAddress, WriteSetMut> = IndexMap::new();
+        for (access_path, value) in self.data.drain(..) {
+            match write_set_muts.get_mut(&access_path.address) {
+                Some(write_set_mut) => write_set_mut.push((access_path, WriteOp::Value(value))),
+                None => {
+                    write_set_muts.insert(
+                        access_path.address,
+                        WriteSetMut::new(vec![(access_path, WriteOp::Value(value))]),
+                    );
+                }
+            }
+        }
+        // Freeze each WriteSet
+        let mut write_sets: IndexMap<AccountAddress, WriteSet> = IndexMap::new();
+        for (address, write_set_mut) in write_set_muts.drain(..) {
+            write_sets.insert(address, write_set_mut.freeze()?);
+        }
+        Ok(write_sets)
+    }
+
+    /// Read an account's resource
+    pub fn read_account_resource(&self, addr: &AccountAddress) -> Option<AccountResource> {
+        let access_path = create_access_path(&addr, account_config::account_struct_tag());
+        match self.data.get(&access_path) {
+            None => None,
+            Some(blob) => SimpleDeserializer::deserialize(blob).ok(),
+        }
+    }
+
+    /// Sets a (key, value) pair within this data store.
+    ///
+    /// Returns the previous data if the key was occupied.
+    pub fn set(&mut self, access_path: AccessPath, data_blob: Vec<u8>) -> Option<Vec<u8>> {
+        self.data.insert(access_path, data_blob)
+    }
+
+    /// Deletes a key from this data store.
+    ///
+    /// Returns the previous data if the key was occupied.
+    pub fn remove(&mut self, access_path: &AccessPath) -> Option<Vec<u8>> {
+        self.data.remove(access_path)
+    }
+
+    /// Adds a [`VerifiedModule`] to this data store.
+    pub fn add_module(&mut self, module: &VerifiedModule) -> Result<()> {
+        let access_path = AccessPath::from(&module.self_id());
+
+        let mut bytes = vec![];
+        module.serialize(&mut bytes)?;
+        self.set(access_path, bytes);
+        Ok(())
+    }
+
+    /// Dumps the data store to stdout
+    pub fn dump(&self) {
+        trace!("Data store:");
+        for (access_path, value) in &self.data {
+            trace!("{:?}: {:?}", access_path, value.len());
+        }
+    }
+}
+
+impl StateView for DataStore {
+    fn get(&self, access_path: &AccessPath) -> Result<Option<Vec<u8>>> {
+        // Since the data is in-memory, it can't fail.
+        match self.data.get(access_path) {
+            None => Ok(None),
+            Some(value) => Ok(Some(value.clone())),
+        }
+    }
+
+    fn multi_get(&self, _access_paths: &[AccessPath]) -> Result<Vec<Option<Vec<u8>>>> {
+        unimplemented!();
+    }
+
+    fn is_genesis(&self) -> bool {
+        false
+    }
+}
+
+impl RemoteCache for DataStore {
+    fn get(&self, access_path: &AccessPath) -> VMResult<Option<Vec<u8>>> {
+        Ok(StateView::get(self, access_path).expect("it should not error"))
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use types::account_address::ADDRESS_LENGTH;
+
+    #[test]
+    fn test_write_set_order() {
+        solana_logger::setup();
+
+        let mut data_store = DataStore::default();
+        let address1 = AccountAddress::new([0; ADDRESS_LENGTH]);
+        let address2 = AccountAddress::new([1; ADDRESS_LENGTH]);
+        let address3 = AccountAddress::new([2; ADDRESS_LENGTH]);
+
+        let mut before1 = WriteSetMut::default();
+        let mut before2 = WriteSetMut::default();
+        let mut before3 = WriteSetMut::default();
+        for i in 1..10 {
+            before1.push((
+                AccessPath::new(address1, AccountAddress::random().to_vec()),
+                WriteOp::Value(vec![i]),
+            ));
+            before2.push((
+                AccessPath::new(address2, AccountAddress::random().to_vec()),
+                WriteOp::Value(vec![i]),
+            ));
+            before3.push((
+                AccessPath::new(address3, AccountAddress::random().to_vec()),
+                WriteOp::Value(vec![i]),
+            ));
+        }
+        let before1 = before1.freeze().unwrap();
+        let before2 = before2.freeze().unwrap();
+        let before3 = before3.freeze().unwrap();
+        data_store.apply_write_set(&before1);
+        data_store.apply_write_set(&before2);
+        data_store.apply_write_set(&before3);
+
+        let write_sets = data_store.into_write_sets().unwrap();
+        let after1 = write_sets.get(&address1).unwrap();
+        let after2 = write_sets.get(&address2).unwrap();
+        let after3 = write_sets.get(&address3).unwrap();
+
+        assert_eq!(&before1, after1);
+        assert_eq!(&before2, after2);
+        assert_eq!(&before3, after3);
+    }
+}

programs/move_loader/src/error_mappers.rs

@@ -0,0 +1,47 @@
+//! Mapping functions to Instruction errors
+
+use log::*;
+use solana_sdk::instruction::InstructionError;
+use std::convert::TryInto;
+use types::vm_error::{StatusCode, VMStatus};
+use vm::file_format::CompiledModule;
+
+#[allow(clippy::needless_pass_by_value)]
+pub fn map_data_error(err: std::boxed::Box<bincode::ErrorKind>) -> InstructionError {
+    debug!("Error: Account data: {:?}", err);
+    match err.as_ref() {
+        bincode::ErrorKind::SizeLimit => InstructionError::AccountDataTooSmall,
+        _ => InstructionError::InvalidAccountData,
+    }
+}
+
+#[allow(clippy::needless_pass_by_value)]
+pub fn map_json_error(err: serde_json::error::Error) -> InstructionError {
+    debug!("Error: serde_json: {:?}", err);
+    InstructionError::InvalidAccountData
+}
+
+pub fn map_vm_verification_error(err: (CompiledModule, Vec<VMStatus>)) -> InstructionError {
+    debug!("Error: Script verification failed: {:?}", err.1);
+    InstructionError::InvalidInstructionData
+}
+
+#[allow(clippy::needless_pass_by_value)]
+pub fn missing_account() -> InstructionError {
+    debug!("Error: Missing account");
+    InstructionError::InvalidAccountData
+}
+
+pub fn map_failure_error(err: failure::Error) -> InstructionError {
+    debug!("Error: Script verification failed: {:?}", err);
+    InstructionError::InvalidInstructionData
+}
+
+pub fn map_err_vm_status(status: VMStatus) -> InstructionError {
+    // Attempt to map the StatusCode (repr(u64)) to a u32 for CustomError.
+    // The only defined StatusCode that fails is StatusCode::UNKNOWN_ERROR
+    match <StatusCode as Into<u64>>::into(status.major_status).try_into() {
+        Ok(u) => InstructionError::CustomError(u),
+        Err(_) => InstructionError::GenericError,
+    }
+}

programs/move_loader/src/lib.rs

@@ -0,0 +1,14 @@
+pub mod account_state;
+pub mod data_store;
+pub mod error_mappers;
+pub mod processor;
+
+use crate::processor::process_instruction;
+use solana_sdk::move_loader::PROGRAM_ID;
+
+solana_sdk::declare_program!(
+    PROGRAM_ID,
+    "MoveLdr111111111111111111111111111111111111",
+    solana_move_loader_program,
+    process_instruction
+);

programs/move_loader/src/processor.rs

@@ -0,0 +1,918 @@
+use crate::account_state::{pubkey_to_address, LibraAccountState};
+use crate::data_store::DataStore;
+use crate::error_mappers::*;
+use bytecode_verifier::verifier::{VerifiedModule, VerifiedScript};
+use log::*;
+use serde_derive::{Deserialize, Serialize};
+use solana_sdk::{
+    account::KeyedAccount,
+    instruction::InstructionError,
+    instruction_processor_utils::{limited_deserialize, next_keyed_account},
+    loader_instruction::LoaderInstruction,
+    move_loader::id,
+    pubkey::Pubkey,
+    sysvar::rent,
+};
+use types::{
+    account_address::AccountAddress,
+    account_config,
+    identifier::Identifier,
+    transaction::{Module, Script, TransactionArgument, TransactionOutput},
+};
+use vm::{
+    access::ModuleAccess,
+    file_format::{CompiledModule, CompiledScript},
+    gas_schedule::{MAXIMUM_NUMBER_OF_GAS_UNITS, MAX_PRICE_PER_GAS_UNIT},
+    transaction_metadata::TransactionMetadata,
+    vm_string::VMString,
+};
+use vm_cache_map::Arena;
+use vm_runtime::{
+    code_cache::{
+        module_adapter::ModuleFetcherImpl,
+        module_cache::{BlockModuleCache, ModuleCache, VMModuleCache},
+    },
+    txn_executor::TransactionExecutor,
+};
+use vm_runtime_types::value::Value;
+
+pub fn process_instruction(
+    _program_id: &Pubkey,
+    keyed_accounts: &mut [KeyedAccount],
+    data: &[u8],
+) -> Result<(), InstructionError> {
+    solana_logger::setup();
+
+    match limited_deserialize(data)? {
+        LoaderInstruction::Write { offset, bytes } => {
+            MoveProcessor::do_write(keyed_accounts, offset, &bytes)
+        }
+        LoaderInstruction::Finalize => MoveProcessor::do_finalize(keyed_accounts),
+        LoaderInstruction::InvokeMain { data } => {
+            MoveProcessor::do_invoke_main(keyed_accounts, &data)
+        }
+    }
+}
+
+/// Command to invoke
+#[derive(Debug, Serialize, Deserialize)]
+pub enum InvokeCommand {
+    /// Create a new genesis account
+    CreateGenesis(u64),
+    /// run a Move script
+    RunScript {
+        /// Sender of the "transaction", the "sender" who is running this script
+        sender_address: AccountAddress,
+        /// Name of the script's function to call
+        function_name: String,
+        /// Arguments to pass to the script being called
+        args: Vec<TransactionArgument>,
+    },
+}
+
+pub struct MoveProcessor {}
+
+impl MoveProcessor {
+    #[allow(clippy::needless_pass_by_value)]
+    fn missing_account() -> InstructionError {
+        debug!("Error: Missing libra account");
+        InstructionError::InvalidAccountData
+    }
+
+    fn arguments_to_values(args: Vec<TransactionArgument>) -> Vec<Value> {
+        let mut locals = vec![];
+        for arg in args {
+            locals.push(match arg {
+                TransactionArgument::U64(i) => Value::u64(i),
+                TransactionArgument::Address(a) => Value::address(a),
+                TransactionArgument::ByteArray(b) => Value::byte_array(b),
+                TransactionArgument::String(s) => Value::string(VMString::new(s)),
+            });
+        }
+        locals
+    }
+
+    fn serialize_and_enforce_length(
+        state: &LibraAccountState,
+        data: &mut Vec<u8>,
+    ) -> Result<(), InstructionError> {
+        let original_len = data.len() as u64;
+        let mut writer = std::io::Cursor::new(data);
+        bincode::config()
+            .limit(original_len)
+            .serialize_into(&mut writer, &state)
+            .map_err(map_data_error)?;
+        if writer.position() < original_len {
+            writer.set_position(original_len);
+        }
+        Ok(())
+    }
+
+    fn deserialize_verified_script(data: &[u8]) -> Result<VerifiedScript, InstructionError> {
+        match limited_deserialize(data)? {
+            LibraAccountState::VerifiedScript { script_bytes } => {
+                let script =
+                    VerifiedScript::deserialize(&script_bytes).map_err(map_err_vm_status)?;
+                Ok(script)
+            }
+            _ => {
+                debug!("Error: Script account does not contain a script");
+                Err(InstructionError::InvalidArgument)
+            }
+        }
+    }
+
+    fn execute(
+        sender_address: AccountAddress,
+        function_name: &str,
+        args: Vec<TransactionArgument>,
+        script: VerifiedScript,
+        data_store: &DataStore,
+    ) -> Result<TransactionOutput, InstructionError> {
+        let allocator = Arena::new();
+        let code_cache = VMModuleCache::new(&allocator);
+        let module_cache = BlockModuleCache::new(&code_cache, ModuleFetcherImpl::new(data_store));
+        let modules_to_publish = vec![];
+
+        let main_module = script.into_module();
+        let module_id = main_module.self_id();
+        module_cache.cache_module(main_module);
+
+        let mut txn_metadata = TransactionMetadata::default();
+        txn_metadata.sender = sender_address;
+
+        // Caps execution to the Libra prescribed 10 milliseconds
+        txn_metadata.max_gas_amount = *MAXIMUM_NUMBER_OF_GAS_UNITS;
+        txn_metadata.gas_unit_price = *MAX_PRICE_PER_GAS_UNIT;
+
+        let mut vm = TransactionExecutor::new(&module_cache, data_store, txn_metadata);
+        vm.execute_function(
+            &module_id,
+            &Identifier::new(function_name).unwrap(),
+            Self::arguments_to_values(args),
+        )
+        .map_err(map_err_vm_status)?;
+
+        Ok(vm
+            .make_write_set(modules_to_publish, Ok(()))
+            .map_err(map_err_vm_status)?)
+    }
+
+    fn keyed_accounts_to_data_store(
+        keyed_accounts: &[KeyedAccount],
+    ) -> Result<DataStore, InstructionError> {
+        let mut data_store = DataStore::default();
+
+        let mut keyed_accounts_iter = keyed_accounts.iter();
+        let genesis = next_keyed_account(&mut keyed_accounts_iter)?;
+
+        match limited_deserialize(&genesis.account.data)? {
+            LibraAccountState::Genesis(write_set) => data_store.apply_write_set(&write_set),
+            _ => {
+                debug!("Must include a genesis account");
+                return Err(InstructionError::InvalidArgument);
+            }
+        }
+
+        for keyed_account in keyed_accounts_iter {
+            match limited_deserialize(&keyed_account.account.data)? {
+                LibraAccountState::User(owner, write_set) => {
+                    if owner != *genesis.unsigned_key() {
+                        debug!("User account must be owned by this genesis");
+                        return Err(InstructionError::InvalidArgument);
+                    }
+                    data_store.apply_write_set(&write_set)
+                }
+                LibraAccountState::PublishedModule(write_set) => {
+                    data_store.apply_write_set(&write_set)
+                }
+                _ => (),
+            }
+        }
+        Ok(data_store)
+    }
+
+    fn data_store_to_keyed_accounts(
+        data_store: DataStore,
+        keyed_accounts: &mut [KeyedAccount],
+    ) -> Result<(), InstructionError> {
+        let mut write_sets = data_store
+            .into_write_sets()
+            .map_err(|_| InstructionError::GenericError)?;
+
+        let mut keyed_accounts_iter = keyed_accounts.iter_mut();
+
+        // Genesis account holds both mint and stdlib
+        let genesis = next_keyed_account(&mut keyed_accounts_iter)?;
+        let genesis_key = *genesis.unsigned_key();
+        let mut write_set = write_sets
+            .remove(&account_config::association_address())
+            .ok_or_else(Self::missing_account)?
+            .into_mut();
+        for (access_path, write_op) in write_sets
+            .remove(&account_config::core_code_address())
+            .ok_or_else(Self::missing_account)?
+            .into_iter()
+        {
+            write_set.push((access_path, write_op));
+        }
+        let write_set = write_set.freeze().unwrap();
+        Self::serialize_and_enforce_length(
+            &LibraAccountState::Genesis(write_set),
+            &mut genesis.account.data,
+        )?;
+
+        // Now do the rest of the accounts
+        for keyed_account in keyed_accounts_iter {
+            let write_set = write_sets
+                .remove(&pubkey_to_address(keyed_account.unsigned_key()))
+                .ok_or_else(Self::missing_account)?;
+            if !keyed_account.account.executable {
+                // Only write back non-executable accounts
+                Self::serialize_and_enforce_length(
+                    &LibraAccountState::User(genesis_key, write_set),
+                    &mut keyed_account.account.data,
+                )?;
+            }
+        }
+        if !write_sets.is_empty() {
+            debug!("Error: Missing keyed accounts");
+            return Err(InstructionError::GenericError);
+        }
+        Ok(())
+    }
+
+    pub fn do_write(
+        keyed_accounts: &mut [KeyedAccount],
+        offset: u32,
+        bytes: &[u8],
+    ) -> Result<(), InstructionError> {
+        let mut keyed_accounts_iter = keyed_accounts.iter_mut();
+        let keyed_account = next_keyed_account(&mut keyed_accounts_iter)?;
+
+        if keyed_account.signer_key().is_none() {
+            debug!("Error: key[0] did not sign the transaction");
+            return Err(InstructionError::MissingRequiredSignature);
+        }
+        let offset = offset as usize;
+        let len = bytes.len();
+        trace!("Write: offset={} length={}", offset, len);
+        if keyed_account.account.data.len() < offset + len {
+            debug!(
+                "Error: Write overflow: {} < {}",
+                keyed_account.account.data.len(),
+                offset + len
+            );
+            return Err(InstructionError::AccountDataTooSmall);
+        }
+        keyed_account.account.data[offset..offset + len].copy_from_slice(&bytes);
+        Ok(())
+    }
+
+    pub fn do_finalize(keyed_accounts: &mut [KeyedAccount]) -> Result<(), InstructionError> {
+        let mut keyed_accounts_iter = keyed_accounts.iter_mut();
+        let finalized = next_keyed_account(&mut keyed_accounts_iter)?;
+        let rent = next_keyed_account(&mut keyed_accounts_iter)?;
+
+        if finalized.signer_key().is_none() {
+            debug!("Error: account to finalize did not sign the transaction");
+            return Err(InstructionError::MissingRequiredSignature);
+        }
+
+        rent::verify_rent_exemption(&finalized, &rent)?;
+
+        match limited_deserialize(&finalized.account.data)? {
+            LibraAccountState::CompiledScript(string) => {
+                let script: Script = serde_json::from_str(&string).map_err(map_json_error)?;
+                let compiled_script =
+                    CompiledScript::deserialize(&script.code()).map_err(map_err_vm_status)?;
+                let verified_script = match VerifiedScript::new(compiled_script) {
+                    Ok(script) => script,
+                    Err((_, errors)) => {
+                        if errors.is_empty() {
+                            return Err(InstructionError::GenericError);
+                        } else {
+                            return Err(map_err_vm_status(errors[0].clone()));
+                        }
+                    }
+                };
+                let mut script_bytes = vec![];
+                verified_script
+                    .as_inner()
+                    .serialize(&mut script_bytes)
+                    .map_err(map_failure_error)?;
+                Self::serialize_and_enforce_length(
+                    &LibraAccountState::VerifiedScript { script_bytes },
+                    &mut finalized.account.data,
+                )?;
+                info!("Finalize script: {:?}", finalized.unsigned_key());
+            }
+            LibraAccountState::CompiledModule(string) => {
+                let module: Module = serde_json::from_str(&string).map_err(map_json_error)?;
+                let compiled_module =
+                    CompiledModule::deserialize(&module.code()).map_err(map_err_vm_status)?;
+                let verified_module =
+                    VerifiedModule::new(compiled_module).map_err(map_vm_verification_error)?;
+
+                let mut data_store = DataStore::default();
+                data_store
+                    .add_module(&verified_module)
+                    .map_err(map_failure_error)?;
+
+                let mut write_sets = data_store
+                    .into_write_sets()
+                    .map_err(|_| InstructionError::GenericError)?;
+
+                let write_set = write_sets
+                    .remove(&pubkey_to_address(finalized.unsigned_key()))
+                    .ok_or_else(Self::missing_account)?;
+                Self::serialize_and_enforce_length(
+                    &LibraAccountState::PublishedModule(write_set),
+                    &mut finalized.account.data,
+                )?;
+
+                if !write_sets.is_empty() {
+                    debug!("Error: Missing keyed accounts");
+                    return Err(InstructionError::GenericError);
+                }
+
+                info!("Finalize module: {:?}", finalized.unsigned_key());
+            }
+            _ => {
+                debug!("Error: Account to finalize does not contain compiled data");
+                return Err(InstructionError::InvalidArgument);
+            }
+        };
+
+        finalized.account.executable = true;
+
+        Ok(())
+    }
+
+    pub fn do_invoke_main(
+        keyed_accounts: &mut [KeyedAccount],
+        data: &[u8],
+    ) -> Result<(), InstructionError> {
+        match limited_deserialize(&data)? {
+            InvokeCommand::CreateGenesis(amount) => {
+                let mut keyed_accounts_iter = keyed_accounts.iter_mut();
+                let script = next_keyed_account(&mut keyed_accounts_iter)?;
+
+                if script.account.owner != id() {
+                    debug!("Error: Move script account not owned by Move loader");
+                    return Err(InstructionError::InvalidArgument);
+                }
+
+                match limited_deserialize(&script.account.data)? {
+                    LibraAccountState::Unallocated => Self::serialize_and_enforce_length(
+                        &LibraAccountState::create_genesis(amount)?,
+                        &mut script.account.data,
+                    ),
+                    _ => {
+                        debug!("Error: Must provide an unallocated account");
+                        Err(InstructionError::InvalidArgument)
+                    }
+                }
+            }
+            InvokeCommand::RunScript {
+                sender_address,
+                function_name,
+                args,
+            } => {
+                let mut keyed_accounts_iter = keyed_accounts.iter_mut();
+                let script = next_keyed_account(&mut keyed_accounts_iter)?;
+
+                trace!(
+                    "Run script {:?} with entrypoint {:?}",
+                    script.unsigned_key(),
+                    function_name
+                );
+
+                if script.account.owner != id() {
+                    debug!("Error: Move script account not owned by Move loader");
+                    return Err(InstructionError::InvalidArgument);
+                }
+                if !script.account.executable {
+                    debug!("Error: Move script account not executable");
+                    return Err(InstructionError::AccountNotExecutable);
+                }
+
+                let data_accounts = keyed_accounts_iter.into_slice();
+
+                let mut data_store = Self::keyed_accounts_to_data_store(&data_accounts)?;
+                let verified_script = Self::deserialize_verified_script(&script.account.data)?;
+
+                let output = Self::execute(
+                    sender_address,
+                    &function_name,
+                    args,
+                    verified_script,
+                    &data_store,
+                )?;
+                for event in output.events() {
+                    trace!("Event: {:?}", event);
+                }
+
+                data_store.apply_write_set(&output.write_set());
+                Self::data_store_to_keyed_accounts(data_store, data_accounts)
+            }
+        }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use solana_sdk::account::Account;
+    use solana_sdk::rent::Rent;
+    use solana_sdk::sysvar::rent;
+
+    const BIG_ENOUGH: usize = 10_000;
+
+    #[test]
+    fn test_account_size() {
+        let mut data =
+            vec![0_u8; bincode::serialized_size(&LibraAccountState::Unallocated).unwrap() as usize];
+        let len = data.len();
+        assert_eq!(
+            MoveProcessor::serialize_and_enforce_length(&LibraAccountState::Unallocated, &mut data),
+            Ok(())
+        );
+        assert_eq!(len, data.len());
+
+        data.resize(6000, 0);
+        let len = data.len();
+        assert_eq!(
+            MoveProcessor::serialize_and_enforce_length(&LibraAccountState::Unallocated, &mut data),
+            Ok(())
+        );
+        assert_eq!(len, data.len());
+
+        data.resize(1, 0);
+        assert_eq!(
+            MoveProcessor::serialize_and_enforce_length(&LibraAccountState::Unallocated, &mut data),
+            Err(InstructionError::AccountDataTooSmall)
+        );
+    }
+
+    #[test]
+    fn test_finalize() {
+        solana_logger::setup();
+
+        let code = "main() { return; }";
+        let sender_address = AccountAddress::default();
+        let mut script = LibraAccount::create_script(&sender_address, code, vec![]);
+        let rent_id = rent::id();
+        let mut rent_account = rent::create_account(1, &Rent::default());
+        let mut keyed_accounts = vec![
+            KeyedAccount::new(&script.key, true, &mut script.account),
+            KeyedAccount::new(&rent_id, false, &mut rent_account),
+        ];
+        MoveProcessor::do_finalize(&mut keyed_accounts).unwrap();
+        let _ = MoveProcessor::deserialize_verified_script(&script.account.data).unwrap();
+    }
+
+    #[test]
+    fn test_create_genesis_account() {
+        solana_logger::setup();
+
+        let amount = 10_000_000;
+        let mut unallocated = LibraAccount::create_unallocated(BIG_ENOUGH);
+
+        let mut keyed_accounts = vec![KeyedAccount::new(
+            &unallocated.key,
+            false,
+            &mut unallocated.account,
+        )];
+        MoveProcessor::do_invoke_main(
+            &mut keyed_accounts,
+            &bincode::serialize(&InvokeCommand::CreateGenesis(amount)).unwrap(),
+        )
+        .unwrap();
+
+        assert_eq!(
+            bincode::deserialize::<LibraAccountState>(
+                &LibraAccount::create_genesis(amount).account.data
+            )
+            .unwrap(),
+            bincode::deserialize::<LibraAccountState>(&keyed_accounts[0].account.data).unwrap()
+        );
+    }
+
+    #[test]
+    fn test_invoke_script() {
+        solana_logger::setup();
+
+        let code = "main() { return; }";
+        let sender_address = AccountAddress::default();
+        let mut script = LibraAccount::create_script(&sender_address, code, vec![]);
+        let mut genesis = LibraAccount::create_genesis(1_000_000_000);
+
+        let rent_id = rent::id();
+        let mut rent_account = rent::create_account(1, &Rent::default());
+        let mut keyed_accounts = vec![
+            KeyedAccount::new(&script.key, true, &mut script.account),
+            KeyedAccount::new(&rent_id, false, &mut rent_account),
+        ];
+
+        MoveProcessor::do_finalize(&mut keyed_accounts).unwrap();
+
+        let mut keyed_accounts = vec![
+            KeyedAccount::new(&script.key, true, &mut script.account),
+            KeyedAccount::new(&genesis.key, false, &mut genesis.account),
+        ];
+
+        MoveProcessor::do_invoke_main(
+            &mut keyed_accounts,
+            &bincode::serialize(&InvokeCommand::RunScript {
+                sender_address,
+                function_name: "main".to_string(),
+                args: vec![],
+            })
+            .unwrap(),
+        )
+        .unwrap();
+    }
+
+    #[test]
+    fn test_publish_module() {
+        solana_logger::setup();
+
+        let code = "
+            module M {
+                universal_truth(): u64 {
+                    return 42;
+                }
+            }
+        ";
+        let mut module = LibraAccount::create_module(code, vec![]);
+        let rent_id = rent::id();
+        let mut rent_account = rent::create_account(1, &Rent::default());
+        let mut keyed_accounts = vec![
+            KeyedAccount::new(&module.key, true, &mut module.account),
+            KeyedAccount::new(&rent_id, false, &mut rent_account),
+        ];
+        keyed_accounts[0].account.data.resize(BIG_ENOUGH, 0);
+
+        MoveProcessor::do_finalize(&mut keyed_accounts).unwrap();
+    }
+
+    #[test]
+    fn test_invoke_endless_loop() {
+        solana_logger::setup();
+
+        let code = "
+            main() {
+                loop {}
+                return;
+            }
+        ";
+        let sender_address = AccountAddress::default();
+        let mut script = LibraAccount::create_script(&sender_address, code, vec![]);
+        let mut genesis = LibraAccount::create_genesis(1_000_000_000);
+
+        let rent_id = rent::id();
+        let mut rent_account = rent::create_account(1, &Rent::default());
+        let mut keyed_accounts = vec![
+            KeyedAccount::new(&script.key, true, &mut script.account),
+            KeyedAccount::new(&rent_id, false, &mut rent_account),
+        ];
+
+        MoveProcessor::do_finalize(&mut keyed_accounts).unwrap();
+
+        let mut keyed_accounts = vec![
+            KeyedAccount::new(&script.key, true, &mut script.account),
+            KeyedAccount::new(&genesis.key, false, &mut genesis.account),
+        ];
+
+        assert_eq!(
+            MoveProcessor::do_invoke_main(
+                &mut keyed_accounts,
+                &bincode::serialize(&InvokeCommand::RunScript {
+                    sender_address,
+                    function_name: "main".to_string(),
+                    args: vec![],
+                })
+                .unwrap(),
+            ),
+            Err(InstructionError::CustomError(4002))
+        );
+    }
+
+    #[test]
+    fn test_invoke_mint_to_address() {
+        solana_logger::setup();
+
+        let mut data_store = DataStore::default();
+
+        let amount = 42;
+        let mut accounts = mint_coins(amount).unwrap();
+        let mut accounts_iter = accounts.iter_mut();
+
+        let _script = next_libra_account(&mut accounts_iter).unwrap();
+        let genesis = next_libra_account(&mut accounts_iter).unwrap();
+        let payee = next_libra_account(&mut accounts_iter).unwrap();
+        match bincode::deserialize(&payee.account.data).unwrap() {
+            LibraAccountState::User(owner, write_set) => {
+                if owner != genesis.key {
+                    panic!();
+                }
+                data_store.apply_write_set(&write_set)
+            }
+            _ => panic!("Invalid account state"),
+        }
+
+        let payee_resource = data_store.read_account_resource(&payee.address).unwrap();
+        assert_eq!(amount, payee_resource.balance());
+        assert_eq!(0, payee_resource.sequence_number());
+    }
+
+    #[test]
+    fn test_invoke_pay_from_sender() {
+        solana_logger::setup();
+        let amount_to_mint = 42;
+        let mut accounts = mint_coins(amount_to_mint).unwrap();
+        let mut accounts_iter = accounts.iter_mut();
+
+        let _script = next_libra_account(&mut accounts_iter).unwrap();
+        let genesis = next_libra_account(&mut accounts_iter).unwrap();
+        let sender = next_libra_account(&mut accounts_iter).unwrap();
+
+        let code = "
+            import 0x0.LibraAccount;
+            import 0x0.LibraCoin;
+            main(payee: address, amount: u64) {
+                LibraAccount.pay_from_sender(move(payee), move(amount));
+                return;
+            }
+        ";
+        let mut script = LibraAccount::create_script(&genesis.address, code, vec![]);
+        let mut payee = LibraAccount::create_unallocated(BIG_ENOUGH);
+
+        let rent_id = rent::id();
+        let mut rent_account = rent::create_account(1, &Rent::default());
+        let mut keyed_accounts = vec![
+            KeyedAccount::new(&script.key, true, &mut script.account),
+            KeyedAccount::new(&rent_id, false, &mut rent_account),
+        ];
+
+        MoveProcessor::do_finalize(&mut keyed_accounts).unwrap();
+
+        let mut keyed_accounts = vec![
+            KeyedAccount::new(&script.key, true, &mut script.account),
+            KeyedAccount::new(&genesis.key, false, &mut genesis.account),
+            KeyedAccount::new(&sender.key, false, &mut sender.account),
+            KeyedAccount::new(&payee.key, false, &mut payee.account),
+        ];
+
+        let amount = 2;
+        MoveProcessor::do_invoke_main(
+            &mut keyed_accounts,
+            &bincode::serialize(&InvokeCommand::RunScript {
+                sender_address: sender.address.clone(),
+                function_name: "main".to_string(),
+                args: vec![
+                    TransactionArgument::Address(payee.address.clone()),
+                    TransactionArgument::U64(amount),
+                ],
+            })
+            .unwrap(),
+        )
+        .unwrap();
+
+        let data_store = MoveProcessor::keyed_accounts_to_data_store(&keyed_accounts[1..]).unwrap();
+        let sender_resource = data_store.read_account_resource(&sender.address).unwrap();
+        let payee_resource = data_store.read_account_resource(&payee.address).unwrap();
+
+        assert_eq!(amount_to_mint - amount, sender_resource.balance());
+        assert_eq!(0, sender_resource.sequence_number());
+        assert_eq!(amount, payee_resource.balance());
+        assert_eq!(0, payee_resource.sequence_number());
+    }
+
+    #[test]
+    fn test_invoke_published_module() {
+        solana_logger::setup();
+
+        let universal_truth = 42;
+
+        // First publish the module
+
+        let code = format!(
+            "
+            module M {{
+                public universal_truth(): u64 {{
+                    return {};
+                }}
+            }}
+        ",
+            universal_truth
+        );
+        let mut module = LibraAccount::create_module(&code, vec![]);
+
+        let rent_id = rent::id();
+        let mut rent_account = rent::create_account(1, &Rent::default());
+        let mut keyed_accounts = vec![
+            KeyedAccount::new(&module.key, true, &mut module.account),
+            KeyedAccount::new(&rent_id, false, &mut rent_account),
+        ];
+        keyed_accounts[0].account.data.resize(BIG_ENOUGH, 0);
+
+        MoveProcessor::do_finalize(&mut keyed_accounts).unwrap();
+
+        // Next invoke the published module
+
+        let amount_to_mint = 84;
+        let mut accounts = mint_coins(amount_to_mint).unwrap();
+        let mut accounts_iter = accounts.iter_mut();
+
+        let _script = next_libra_account(&mut accounts_iter).unwrap();
+        let genesis = next_libra_account(&mut accounts_iter).unwrap();
+        let sender = next_libra_account(&mut accounts_iter).unwrap();
+
+        let code = format!(
+            "
+                import 0x0.LibraAccount;
+                import 0x0.LibraCoin;
+                import 0x{}.M;
+                
+                main(payee: address) {{
+                    let amount: u64;
+                    amount = M.universal_truth();
+                    LibraAccount.pay_from_sender(move(payee), move(amount));
+                    return;
+                }}
+            ",
+            module.address
+        );
+        let mut script =
+            LibraAccount::create_script(&genesis.address, &code, vec![&module.account.data]);
+        let mut payee = LibraAccount::create_unallocated(BIG_ENOUGH);
+
+        let rent_id = rent::id();
+        let mut rent_account = rent::create_account(1, &Rent::default());
+        let mut keyed_accounts = vec![
+            KeyedAccount::new(&script.key, true, &mut script.account),
+            KeyedAccount::new(&rent_id, false, &mut rent_account),
+        ];
+
+        MoveProcessor::do_finalize(&mut keyed_accounts).unwrap();
+
+        let mut keyed_accounts = vec![
+            KeyedAccount::new(&script.key, true, &mut script.account),
+            KeyedAccount::new(&genesis.key, false, &mut genesis.account),
+            KeyedAccount::new(&sender.key, false, &mut sender.account),
+            KeyedAccount::new(&module.key, false, &mut module.account),
+            KeyedAccount::new(&payee.key, false, &mut payee.account),
+        ];
+
+        MoveProcessor::do_invoke_main(
+            &mut keyed_accounts,
+            &bincode::serialize(&InvokeCommand::RunScript {
+                sender_address: sender.address.clone(),
+                function_name: "main".to_string(),
+                args: vec![TransactionArgument::Address(payee.address.clone())],
+            })
+            .unwrap(),
+        )
+        .unwrap();
+
+        let data_store = MoveProcessor::keyed_accounts_to_data_store(&keyed_accounts[1..]).unwrap();
+        let sender_resource = data_store.read_account_resource(&sender.address).unwrap();
+        let payee_resource = data_store.read_account_resource(&payee.address).unwrap();
+
+        assert_eq!(amount_to_mint - universal_truth, sender_resource.balance());
+        assert_eq!(0, sender_resource.sequence_number());
+        assert_eq!(universal_truth, payee_resource.balance());
+        assert_eq!(0, payee_resource.sequence_number());
+    }
+
+    // Helpers
+
+    fn mint_coins(amount: u64) -> Result<Vec<LibraAccount>, InstructionError> {
+        let code = "
+            import 0x0.LibraAccount;
+            import 0x0.LibraCoin;
+            main(payee: address, amount: u64) {
+                LibraAccount.mint_to_address(move(payee), move(amount));
+                return;
+            }
+        ";
+        let mut genesis = LibraAccount::create_genesis(1_000_000_000);
+        let mut script = LibraAccount::create_script(&genesis.address.clone(), code, vec![]);
+        let mut payee = LibraAccount::create_unallocated(BIG_ENOUGH);
+
+        let rent_id = rent::id();
+        let mut rent_account = rent::create_account(1, &Rent::default());
+        let mut keyed_accounts = vec![
+            KeyedAccount::new(&script.key, true, &mut script.account),
+            KeyedAccount::new(&rent_id, false, &mut rent_account),
+        ];
+
+        MoveProcessor::do_finalize(&mut keyed_accounts).unwrap();
+
+        let mut keyed_accounts = vec![
+            KeyedAccount::new(&script.key, true, &mut script.account),
+            KeyedAccount::new(&genesis.key, false, &mut genesis.account),
+            KeyedAccount::new(&payee.key, false, &mut payee.account),
+        ];
+
+        MoveProcessor::do_invoke_main(
+            &mut keyed_accounts,
+            &bincode::serialize(&InvokeCommand::RunScript {
+                sender_address: account_config::association_address(),
+                function_name: "main".to_string(),
+                args: vec![
+                    TransactionArgument::Address(pubkey_to_address(&payee.key)),
+                    TransactionArgument::U64(amount),
+                ],
+            })
+            .unwrap(),
+        )
+        .unwrap();
+
+        Ok(vec![
+            LibraAccount::new(script.key, script.account),
+            LibraAccount::new(genesis.key, genesis.account),
+            LibraAccount::new(payee.key, payee.account),
+        ])
+    }
+
+    #[derive(Eq, PartialEq, Debug, Default)]
+    struct LibraAccount {
+        pub key: Pubkey,
+        pub address: AccountAddress,
+        pub account: Account,
+    }
+
+    pub fn next_libra_account<I: Iterator>(iter: &mut I) -> Result<I::Item, InstructionError> {
+        iter.next().ok_or(InstructionError::NotEnoughAccountKeys)
+    }
+
+    impl LibraAccount {
+        pub fn new(key: Pubkey, account: Account) -> Self {
+            let address = pubkey_to_address(&key);
+            Self {
+                key,
+                address,
+                account,
+            }
+        }
+
+        pub fn create_unallocated(size: usize) -> Self {
+            let key = Pubkey::new_rand();
+            let mut account = Account {
+                lamports: 1,
+                data: bincode::serialize(&LibraAccountState::create_unallocated()).unwrap(),
+                owner: id(),
+                ..Account::default()
+            };
+            if account.data.len() < size {
+                account.data.resize(size, 0);
+            }
+
+            Self::new(key, account)
+        }
+
+        pub fn create_genesis(amount: u64) -> Self {
+            let account = Account {
+                lamports: 1,
+                owner: id(),
+                ..Account::default()
+            };
+            let mut genesis = Self::new(Pubkey::new_rand(), account);
+            let pre_data = LibraAccountState::create_genesis(amount).unwrap();
+            let _hi = "hello";
+            genesis.account.data = bincode::serialize(&pre_data).unwrap();
+            genesis
+        }
+
+        pub fn create_script(
+            sender_address: &AccountAddress,
+            code: &str,
+            deps: Vec<&Vec<u8>>,
+        ) -> Self {
+            let mut script = Self::create_unallocated(0);
+            script.account.data = bincode::serialize(&LibraAccountState::create_script(
+                sender_address,
+                code,
+                deps,
+            ))
+            .unwrap();
+
+            script
+        }
+
+        pub fn create_module(code: &str, deps: Vec<&Vec<u8>>) -> Self {
+            let mut module = Self::create_unallocated(0);
+            module.account.data = bincode::serialize(&LibraAccountState::create_module(
+                &module.address,
+                code,
+                deps,
+            ))
+            .unwrap();
+
+            module
+        }
+    }
+}