fn make_structures()

in fastpay/src/bench.rs [99:181]
70 lines of code
6 McCabe index (conditional complexity)

    fn make_structures(&self) -> (Vec<AuthorityState>, Vec<(u32, Bytes)>) {
        info!("Preparing accounts.");
        let mut keys = Vec::new();
        for _ in 0..self.committee_size {
            keys.push(get_key_pair());
        }
        let committee = Committee {
            voting_rights: keys.iter().map(|(k, _)| (*k, 1)).collect(),
            total_votes: self.committee_size,
        };

        // Pick an authority and create one state per shard.
        let (public_auth0, secret_auth0) = keys.pop().unwrap();
        let mut states = Vec::new();
        for i in 0..self.num_shards {
            let state = AuthorityState::new_shard(
                committee.clone(),
                public_auth0,
                secret_auth0.copy(),
                i as u32,
                self.num_shards,
            );
            states.push(state);
        }

        // Seed user accounts.
        let mut account_keys = Vec::new();
        for _ in 0..self.num_accounts {
            let keypair = get_key_pair();
            let i = AuthorityState::get_shard(self.num_shards, &keypair.0) as usize;
            assert!(states[i].in_shard(&keypair.0));
            let client = AccountOffchainState {
                balance: Balance::from(Amount::from(100)),
                next_sequence_number: SequenceNumber::from(0),
                pending_confirmation: None,
                confirmed_log: Vec::new(),
                synchronization_log: Vec::new(),
                received_log: Vec::new(),
            };
            states[i].accounts.insert(keypair.0, client);
            account_keys.push(keypair);
        }

        info!("Preparing transactions.");
        // Make one transaction per account (transfer order + confirmation).
        let mut orders: Vec<(u32, Bytes)> = Vec::new();
        let mut next_recipient = get_key_pair().0;
        for (pubx, secx) in account_keys.iter() {
            let transfer = Transfer {
                sender: *pubx,
                recipient: Address::FastPay(next_recipient),
                amount: Amount::from(50),
                sequence_number: SequenceNumber::from(0),
                user_data: UserData::default(),
            };
            next_recipient = *pubx;
            let order = TransferOrder::new(transfer.clone(), secx);
            let shard = AuthorityState::get_shard(self.num_shards, pubx);

            // Serialize order
            let bufx = serialize_transfer_order(&order);
            assert!(!bufx.is_empty());

            // Make certificate
            let mut certificate = CertifiedTransferOrder {
                value: order,
                signatures: Vec::new(),
            };
            for i in 0..committee.quorum_threshold() {
                let (pubx, secx) = keys.get(i).unwrap();
                let sig = Signature::new(&certificate.value.transfer, secx);
                certificate.signatures.push((*pubx, sig));
            }

            let bufx2 = serialize_cert(&certificate);
            assert!(!bufx2.is_empty());

            orders.push((shard, bufx2.into()));
            orders.push((shard, bufx.into()));
        }

        (states, orders)
    }