From 02dd5e9104e38a0bd370d67c4e6a59b3fa46651a Mon Sep 17 00:00:00 2001 From: green Date: Wed, 15 Mar 2023 23:57:56 +0000 Subject: [PATCH] Merge with master --- fuel-asm/src/panic_reason.rs | 23 ++++--- fuel-tx/src/transaction.rs | 7 ++- fuel-tx/src/transaction/id.rs | 9 ++- fuel-tx/src/transaction/types/input.rs | 16 ++--- fuel-tx/src/transaction/types/input/coin.rs | 7 +-- .../src/transaction/types/input/contract.rs | 5 +- .../src/transaction/types/input/message.rs | 18 ++++-- .../transaction/types/input/ser_de_tests.rs | 2 +- fuel-tx/tests/offset.rs | 9 --- fuel-tx/tests/valid_cases/input.rs | 2 +- fuel-types/src/types.rs | 9 +++ fuel-vm/src/interpreter/blockchain.rs | 43 ++++--------- .../src/interpreter/blockchain/smo_tests.rs | 61 +------------------ fuel-vm/src/interpreter/diff/tests.rs | 8 +-- fuel-vm/src/interpreter/internal.rs | 13 +--- fuel-vm/tests/encoding.rs | 23 ++++++- 16 files changed, 100 insertions(+), 155 deletions(-) diff --git a/fuel-asm/src/panic_reason.rs b/fuel-asm/src/panic_reason.rs index c89281a120..acbae9d2ee 100644 --- a/fuel-asm/src/panic_reason.rs +++ b/fuel-asm/src/panic_reason.rs @@ -72,13 +72,13 @@ pub enum PanicReason { /// The jump instruction cannot move backwards in predicate verification. IllegalJump = 0x1f, /// The contract ID is already deployed and can't be overwritten. - ContractIdAlreadyDeployed = 0x22, + ContractIdAlreadyDeployed = 0x20, /// The loaded contract mismatch expectations. - ContractMismatch = 0x23, + ContractMismatch = 0x21, /// No more nested calls are allowed. - NestedCallLimitReached = 0x24, + NestedCallLimitReached = 0x22, /// The byte can't be mapped to any known `PanicReason`. - UnknownPanicReason = 0x25, + UnknownPanicReason = 0x23, } impl fmt::Display for PanicReason { @@ -137,11 +137,9 @@ impl From for PanicReason { 0x1d => ExpectedOutputVariable, 0x1e => ExpectedParentInternalContext, 0x1f => IllegalJump, - 0x20 => NonZeroMessageOutputRecipient, - 0x21 => ZeroedMessageOutputRecipient, - 0x22 => ContractIdAlreadyDeployed, - 0x23 => ContractMismatch, - 0x24 => NestedCallLimitReached, + 0x20 => ContractIdAlreadyDeployed, + 0x21 => ContractMismatch, + 0x22 => NestedCallLimitReached, _ => UnknownPanicReason, } } @@ -168,15 +166,16 @@ mod tests { #[test] fn test_u8_panic_reason_round_trip() { - for i in 0..0x25 { + const LAST_PANIC_REASON: u8 = 0x23; + for i in 0..LAST_PANIC_REASON { let reason = PanicReason::from(i); let i2 = reason as u8; assert_eq!(i, i2); } - for i in 0x25..=255 { + for i in LAST_PANIC_REASON..=255 { let reason = PanicReason::from(i); let i2 = reason as u8; - assert_eq!(0x25, i2); + assert_eq!(LAST_PANIC_REASON, i2); } } } diff --git a/fuel-tx/src/transaction.rs b/fuel-tx/src/transaction.rs index 316a3587c3..2c508a7a83 100644 --- a/fuel-tx/src/transaction.rs +++ b/fuel-tx/src/transaction.rs @@ -30,7 +30,7 @@ use crate::TxPointer; use crate::input::coin::{CoinPredicate, CoinSigned}; use crate::input::contract::Contract; -use crate::input::message::MessagePredicate; +use crate::input::message::MetadataPredicate; use input::*; #[cfg(feature = "std")] @@ -214,7 +214,10 @@ pub trait Executable: field::Inputs + field::Outputs + field::Witnesses { .filter_map(|input| match input { Input::CoinPredicate(CoinPredicate { asset_id, .. }) | Input::CoinSigned(CoinSigned { asset_id, .. }) => Some(asset_id), - Input::MetadataPredicate(_) | Input::MetadataSigned(_) => Some(&AssetId::BASE), + Input::DepositCoinSigned(_) + | Input::DepositCoinPredicate(_) + | Input::MetadataPredicate(_) + | Input::MetadataSigned(_) => Some(&AssetId::BASE), _ => None, }) .collect_vec() diff --git a/fuel-tx/src/transaction/id.rs b/fuel-tx/src/transaction/id.rs index 75cd00e901..28e91bf028 100644 --- a/fuel-tx/src/transaction/id.rs +++ b/fuel-tx/src/transaction/id.rs @@ -1,6 +1,6 @@ -use crate::{field, Input, Transaction}; use crate::input::coin::CoinSigned; -use crate::input::message::MetadataSigned; +use crate::input::message::{DepositCoinSigned, MetadataSigned}; +use crate::{field, Input, Transaction}; use fuel_crypto::{Message, PublicKey, SecretKey, Signature}; use fuel_types::Bytes32; @@ -53,6 +53,11 @@ where Input::CoinSigned(CoinSigned { owner, witness_index, .. }) + | Input::DepositCoinSigned(DepositCoinSigned { + recipient: owner, + witness_index, + .. + }) | Input::MetadataSigned(MetadataSigned { recipient: owner, witness_index, diff --git a/fuel-tx/src/transaction/types/input.rs b/fuel-tx/src/transaction/types/input.rs index 7e81fd1ec2..dad7d91a6d 100644 --- a/fuel-tx/src/transaction/types/input.rs +++ b/fuel-tx/src/transaction/types/input.rs @@ -266,10 +266,10 @@ impl Input { Self::CoinSigned(CoinSigned { utxo_id, .. }) | Self::CoinPredicate(CoinPredicate { utxo_id, .. }) | Self::Contract(Contract { utxo_id, .. }) => Some(utxo_id), - Self::DepositCoinSigned { .. } => None, - Self::DepositCoinPredicate { .. } => None, - Self::MetadataSigned { .. } => None, - Self::MetadataPredicate { .. } => None, + Self::DepositCoinSigned(_) => None, + Self::DepositCoinPredicate(_) => None, + Self::MetadataSigned(_) => None, + Self::MetadataPredicate(_) => None, } } @@ -630,9 +630,11 @@ impl io::Read for Input { let _ = contract.read(&mut full_buf[WORD_SIZE..])?; } - bytes::store_number(ident_buf, InputRepr::Message as Word); + Self::DepositCoinSigned(message) => { + bytes::store_number(ident_buf, InputRepr::Message as Word); let _ = message.read(&mut full_buf[WORD_SIZE..])?; } + Self::DepositCoinPredicate(message) => { bytes::store_number(ident_buf, InputRepr::Message as Word); let _ = message.read(&mut full_buf[WORD_SIZE..])?; @@ -687,8 +689,8 @@ impl io::Write for Input { } InputRepr::Message => { - let mut message = MessageFull::default(); - let n = WORD_SIZE + MessageFull::write(&mut message, &full_buf[WORD_SIZE..])?; + let mut message = FullMessage::default(); + let n = WORD_SIZE + FullMessage::write(&mut message, &full_buf[WORD_SIZE..])?; *self = match (message.data.is_empty(), message.predicate.is_empty()) { (true, true) => Self::DepositCoinSigned(message.into_coin_signed()), diff --git a/fuel-tx/src/transaction/types/input/coin.rs b/fuel-tx/src/transaction/types/input/coin.rs index 9ad830461b..0a26bdc0c7 100644 --- a/fuel-tx/src/transaction/types/input/coin.rs +++ b/fuel-tx/src/transaction/types/input/coin.rs @@ -1,9 +1,8 @@ -use crate::transaction::types::input::consts::INPUT_COIN_FIXED_SIZE; +use crate::input::sizes::CoinSizes; use crate::transaction::types::input::AsField; use crate::{TxPointer, UtxoId}; -use fuel_types::bytes::Deserializable; -use fuel_types::bytes::{SizedBytes, WORD_SIZE}; -use fuel_types::{bytes, Address, AssetId, Word}; +use fuel_types::bytes::{Deserializable, SizedBytes}; +use fuel_types::{bytes, Address, AssetId, MemLayout, MemLocType, Word}; pub type CoinFull = Coin; pub type CoinSigned = Coin; diff --git a/fuel-tx/src/transaction/types/input/contract.rs b/fuel-tx/src/transaction/types/input/contract.rs index f6328ecd35..d9205dcd17 100644 --- a/fuel-tx/src/transaction/types/input/contract.rs +++ b/fuel-tx/src/transaction/types/input/contract.rs @@ -1,8 +1,7 @@ -use crate::transaction::types::input::consts::INPUT_CONTRACT_SIZE; +use crate::input::sizes::ContractSizes; use crate::{TxPointer, UtxoId}; -use fuel_types::bytes::{Deserializable, SizedBytes, WORD_SIZE}; +use fuel_types::bytes::{Deserializable, SizedBytes}; use fuel_types::{bytes, Bytes32, ContractId, MemLayout, MemLocType, Word}; -use crate::input::sizes::ContractSizes; /// It is a full representation of the contract input from the specification: /// https://github.com/FuelLabs/fuel-specs/blob/master/src/protocol/tx_format/input.md#inputcontract. diff --git a/fuel-tx/src/transaction/types/input/message.rs b/fuel-tx/src/transaction/types/input/message.rs index da2717b78b..81b51f0839 100644 --- a/fuel-tx/src/transaction/types/input/message.rs +++ b/fuel-tx/src/transaction/types/input/message.rs @@ -1,7 +1,7 @@ -use crate::transaction::types::input::consts::INPUT_MESSAGE_FIXED_SIZE; +use crate::input::sizes::MessageSizes; use crate::transaction::types::input::AsField; -use fuel_types::bytes::{SizedBytes, WORD_SIZE}; -use fuel_types::{bytes, Address, MessageId, Word}; +use fuel_types::bytes::SizedBytes; +use fuel_types::{bytes, Address, MemLayout, MemLocType, MessageId, Word}; pub type FullMessage = Message; pub type MetadataSigned = Message>; @@ -219,11 +219,11 @@ where bytes::store_number_at(buf, S::layout(S::LAYOUT.witness_index), witness_index); let data_size = if let Some(data) = data.as_field() { - data.as_field() + data.len() } else { 0 }; - bytes::store_number_at(buf, S::layout(S::LAYOUT.data_len), data_size); + bytes::store_number_at(buf, S::layout(S::LAYOUT.data_len), data_size as Word); let predicate_len = if let Some(predicate) = predicate.as_field() { predicate.len() @@ -239,7 +239,13 @@ where }; bytes::store_number_at(buf, S::layout(S::LAYOUT.predicate_data_len), predicate_data_len as Word); - let (_, buf) = bytes::store_raw_bytes(full_buf.get_mut(LEN..).ok_or(bytes::eof())?, data.as_slice())?; + let buf = full_buf.get_mut(LEN..).ok_or(bytes::eof())?; + let buf = if let Some(data) = data.as_field() { + let (_, buf) = bytes::store_raw_bytes(buf, data.as_slice())?; + buf + } else { + buf + }; let buf = if let Some(predicate) = predicate.as_field() { let (_, buf) = bytes::store_raw_bytes(buf, predicate.as_slice())?; diff --git a/fuel-tx/src/transaction/types/input/ser_de_tests.rs b/fuel-tx/src/transaction/types/input/ser_de_tests.rs index 473c302936..ee5c859e55 100644 --- a/fuel-tx/src/transaction/types/input/ser_de_tests.rs +++ b/fuel-tx/src/transaction/types/input/ser_de_tests.rs @@ -7,7 +7,7 @@ use fuel_types::MemLayout; #[test] fn test_input_serialization() { const DATA_SIZE: usize = 16; - let mut input = Input::message_predicate( + let mut input = Input::metadata_predicate( MessageId::from([1u8; 32]), Address::from([2u8; 32]), Address::from([3u8; 32]), diff --git a/fuel-tx/tests/offset.rs b/fuel-tx/tests/offset.rs index 5f9bdb2002..35d20de54e 100644 --- a/fuel-tx/tests/offset.rs +++ b/fuel-tx/tests/offset.rs @@ -257,15 +257,6 @@ fn outputs_assert(tx: &Tx, bytes: &[u8], cases: &mut TestedFields) assert_eq!(contract_id, contract_id_p); } - - if let Some(recipient) = o.recipient() { - cases.output_recipient = true; - - let ofs = output_ofs + o.repr().recipient_offset().expect("output have recipient"); - let recipient_p = Address::from_bytes_ref_checked(&bytes[ofs..ofs + Address::LEN]).unwrap(); - - assert_eq!(recipient, recipient_p); - } }); } diff --git a/fuel-tx/tests/valid_cases/input.rs b/fuel-tx/tests/valid_cases/input.rs index c368219851..d1eb872a29 100644 --- a/fuel-tx/tests/valid_cases/input.rs +++ b/fuel-tx/tests/valid_cases/input.rs @@ -20,7 +20,7 @@ fn input_coin_message_signature() { .iter() .enumerate() .try_for_each(|(index, input)| match input { - Input::CoinSigned { .. } | Input::MetadataSigned { .. } => { + Input::CoinSigned(_) | Input::DepositCoinSigned(_) | Input::MetadataSigned(_) => { input.check(index, &txhash, outputs, witnesses, &Default::default()) } _ => Ok(()), diff --git a/fuel-types/src/types.rs b/fuel-types/src/types.rs index f5e94b7bf8..a580450bcd 100644 --- a/fuel-types/src/types.rs +++ b/fuel-types/src/types.rs @@ -298,6 +298,7 @@ key!(Bytes4, 4); key!(Bytes8, 8); key!(Bytes20, 20); key!(Bytes32, 32); +key!(Nonce, 32); key!(MessageId, 32); key!(Salt, 32); @@ -314,3 +315,11 @@ impl AssetId { /// The base native asset of the Fuel protocol. pub const BASE: AssetId = AssetId::zeroed(); } + +impl From for Nonce { + fn from(value: u64) -> Self { + let mut default = [0u8; 32]; + default[..8].copy_from_slice(&value.to_be_bytes()[..]); + default.into() + } +} diff --git a/fuel-vm/src/interpreter/blockchain.rs b/fuel-vm/src/interpreter/blockchain.rs index 8034daa925..47961286fa 100644 --- a/fuel-vm/src/interpreter/blockchain.rs +++ b/fuel-vm/src/interpreter/blockchain.rs @@ -1,28 +1,27 @@ use super::contract::{balance, contract_size}; use super::gas::{dependent_gas_charge, ProfileGas}; use super::internal::{ - absolute_output_mem_range, append_receipt, base_asset_balance_sub, current_contract, inc_pc, internal_contract, - internal_contract_bounds, set_message_output, tx_id, AppendReceipt, + append_receipt, base_asset_balance_sub, current_contract, inc_pc, internal_contract, internal_contract_bounds, + tx_id, AppendReceipt, }; use super::memory::{try_mem_write, try_zeroize, OwnershipRegisters}; use super::{ExecutableTransaction, Interpreter, MemoryRange, RuntimeBalances}; +use crate::arith::{add_usize, checked_add_usize, checked_add_word, checked_sub_word}; use crate::call::CallFrame; use crate::constraints::{reg_key::*, CheckedMemConstLen, CheckedMemRange, CheckedMemValue}; use crate::context::Context; use crate::error::{Bug, BugId, BugVariant, RuntimeError}; use crate::gas::DependentCost; +use crate::interpreter::PanicContext; use crate::prelude::Profiler; use crate::storage::{ContractsAssets, ContractsAssetsStorage, ContractsRawCode, InterpreterStorage}; use crate::{arith, consts::*}; use fuel_asm::PanicReason; use fuel_storage::{StorageInspect, StorageSize}; -use fuel_tx::{Output, Receipt}; -use fuel_types::bytes::{self, Deserializable}; +use fuel_tx::Receipt; +use fuel_types::bytes; use fuel_types::{Address, AssetId, Bytes32, ContractId, RegisterId, Word}; - -use crate::arith::{add_usize, checked_add_usize, checked_add_word, checked_sub_word}; -use crate::interpreter::PanicContext; use std::borrow::Borrow; use std::ops::Range; @@ -667,6 +666,11 @@ pub(crate) fn timestamp( inc_pc(pc) } +// TODO: Register b is the address of the begin of the data and register c +// is the end of the data(Based on the specification). +// The user doesn't specify the output index for message. +// We need to use the index of the receipt to calculate the `Nonce`. +// Add unit tests for a new usage. struct MessageOutputCtx<'vm, Tx> { max_message_data_length: u64, memory: &'vm mut [u8; MEM_SIZE], @@ -681,6 +685,7 @@ struct MessageOutputCtx<'vm, Tx> { /// B call_abi_len: Word, /// C + #[allow(dead_code)] message_output_idx: Word, /// D amount_coins_to_send: Word, @@ -703,19 +708,6 @@ impl MessageOutputCtx<'_, Tx> { let recipient = recipient_address.try_from(self.memory)?; - if recipient == Address::zeroed() { - return Err(PanicReason::ZeroedMessageOutputRecipient.into()); - } - - let output = absolute_output_mem_range(self.tx, self.tx_offset, self.message_output_idx as usize, None)? - .ok_or(PanicReason::OutputNotFound)?; - let output = Output::from_bytes(output.read(self.memory))?; - - // amount isn't checked because we are allowed to send zero balances with a message - if !matches!(output, Output::Message { recipient, .. } if recipient == Address::zeroed()) { - return Err(PanicReason::NonZeroMessageOutputRecipient.into()); - } - // validations passed, perform the mutations base_asset_balance_sub(self.balances, self.memory, self.amount_coins_to_send)?; @@ -725,24 +717,15 @@ impl MessageOutputCtx<'_, Tx> { let call_abi = call_abi.read(self.memory).to_vec(); let sender = Address::from_bytes_ref(sender.read(self.memory)); - let message = Output::message(recipient, self.amount_coins_to_send); let receipt = Receipt::message_out_from_tx_output( txid, - self.message_output_idx, + self.receipts.len() as Word, *sender, recipient, self.amount_coins_to_send, call_abi, ); - set_message_output( - self.tx, - self.memory, - self.tx_offset, - self.message_output_idx as usize, - message, - )?; - append_receipt( AppendReceipt { receipts: self.receipts, diff --git a/fuel-vm/src/interpreter/blockchain/smo_tests.rs b/fuel-vm/src/interpreter/blockchain/smo_tests.rs index 16fca64d36..eedbf65c89 100644 --- a/fuel-vm/src/interpreter/blockchain/smo_tests.rs +++ b/fuel-vm/src/interpreter/blockchain/smo_tests.rs @@ -2,9 +2,8 @@ use crate::interpreter::memory::Memory; use crate::interpreter::InitialBalances; use super::*; -use fuel_tx::field::Outputs; + use fuel_tx::Create; -use fuel_types::bytes::SizedBytes; use test_case::test_case; struct Input { @@ -17,7 +16,6 @@ struct Input { /// D amount_coins_to_send: Word, max_message_data_length: Word, - message_output: fuel_tx::Output, memory: Vec<(usize, Vec)>, balance: InitialBalances, } @@ -27,12 +25,6 @@ struct Output { receipts: Vec, } -fn output_bytes(mut output: fuel_tx::Output) -> Vec { - let mut buf = vec![0u8; output.serialized_size()]; - std::io::Read::read(&mut output, &mut buf).unwrap(); - buf -} - impl Default for Input { fn default() -> Self { Self { @@ -40,11 +32,7 @@ impl Default for Input { call_abi_len: Default::default(), message_output_idx: Default::default(), amount_coins_to_send: Default::default(), - message_output: fuel_tx::Output::message(Address::zeroed(), 0), - memory: vec![ - (112, output_bytes(fuel_tx::Output::message(Address::zeroed(), 0))), - (400, Address::from([1u8; 32]).to_vec()), - ], + memory: vec![(400, Address::from([1u8; 32]).to_vec())], max_message_data_length: 100, balance: Default::default(), } @@ -104,17 +92,6 @@ impl Default for Input { } => Err(RuntimeError::Recoverable(PanicReason::MemoryOverflow)) ; "call abi length > max message data length" )] -#[test_case( - Input { - recipient_mem_address: 400, - call_abi_len: 10, - message_output_idx: 1, - amount_coins_to_send: 0, - max_message_data_length: 100, - ..Default::default() - } => Err(RuntimeError::Recoverable(PanicReason::OutputNotFound)) - ; "message index out of bounds" -)] #[test_case( Input { recipient_mem_address: 400, @@ -127,45 +104,12 @@ impl Default for Input { ; "amount coins to send > balance" )] // TODO: Test the above on an internal context -#[test_case( - Input { - recipient_mem_address: 400, - call_abi_len: 10, - message_output_idx: 0, - amount_coins_to_send: 0, - message_output: fuel_tx::Output::coin(Address::zeroed(), 0, Default::default()), - ..Default::default() - } => Err(RuntimeError::Recoverable(PanicReason::NonZeroMessageOutputRecipient)) - ; "wrong output type" -)] -#[test_case( - Input { - recipient_mem_address: 4000, - call_abi_len: 10, - message_output_idx: 0, - amount_coins_to_send: 0, - ..Default::default() - } => Err(RuntimeError::Recoverable(PanicReason::ZeroedMessageOutputRecipient)) - ; "receipt address in memory == 0" -)] -#[test_case( - Input { - recipient_mem_address: 400, - call_abi_len: 10, - message_output_idx: 0, - amount_coins_to_send: 0, - message_output: fuel_tx::Output::message(Address::from([1u8; 32]), 0), - ..Default::default() - } => Err(RuntimeError::Recoverable(PanicReason::NonZeroMessageOutputRecipient)) - ; "output message not zeroed out" -)] fn test_smo( Input { recipient_mem_address, call_abi_len, message_output_idx, amount_coins_to_send, - message_output, memory: mem, max_message_data_length, balance, @@ -177,7 +121,6 @@ fn test_smo( } let mut receipts = Vec::default(); let mut tx = Create::default(); - *tx.outputs_mut() = vec![message_output]; let mut balances = RuntimeBalances::from(balance); let fp = 0; let mut pc = 0; diff --git a/fuel-vm/src/interpreter/diff/tests.rs b/fuel-vm/src/interpreter/diff/tests.rs index be8477c17e..221d20980f 100644 --- a/fuel-vm/src/interpreter/diff/tests.rs +++ b/fuel-vm/src/interpreter/diff/tests.rs @@ -202,12 +202,12 @@ fn reset_vm_memory() { #[test] fn reset_vm_txns() { + use fuel_tx::field::Outputs; let a = Interpreter::<_, Script>::with_memory_storage(); let mut b = Interpreter::<_, Script>::with_memory_storage(); - b.tx.outputs_mut().push(fuel_tx::Output::Message { - recipient: Address::zeroed(), - amount: 1, - asset_id: AssetId::zeroed(), + b.tx.outputs_mut().push(fuel_tx::Output::ContractCreated { + contract_id: Default::default(), + state_root: Default::default(), }); let diff: Diff = a.diff(&b).into(); assert_ne!(a, b); diff --git a/fuel-vm/src/interpreter/internal.rs b/fuel-vm/src/interpreter/internal.rs index 25a3e5e98f..16b917d3fe 100644 --- a/fuel-vm/src/interpreter/internal.rs +++ b/fuel-vm/src/interpreter/internal.rs @@ -8,7 +8,7 @@ use crate::crypto; use crate::error::RuntimeError; use fuel_asm::{Flags, Instruction, PanicReason, RegId}; -use fuel_tx::field::ReceiptsRoot; +use fuel_tx::field::{Outputs, ReceiptsRoot}; use fuel_tx::Script; use fuel_tx::{Output, Receipt}; use fuel_types::bytes::SerializableVec; @@ -56,17 +56,6 @@ pub(crate) fn set_variable_output( update_memory_output(tx, memory, tx_offset, idx) } -pub(crate) fn set_message_output( - tx: &mut Tx, - memory: &mut [u8; MEM_SIZE], - tx_offset: usize, - idx: usize, - message: Output, -) -> Result<(), RuntimeError> { - tx.replace_message_output(idx, message)?; - update_memory_output(tx, memory, tx_offset, idx) -} - fn absolute_output_offset(tx: &Tx, tx_offset: usize, idx: usize) -> Option { tx.outputs_offset_at(idx).map(|offset| tx_offset + offset) } diff --git a/fuel-vm/tests/encoding.rs b/fuel-vm/tests/encoding.rs index ae31c83127..df02ac1c1d 100644 --- a/fuel-vm/tests/encoding.rs +++ b/fuel-vm/tests/encoding.rs @@ -122,7 +122,24 @@ fn input() { vec![0xdd; 50], vec![], ), - Input::message_signed( + Input::deposit_coin_signed( + [0xaa; 32].into(), + [0xbb; 32].into(), + [0xcc; 32].into(), + Word::MAX, + Word::MAX, + 0xff, + ), + Input::deposit_coin_predicate( + [0xaa; 32].into(), + [0xbb; 32].into(), + [0xcc; 32].into(), + Word::MAX, + Word::MAX, + vec![0xee; 50], + vec![0xff; 23], + ), + Input::metadata_signed( [0xaa; 32].into(), [0xbb; 32].into(), [0xcc; 32].into(), @@ -131,7 +148,7 @@ fn input() { 0xff, vec![0xdd; 50], ), - Input::message_predicate( + Input::metadata_predicate( [0xaa; 32].into(), [0xbb; 32].into(), [0xcc; 32].into(), @@ -141,7 +158,7 @@ fn input() { vec![0xee; 50], vec![0xff; 23], ), - Input::message_predicate( + Input::metadata_predicate( [0xaa; 32].into(), [0xbb; 32].into(), [0xcc; 32].into(),