blockworks-foundation
/
solana
mirror of https://github.com/blockworks-foundation/solana.git
1
0
Fork 0
Code Issues Projects Releases Wiki Activity

Pay for storage transactions with a system account (#4423) 

automerge
This commit is contained in:
Michael Vines 2019-05-24 11:04:05 -07:00 committed by Grimes
parent 45642c4da1
commit 9784bbf154
2 changed files with 129 additions and 97 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

224
programs/storage_api/src/storage_processor.rs
View File

@ -252,11 +252,11 @@ mod tests {
let (genesis_block, mint_keypair) = create_genesis_block(1000); let (genesis_block, mint_keypair) = create_genesis_block(1000);
let mint_pubkey = mint_keypair.pubkey(); let mint_pubkey = mint_keypair.pubkey();
let replicator_keypair = Keypair::new(); let replicator_keypair = Keypair::new();
let replicator = replicator_keypair.pubkey(); let replicator_pubkey = replicator_keypair.pubkey();
let validator_keypair = Keypair::new(); let validator_keypair = Keypair::new();
let validator = validator_keypair.pubkey(); let validator_pubkey = validator_keypair.pubkey();
let mining_pool_keypair = Keypair::new(); let mining_pool_keypair = Keypair::new();
let mining_pool = mining_pool_keypair.pubkey(); let mining_pool_pubkey = mining_pool_keypair.pubkey();
let mut bank = Bank::new(&genesis_block); let mut bank = Bank::new(&genesis_block);
bank.add_instruction_processor(id(), process_instruction); bank.add_instruction_processor(id(), process_instruction);
@ -266,21 +266,21 @@ mod tests {
let message = Message::new(storage_instruction::create_validator_storage_account( let message = Message::new(storage_instruction::create_validator_storage_account(
&mint_pubkey, &mint_pubkey,
&validator, &validator_pubkey,
10, 10,
)); ));
bank_client.send_message(&[&mint_keypair], message).unwrap(); bank_client.send_message(&[&mint_keypair], message).unwrap();
let message = Message::new(storage_instruction::create_replicator_storage_account( let message = Message::new(storage_instruction::create_replicator_storage_account(
&mint_pubkey, &mint_pubkey,
&replicator, &replicator_pubkey,
10, 10,
)); ));
bank_client.send_message(&[&mint_keypair], message).unwrap(); bank_client.send_message(&[&mint_keypair], message).unwrap();
let message = Message::new(storage_instruction::create_mining_pool_account( let message = Message::new(storage_instruction::create_mining_pool_account(
&mint_pubkey, &mint_pubkey,
&mining_pool, &mining_pool_pubkey,
100, 100,
)); ));
bank_client.send_message(&[&mint_keypair], message).unwrap(); bank_client.send_message(&[&mint_keypair], message).unwrap();
@ -292,80 +292,107 @@ mod tests {
} }
// advertise for storage segment 1 // advertise for storage segment 1
let ix = storage_instruction::advertise_recent_blockhash(
&validator,
Hash::default(),
SLOTS_PER_SEGMENT,
);
assert_matches!(bank_client.send_instruction(&validator_keypair, ix), Ok(_));
let ix = storage_instruction::mining_proof(
&replicator,
Hash::default(),
slot,
Signature::default(),
);
assert_matches!(bank_client.send_instruction(&replicator_keypair, ix), Ok(_));
let ix = storage_instruction::advertise_recent_blockhash(
&validator,
Hash::default(),
SLOTS_PER_SEGMENT * 2,
);
let next_storage_segment_tick_height = TICKS_IN_SEGMENT;
for _ in 0..next_storage_segment_tick_height {
bank.register_tick(&bank.last_blockhash());
}
assert_matches!(bank_client.send_instruction(&validator_keypair, ix), Ok(_));
let ix = storage_instruction::proof_validation(
&validator,
slot,
vec![CheckedProof {
proof: Proof {
id: replicator,
signature: Signature::default(),
sha_state: Hash::default(),
},
status: ProofStatus::Valid,
}],
);
assert_matches!(bank_client.send_instruction(&validator_keypair, ix), Ok(_));
let ix = storage_instruction::advertise_recent_blockhash(
&validator,
Hash::default(),
SLOTS_PER_SEGMENT * 3,
);
let next_storage_segment_tick_height = TICKS_IN_SEGMENT;
for _ in 0..next_storage_segment_tick_height {
bank.register_tick(&bank.last_blockhash());
}
assert_matches!(bank_client.send_instruction(&validator_keypair, ix), Ok(_));
assert_eq!(bank_client.get_balance(&validator).unwrap(), 10,);
let message = Message::new_with_payer( let message = Message::new_with_payer(
vec![storage_instruction::claim_reward( vec![storage_instruction::advertise_recent_blockhash(
&validator, &validator_pubkey,
&mining_pool, Hash::default(),
slot, SLOTS_PER_SEGMENT,
)], )],
Some(&validator), Some(&mint_pubkey),
); );
assert_matches!( assert_matches!(
bank_client.send_message(&[&validator_keypair], message), bank_client.send_message(&[&mint_keypair, &validator_keypair], message),
Ok(_) Ok(_)
); );
let message = Message::new_with_payer(
vec![storage_instruction::mining_proof(
&replicator_pubkey,
Hash::default(),
slot,
Signature::default(),
)],
Some(&mint_pubkey),
);
assert_matches!(
bank_client.send_message(&[&mint_keypair, &replicator_keypair], message),
Ok(_)
);
let message = Message::new_with_payer(
vec![storage_instruction::advertise_recent_blockhash(
&validator_pubkey,
Hash::default(),
SLOTS_PER_SEGMENT * 2,
)],
Some(&mint_pubkey),
);
let next_storage_segment_tick_height = TICKS_IN_SEGMENT;
for _ in 0..next_storage_segment_tick_height {
bank.register_tick(&bank.last_blockhash());
}
assert_matches!(
bank_client.send_message(&[&mint_keypair, &validator_keypair], message),
Ok(_)
);
let message = Message::new_with_payer(
vec![storage_instruction::proof_validation(
&validator_pubkey,
slot,
vec![CheckedProof {
proof: Proof {
id: replicator_pubkey,
signature: Signature::default(),
sha_state: Hash::default(),
},
status: ProofStatus::Valid,
}],
)],
Some(&mint_pubkey),
);
assert_matches!(
bank_client.send_message(&[&mint_keypair, &validator_keypair], message),
Ok(_)
);
let message = Message::new_with_payer(
vec![storage_instruction::advertise_recent_blockhash(
&validator_pubkey,
Hash::default(),
SLOTS_PER_SEGMENT * 3,
)],
Some(&mint_pubkey),
);
let next_storage_segment_tick_height = TICKS_IN_SEGMENT;
for _ in 0..next_storage_segment_tick_height {
bank.register_tick(&bank.last_blockhash());
}
assert_matches!(
bank_client.send_message(&[&mint_keypair, &validator_keypair], message),
Ok(_)
);
assert_eq!(bank_client.get_balance(&validator_pubkey).unwrap(), 10,);
let message = Message::new_with_payer(
vec![storage_instruction::claim_reward(
&validator_pubkey,
&mining_pool_pubkey,
slot,
)],
Some(&mint_pubkey),
);
assert_matches!(bank_client.send_message(&[&mint_keypair], message), Ok(_));
assert_eq!( assert_eq!(
bank_client.get_balance(&validator).unwrap(), bank_client.get_balance(&validator_pubkey).unwrap(),
10 + TOTAL_VALIDATOR_REWARDS 10 + TOTAL_VALIDATOR_REWARDS
); );
@ -374,23 +401,20 @@ mod tests {
bank.register_tick(&bank.last_blockhash()); bank.register_tick(&bank.last_blockhash());
} }
assert_eq!(bank_client.get_balance(&replicator).unwrap(), 10); assert_eq!(bank_client.get_balance(&replicator_pubkey).unwrap(), 10);
let message = Message::new_with_payer( let message = Message::new_with_payer(
vec![storage_instruction::claim_reward( vec![storage_instruction::claim_reward(
&replicator, &replicator_pubkey,
&mining_pool, &mining_pool_pubkey,
slot, slot,
)], )],
Some(&replicator), Some(&mint_pubkey),
);
assert_matches!(
bank_client.send_message(&[&replicator_keypair], message),
Ok(_)
); );
assert_matches!(bank_client.send_message(&[&mint_keypair], message), Ok(_));
// TODO enable when rewards are working // TODO enable when rewards are working
// assert_eq!(bank_client.get_balance(&replicator).unwrap(), 10 + TOTAL_REPLICATOR_REWARDS); // assert_eq!(bank_client.get_balance(&replicator_pubkey).unwrap(), 10 + TOTAL_REPLICATOR_REWARDS);
} }
fn get_storage_slot<C: SyncClient>(client: &C, account: &Pubkey) -> u64 { fn get_storage_slot<C: SyncClient>(client: &C, account: &Pubkey) -> u64 {
@ -468,26 +492,34 @@ mod tests {
)); ));
bank_client.send_message(&[&mint_keypair], message).unwrap(); bank_client.send_message(&[&mint_keypair], message).unwrap();
let ix = storage_instruction::advertise_recent_blockhash( let message = Message::new_with_payer(
&validator_pubkey, vec![storage_instruction::advertise_recent_blockhash(
storage_blockhash, &validator_pubkey,
SLOTS_PER_SEGMENT, storage_blockhash,
SLOTS_PER_SEGMENT,
)],
Some(&mint_pubkey),
); );
bank_client assert_matches!(
.send_instruction(&validator_keypair, ix) bank_client.send_message(&[&mint_keypair, &validator_keypair], message),
.unwrap(); Ok(_)
);
let slot = 0; let slot = 0;
let ix = storage_instruction::mining_proof( let message = Message::new_with_payer(
&replicator_pubkey, vec![storage_instruction::mining_proof(
Hash::default(), &replicator_pubkey,
slot, Hash::default(),
Signature::default(), slot,
Signature::default(),
)],
Some(&mint_pubkey),
);
assert_matches!(
bank_client.send_message(&[&mint_keypair, &replicator_keypair], message),
Ok(_)
); );
let _result = bank_client
.send_instruction(&replicator_keypair, ix)
.unwrap();
assert_eq!( assert_eq!(
get_storage_slot(&bank_client, &validator_pubkey), get_storage_slot(&bank_client, &validator_pubkey),

2
runtime/src/accounts.rs
View File

@ -884,7 +884,7 @@ mod tests {
account.owner = native_loader::id(); account.owner = native_loader::id();
accounts.push((key1, account)); accounts.push((key1, account));
let instructions = vec![CompiledInstruction::new(0, &(), vec![0])]; let instructions = vec![CompiledInstruction::new(1, &(), vec![0])];
let tx = Transaction::new_with_compiled_instructions( let tx = Transaction::new_with_compiled_instructions(
&[&keypair], &[&keypair],
&[], &[],