2019-03-24 20:20:34 -07:00
|
|
|
//! A library for generating a message from a sequence of instructions
|
2019-03-24 20:06:02 -07:00
|
|
|
|
2019-03-24 19:55:32 -07:00
|
|
|
use crate::hash::Hash;
|
2019-05-07 18:48:31 -07:00
|
|
|
use crate::instruction::{AccountMeta, CompiledInstruction, Instruction};
|
2019-03-24 19:55:32 -07:00
|
|
|
use crate::pubkey::Pubkey;
|
2019-03-25 08:15:16 -07:00
|
|
|
use crate::short_vec;
|
2019-03-24 20:06:02 -07:00
|
|
|
use itertools::Itertools;
|
|
|
|
|
|
|
|
fn position(keys: &[Pubkey], key: &Pubkey) -> u8 {
|
|
|
|
keys.iter().position(|k| k == key).unwrap() as u8
|
|
|
|
}
|
|
|
|
|
2019-05-22 15:23:16 -07:00
|
|
|
fn compile_instruction(ix: Instruction, keys: &[Pubkey]) -> CompiledInstruction {
|
2019-03-24 20:06:02 -07:00
|
|
|
let accounts: Vec<_> = ix
|
|
|
|
.accounts
|
|
|
|
.iter()
|
|
|
|
.map(|account_meta| position(keys, &account_meta.pubkey))
|
|
|
|
.collect();
|
|
|
|
|
|
|
|
CompiledInstruction {
|
2019-05-22 15:23:16 -07:00
|
|
|
program_ids_index: position(keys, &ix.program_ids_index),
|
2019-03-24 20:06:02 -07:00
|
|
|
data: ix.data.clone(),
|
|
|
|
accounts,
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2019-05-22 15:23:16 -07:00
|
|
|
fn compile_instructions(ixs: Vec<Instruction>, keys: &[Pubkey]) -> Vec<CompiledInstruction> {
|
2019-03-24 20:20:34 -07:00
|
|
|
ixs.into_iter()
|
2019-05-22 15:23:16 -07:00
|
|
|
.map(|ix| compile_instruction(ix, keys))
|
2019-03-24 20:06:02 -07:00
|
|
|
.collect()
|
|
|
|
}
|
|
|
|
|
2019-03-24 20:20:34 -07:00
|
|
|
/// Return pubkeys referenced by all instructions, with the ones needing signatures first.
|
2019-05-07 18:48:31 -07:00
|
|
|
/// If the payer key is provided, it is always placed first in the list of signed keys.
|
2019-03-24 20:20:34 -07:00
|
|
|
/// No duplicates and order is preserved.
|
2019-05-07 18:48:31 -07:00
|
|
|
fn get_keys(instructions: &[Instruction], payer: Option<&Pubkey>) -> (Vec<Pubkey>, Vec<Pubkey>) {
|
2019-03-24 20:20:34 -07:00
|
|
|
let mut keys_and_signed: Vec<_> = instructions
|
|
|
|
.iter()
|
|
|
|
.flat_map(|ix| ix.accounts.iter())
|
|
|
|
.collect();
|
|
|
|
keys_and_signed.sort_by(|x, y| y.is_signer.cmp(&x.is_signer));
|
|
|
|
|
2019-05-07 18:48:31 -07:00
|
|
|
let payer_account_meta;
|
|
|
|
if let Some(payer) = payer {
|
|
|
|
payer_account_meta = AccountMeta {
|
|
|
|
pubkey: *payer,
|
|
|
|
is_signer: true,
|
|
|
|
};
|
|
|
|
keys_and_signed.insert(0, &payer_account_meta);
|
|
|
|
}
|
|
|
|
|
2019-03-24 20:20:34 -07:00
|
|
|
let mut signed_keys = vec![];
|
|
|
|
let mut unsigned_keys = vec![];
|
|
|
|
for account_meta in keys_and_signed.into_iter().unique_by(|x| x.pubkey) {
|
|
|
|
if account_meta.is_signer {
|
|
|
|
signed_keys.push(account_meta.pubkey);
|
|
|
|
} else {
|
|
|
|
unsigned_keys.push(account_meta.pubkey);
|
2019-03-24 20:06:02 -07:00
|
|
|
}
|
|
|
|
}
|
2019-03-24 20:20:34 -07:00
|
|
|
(signed_keys, unsigned_keys)
|
|
|
|
}
|
2019-03-24 20:06:02 -07:00
|
|
|
|
2019-03-24 20:20:34 -07:00
|
|
|
/// Return program ids referenced by all instructions. No duplicates and order is preserved.
|
|
|
|
fn get_program_ids(instructions: &[Instruction]) -> Vec<Pubkey> {
|
|
|
|
instructions
|
|
|
|
.iter()
|
|
|
|
.map(|ix| ix.program_ids_index)
|
|
|
|
.unique()
|
|
|
|
.collect()
|
2019-03-24 20:06:02 -07:00
|
|
|
}
|
2019-03-24 19:55:32 -07:00
|
|
|
|
2019-05-22 15:23:16 -07:00
|
|
|
#[derive(Serialize, Deserialize, Default, Debug, PartialEq, Eq, Clone)]
|
|
|
|
pub struct MessageHeader {
|
2019-03-29 12:21:32 -07:00
|
|
|
/// The number of signatures required for this message to be considered valid. The
|
|
|
|
/// signatures must match the first `num_required_signatures` of `account_keys`.
|
|
|
|
pub num_required_signatures: u8,
|
2019-03-29 09:05:06 -07:00
|
|
|
|
2019-05-22 15:23:16 -07:00
|
|
|
/// The last num_credit_only_signed_accounts of the signed keys are credit-only accounts.
|
|
|
|
/// Programs may process multiple transactions that add lamports to the same credit-only
|
|
|
|
/// account within a single PoH entry, but are not permitted to debit lamports or modify
|
|
|
|
/// account data. Transactions targeting the same debit account are evaluated sequentially.
|
|
|
|
pub num_credit_only_signed_accounts: u8,
|
|
|
|
|
|
|
|
/// The last num_credit_only_unsigned_accounts of the unsigned keys are credit-only accounts.
|
|
|
|
pub num_credit_only_unsigned_accounts: u8,
|
|
|
|
}
|
|
|
|
|
|
|
|
#[derive(Serialize, Deserialize, Debug, PartialEq, Eq, Clone)]
|
|
|
|
pub struct Message {
|
|
|
|
/// The message header, identifying signed and credit-only `account_keys`
|
|
|
|
pub header: MessageHeader,
|
|
|
|
|
2019-03-29 09:05:06 -07:00
|
|
|
/// All the account keys used by this transaction
|
2019-03-25 08:15:16 -07:00
|
|
|
#[serde(with = "short_vec")]
|
2019-03-24 19:55:32 -07:00
|
|
|
pub account_keys: Vec<Pubkey>,
|
2019-03-29 09:05:06 -07:00
|
|
|
|
|
|
|
/// The id of a recent ledger entry.
|
2019-03-24 19:55:32 -07:00
|
|
|
pub recent_blockhash: Hash,
|
2019-03-29 09:05:06 -07:00
|
|
|
|
|
|
|
/// Programs that will be executed in sequence and committed in one atomic transaction if all
|
|
|
|
/// succeed.
|
2019-03-25 08:15:16 -07:00
|
|
|
#[serde(with = "short_vec")]
|
2019-03-24 19:55:32 -07:00
|
|
|
pub instructions: Vec<CompiledInstruction>,
|
|
|
|
}
|
2019-03-24 20:06:02 -07:00
|
|
|
|
|
|
|
impl Message {
|
2019-03-29 09:05:06 -07:00
|
|
|
pub fn new_with_compiled_instructions(
|
2019-03-29 12:21:32 -07:00
|
|
|
num_required_signatures: u8,
|
2019-05-22 15:23:16 -07:00
|
|
|
num_credit_only_signed_accounts: u8,
|
|
|
|
num_credit_only_unsigned_accounts: u8,
|
2019-03-29 09:05:06 -07:00
|
|
|
account_keys: Vec<Pubkey>,
|
|
|
|
recent_blockhash: Hash,
|
|
|
|
instructions: Vec<CompiledInstruction>,
|
|
|
|
) -> Self {
|
|
|
|
Self {
|
2019-05-22 15:23:16 -07:00
|
|
|
header: MessageHeader {
|
|
|
|
num_required_signatures,
|
|
|
|
num_credit_only_signed_accounts,
|
|
|
|
num_credit_only_unsigned_accounts,
|
|
|
|
},
|
2019-03-29 09:05:06 -07:00
|
|
|
account_keys,
|
|
|
|
recent_blockhash,
|
|
|
|
instructions,
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2019-03-24 20:06:02 -07:00
|
|
|
pub fn new(instructions: Vec<Instruction>) -> Self {
|
2019-05-07 15:00:54 -07:00
|
|
|
Self::new_with_payer(instructions, None)
|
|
|
|
}
|
|
|
|
|
|
|
|
pub fn new_with_payer(instructions: Vec<Instruction>, payer: Option<&Pubkey>) -> Self {
|
2019-03-24 20:20:34 -07:00
|
|
|
let program_ids = get_program_ids(&instructions);
|
2019-05-07 18:48:31 -07:00
|
|
|
let (mut signed_keys, unsigned_keys) = get_keys(&instructions, payer);
|
2019-03-29 12:21:32 -07:00
|
|
|
let num_required_signatures = signed_keys.len() as u8;
|
2019-05-22 15:23:16 -07:00
|
|
|
let num_credit_only_signed_accounts = 0;
|
|
|
|
let num_credit_only_unsigned_accounts = program_ids.len() as u8;
|
2019-03-24 20:20:34 -07:00
|
|
|
signed_keys.extend(&unsigned_keys);
|
2019-05-22 15:23:16 -07:00
|
|
|
signed_keys.extend(&program_ids);
|
|
|
|
let instructions = compile_instructions(instructions, &signed_keys);
|
2019-03-29 09:05:06 -07:00
|
|
|
Self::new_with_compiled_instructions(
|
2019-03-29 12:21:32 -07:00
|
|
|
num_required_signatures,
|
2019-05-22 15:23:16 -07:00
|
|
|
num_credit_only_signed_accounts,
|
|
|
|
num_credit_only_unsigned_accounts,
|
2019-03-29 09:05:06 -07:00
|
|
|
signed_keys,
|
|
|
|
Hash::default(),
|
2019-03-24 20:20:34 -07:00
|
|
|
instructions,
|
2019-03-29 09:05:06 -07:00
|
|
|
)
|
|
|
|
}
|
|
|
|
|
2019-04-02 15:02:57 -07:00
|
|
|
pub fn program_ids(&self) -> &[Pubkey] {
|
2019-05-22 15:23:16 -07:00
|
|
|
&self.account_keys
|
|
|
|
[self.account_keys.len() - self.header.num_credit_only_unsigned_accounts as usize..]
|
|
|
|
}
|
|
|
|
|
|
|
|
pub fn program_index_in_program_ids(&self, index: u8) -> u8 {
|
|
|
|
index - (self.account_keys.len() as u8 - self.header.num_credit_only_unsigned_accounts)
|
2019-03-24 20:06:02 -07:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
#[cfg(test)]
|
|
|
|
mod tests {
|
|
|
|
use super::*;
|
|
|
|
use crate::instruction::AccountMeta;
|
|
|
|
use crate::signature::{Keypair, KeypairUtil};
|
|
|
|
|
|
|
|
#[test]
|
2019-03-24 20:20:34 -07:00
|
|
|
fn test_message_unique_program_ids() {
|
2019-03-24 20:06:02 -07:00
|
|
|
let program_id0 = Pubkey::default();
|
2019-03-24 20:20:34 -07:00
|
|
|
let program_ids = get_program_ids(&[
|
2019-03-24 20:06:02 -07:00
|
|
|
Instruction::new(program_id0, &0, vec![]),
|
|
|
|
Instruction::new(program_id0, &0, vec![]),
|
2019-03-24 20:20:34 -07:00
|
|
|
]);
|
2019-03-24 20:06:02 -07:00
|
|
|
assert_eq!(program_ids, vec![program_id0]);
|
|
|
|
}
|
|
|
|
|
|
|
|
#[test]
|
2019-03-24 20:20:34 -07:00
|
|
|
fn test_message_unique_program_ids_not_adjacent() {
|
2019-03-24 20:06:02 -07:00
|
|
|
let program_id0 = Pubkey::default();
|
2019-03-30 20:37:33 -07:00
|
|
|
let program_id1 = Pubkey::new_rand();
|
2019-03-24 20:20:34 -07:00
|
|
|
let program_ids = get_program_ids(&[
|
2019-03-24 20:06:02 -07:00
|
|
|
Instruction::new(program_id0, &0, vec![]),
|
|
|
|
Instruction::new(program_id1, &0, vec![]),
|
|
|
|
Instruction::new(program_id0, &0, vec![]),
|
2019-03-24 20:20:34 -07:00
|
|
|
]);
|
2019-03-24 20:06:02 -07:00
|
|
|
assert_eq!(program_ids, vec![program_id0, program_id1]);
|
|
|
|
}
|
|
|
|
|
|
|
|
#[test]
|
2019-03-24 20:20:34 -07:00
|
|
|
fn test_message_unique_program_ids_order_preserved() {
|
2019-03-30 20:37:33 -07:00
|
|
|
let program_id0 = Pubkey::new_rand();
|
2019-03-24 20:06:02 -07:00
|
|
|
let program_id1 = Pubkey::default(); // Key less than program_id0
|
2019-03-24 20:20:34 -07:00
|
|
|
let program_ids = get_program_ids(&[
|
2019-03-24 20:06:02 -07:00
|
|
|
Instruction::new(program_id0, &0, vec![]),
|
|
|
|
Instruction::new(program_id1, &0, vec![]),
|
|
|
|
Instruction::new(program_id0, &0, vec![]),
|
2019-03-24 20:20:34 -07:00
|
|
|
]);
|
2019-03-24 20:06:02 -07:00
|
|
|
assert_eq!(program_ids, vec![program_id0, program_id1]);
|
|
|
|
}
|
|
|
|
|
|
|
|
#[test]
|
2019-03-24 20:20:34 -07:00
|
|
|
fn test_message_unique_keys_both_signed() {
|
2019-03-24 20:06:02 -07:00
|
|
|
let program_id = Pubkey::default();
|
|
|
|
let id0 = Pubkey::default();
|
2019-05-07 18:48:31 -07:00
|
|
|
let keys = get_keys(
|
|
|
|
&[
|
|
|
|
Instruction::new(program_id, &0, vec![AccountMeta::new(id0, true)]),
|
|
|
|
Instruction::new(program_id, &0, vec![AccountMeta::new(id0, true)]),
|
|
|
|
],
|
|
|
|
None,
|
|
|
|
);
|
|
|
|
assert_eq!(keys, (vec![id0], vec![]));
|
|
|
|
}
|
|
|
|
|
|
|
|
#[test]
|
|
|
|
fn test_message_unique_keys_signed_and_payer() {
|
|
|
|
let program_id = Pubkey::default();
|
|
|
|
let id0 = Pubkey::default();
|
|
|
|
let keys = get_keys(
|
|
|
|
&[Instruction::new(
|
|
|
|
program_id,
|
|
|
|
&0,
|
|
|
|
vec![AccountMeta::new(id0, true)],
|
|
|
|
)],
|
|
|
|
Some(&id0),
|
|
|
|
);
|
|
|
|
assert_eq!(keys, (vec![id0], vec![]));
|
|
|
|
}
|
|
|
|
|
|
|
|
#[test]
|
|
|
|
fn test_message_unique_keys_unsigned_and_payer() {
|
|
|
|
let program_id = Pubkey::default();
|
|
|
|
let id0 = Pubkey::default();
|
|
|
|
let keys = get_keys(
|
|
|
|
&[Instruction::new(
|
|
|
|
program_id,
|
|
|
|
&0,
|
|
|
|
vec![AccountMeta::new(id0, false)],
|
|
|
|
)],
|
|
|
|
Some(&id0),
|
|
|
|
);
|
2019-03-24 20:06:02 -07:00
|
|
|
assert_eq!(keys, (vec![id0], vec![]));
|
|
|
|
}
|
|
|
|
|
|
|
|
#[test]
|
2019-03-24 20:20:34 -07:00
|
|
|
fn test_message_unique_keys_one_signed() {
|
2019-03-24 20:06:02 -07:00
|
|
|
let program_id = Pubkey::default();
|
|
|
|
let id0 = Pubkey::default();
|
2019-05-07 18:48:31 -07:00
|
|
|
let keys = get_keys(
|
|
|
|
&[
|
|
|
|
Instruction::new(program_id, &0, vec![AccountMeta::new(id0, false)]),
|
|
|
|
Instruction::new(program_id, &0, vec![AccountMeta::new(id0, true)]),
|
|
|
|
],
|
|
|
|
None,
|
|
|
|
);
|
2019-03-24 20:06:02 -07:00
|
|
|
assert_eq!(keys, (vec![id0], vec![]));
|
|
|
|
}
|
|
|
|
|
|
|
|
#[test]
|
2019-03-24 20:20:34 -07:00
|
|
|
fn test_message_unique_keys_order_preserved() {
|
2019-03-24 20:06:02 -07:00
|
|
|
let program_id = Pubkey::default();
|
2019-03-30 20:37:33 -07:00
|
|
|
let id0 = Pubkey::new_rand();
|
2019-03-24 20:06:02 -07:00
|
|
|
let id1 = Pubkey::default(); // Key less than id0
|
2019-05-07 18:48:31 -07:00
|
|
|
let keys = get_keys(
|
|
|
|
&[
|
|
|
|
Instruction::new(program_id, &0, vec![AccountMeta::new(id0, false)]),
|
|
|
|
Instruction::new(program_id, &0, vec![AccountMeta::new(id1, false)]),
|
|
|
|
],
|
|
|
|
None,
|
|
|
|
);
|
2019-03-24 20:06:02 -07:00
|
|
|
assert_eq!(keys, (vec![], vec![id0, id1]));
|
|
|
|
}
|
|
|
|
|
|
|
|
#[test]
|
2019-03-24 20:20:34 -07:00
|
|
|
fn test_message_unique_keys_not_adjacent() {
|
2019-03-24 20:06:02 -07:00
|
|
|
let program_id = Pubkey::default();
|
|
|
|
let id0 = Pubkey::default();
|
2019-03-30 20:37:33 -07:00
|
|
|
let id1 = Pubkey::new_rand();
|
2019-05-07 18:48:31 -07:00
|
|
|
let keys = get_keys(
|
|
|
|
&[
|
|
|
|
Instruction::new(program_id, &0, vec![AccountMeta::new(id0, false)]),
|
|
|
|
Instruction::new(program_id, &0, vec![AccountMeta::new(id1, false)]),
|
|
|
|
Instruction::new(program_id, &0, vec![AccountMeta::new(id0, true)]),
|
|
|
|
],
|
|
|
|
None,
|
|
|
|
);
|
2019-03-24 20:06:02 -07:00
|
|
|
assert_eq!(keys, (vec![id0], vec![id1]));
|
|
|
|
}
|
|
|
|
|
|
|
|
#[test]
|
2019-03-24 20:20:34 -07:00
|
|
|
fn test_message_signed_keys_first() {
|
2019-03-24 20:06:02 -07:00
|
|
|
let program_id = Pubkey::default();
|
|
|
|
let id0 = Pubkey::default();
|
2019-03-30 20:37:33 -07:00
|
|
|
let id1 = Pubkey::new_rand();
|
2019-05-07 18:48:31 -07:00
|
|
|
let keys = get_keys(
|
|
|
|
&[
|
|
|
|
Instruction::new(program_id, &0, vec![AccountMeta::new(id0, false)]),
|
|
|
|
Instruction::new(program_id, &0, vec![AccountMeta::new(id1, true)]),
|
|
|
|
],
|
|
|
|
None,
|
|
|
|
);
|
2019-03-24 20:06:02 -07:00
|
|
|
assert_eq!(keys, (vec![id1], vec![id0]));
|
|
|
|
}
|
|
|
|
|
|
|
|
#[test]
|
|
|
|
// Ensure there's a way to calculate the number of required signatures.
|
2019-03-24 20:20:34 -07:00
|
|
|
fn test_message_signed_keys_len() {
|
2019-03-24 20:06:02 -07:00
|
|
|
let program_id = Pubkey::default();
|
|
|
|
let id0 = Pubkey::default();
|
|
|
|
let ix = Instruction::new(program_id, &0, vec![AccountMeta::new(id0, false)]);
|
2019-03-24 20:20:34 -07:00
|
|
|
let message = Message::new(vec![ix]);
|
2019-05-22 15:23:16 -07:00
|
|
|
assert_eq!(message.header.num_required_signatures, 0);
|
2019-03-24 20:06:02 -07:00
|
|
|
|
|
|
|
let ix = Instruction::new(program_id, &0, vec![AccountMeta::new(id0, true)]);
|
2019-03-24 20:20:34 -07:00
|
|
|
let message = Message::new(vec![ix]);
|
2019-05-22 15:23:16 -07:00
|
|
|
assert_eq!(message.header.num_required_signatures, 1);
|
2019-03-24 20:06:02 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
#[test]
|
2019-03-24 20:20:34 -07:00
|
|
|
fn test_message_kitchen_sink() {
|
2019-05-22 15:23:16 -07:00
|
|
|
let program_id0 = Pubkey::new_rand();
|
2019-03-30 20:37:33 -07:00
|
|
|
let program_id1 = Pubkey::new_rand();
|
2019-03-24 20:06:02 -07:00
|
|
|
let id0 = Pubkey::default();
|
|
|
|
let keypair1 = Keypair::new();
|
|
|
|
let id1 = keypair1.pubkey();
|
2019-03-24 20:20:34 -07:00
|
|
|
let message = Message::new(vec![
|
2019-03-24 20:06:02 -07:00
|
|
|
Instruction::new(program_id0, &0, vec![AccountMeta::new(id0, false)]),
|
|
|
|
Instruction::new(program_id1, &0, vec![AccountMeta::new(id1, true)]),
|
|
|
|
Instruction::new(program_id0, &0, vec![AccountMeta::new(id1, false)]),
|
2019-03-24 20:20:34 -07:00
|
|
|
]);
|
|
|
|
assert_eq!(
|
|
|
|
message.instructions[0],
|
2019-05-22 15:23:16 -07:00
|
|
|
CompiledInstruction::new(2, &0, vec![1])
|
2019-03-24 20:20:34 -07:00
|
|
|
);
|
|
|
|
assert_eq!(
|
|
|
|
message.instructions[1],
|
2019-05-22 15:23:16 -07:00
|
|
|
CompiledInstruction::new(3, &0, vec![0])
|
2019-03-24 20:20:34 -07:00
|
|
|
);
|
|
|
|
assert_eq!(
|
|
|
|
message.instructions[2],
|
2019-05-22 15:23:16 -07:00
|
|
|
CompiledInstruction::new(2, &0, vec![0])
|
2019-03-24 20:20:34 -07:00
|
|
|
);
|
2019-03-24 20:06:02 -07:00
|
|
|
}
|
2019-05-07 15:00:54 -07:00
|
|
|
|
|
|
|
#[test]
|
|
|
|
fn test_message_payer_first() {
|
|
|
|
let program_id = Pubkey::default();
|
|
|
|
let payer = Pubkey::new_rand();
|
|
|
|
let id0 = Pubkey::default();
|
|
|
|
|
|
|
|
let ix = Instruction::new(program_id, &0, vec![AccountMeta::new(id0, false)]);
|
|
|
|
let message = Message::new_with_payer(vec![ix], Some(&payer));
|
2019-05-22 15:23:16 -07:00
|
|
|
assert_eq!(message.header.num_required_signatures, 1);
|
2019-05-07 15:00:54 -07:00
|
|
|
|
|
|
|
let ix = Instruction::new(program_id, &0, vec![AccountMeta::new(id0, true)]);
|
|
|
|
let message = Message::new_with_payer(vec![ix], Some(&payer));
|
2019-05-22 15:23:16 -07:00
|
|
|
assert_eq!(message.header.num_required_signatures, 2);
|
2019-05-07 15:00:54 -07:00
|
|
|
|
|
|
|
let ix = Instruction::new(
|
|
|
|
program_id,
|
|
|
|
&0,
|
|
|
|
vec![AccountMeta::new(payer, true), AccountMeta::new(id0, true)],
|
|
|
|
);
|
|
|
|
let message = Message::new_with_payer(vec![ix], Some(&payer));
|
2019-05-22 15:23:16 -07:00
|
|
|
assert_eq!(message.header.num_required_signatures, 2);
|
2019-05-07 15:00:54 -07:00
|
|
|
}
|
|
|
|
|
2019-03-24 20:06:02 -07:00
|
|
|
}
|