ntt-accountant: remove commented tests, leave TODOs

cosmwasm/contracts/ntt-global-accountant/tests/missing_observations.rs

@@ -30,197 +30,8 @@ fn _create_observation() -> Observation {
     }
 }
 
-// TODO: port test
-// #[test]
-// fn missing_observations() {
-//     let (wh, mut contract) = proper_instantiate();
-//     register_emitters(&wh, &mut contract, 3);
+// TODO: port missing_observations test
 
-//     let index = wh.guardian_set_index();
-//     let quorum = wh
-//         .calculate_quorum(index, contract.app().block_info().height)
-//         .unwrap() as usize;
+// TODO: port different_observations test
 
-//     let o = create_observation();
-//     let digest = o.digest().unwrap();
-//     let data = to_binary(&[o.clone()]).unwrap();
-//     let signatures = sign_observations(&wh, &data);
-
-//     // Don't submit enough signatures for the transfer to reach quorum.
-//     for s in &signatures[..quorum - 1] {
-//         contract
-//             .submit_observations(data.clone(), index, *s)
-//             .unwrap();
-//     }
-
-//     // The transfer should still be pending.
-//     let key = transfer::Key::new(o.emitter_chain, o.emitter_address.into(), o.sequence);
-//     let pending = contract.query_pending_transfer(key).unwrap();
-//     assert_eq!(&digest, pending[0].digest());
-
-//     for (i, s) in signatures.iter().enumerate() {
-//         let resp = contract.query_missing_observations(index, s.index).unwrap();
-//         if i < quorum - 1 {
-//             assert!(resp.missing.is_empty());
-//         } else {
-//             assert_eq!(resp.missing.len(), 1);
-
-//             let missing = resp.missing.first().unwrap();
-//             assert_eq!(missing.chain_id, o.emitter_chain);
-//             assert_eq!(missing.tx_hash, o.tx_hash);
-//         }
-//     }
-
-//     // Now submit one more signature so the transfer is committed.
-//     contract
-//         .submit_observations(data, index, signatures[quorum])
-//         .unwrap();
-
-//     // There should be no more missing observations.
-//     for s in signatures {
-//         let resp = contract.query_missing_observations(index, s.index).unwrap();
-//         assert!(resp.missing.is_empty());
-//     }
-// }
-
-// TODO: port test
-// #[test]
-// fn different_observations() {
-//     let (wh, mut contract) = proper_instantiate();
-//     register_emitters(&wh, &mut contract, 3);
-
-//     let index = wh.guardian_set_index();
-//     let quorum = wh
-//         .calculate_quorum(index, contract.app().block_info().height)
-//         .unwrap() as usize;
-
-//     let first = create_observation();
-//     let first_data = to_binary(&[first.clone()]).unwrap();
-//     let first_signatures = sign_observations(&wh, &first_data);
-
-//     // Don't submit enough signatures for the transfer to reach quorum.
-//     for s in &first_signatures[..quorum - 1] {
-//         contract
-//             .submit_observations(first_data.clone(), index, *s)
-//             .unwrap();
-//     }
-
-//     // Create a new observation with a different tx hash and payload.
-//     let msg: Message = Message::Transfer {
-//         amount: Amount(Uint256::from(900u128).to_be_bytes()),
-//         token_address: Address([0x02; 32]),
-//         token_chain: Chain::Ethereum,
-//         recipient: Address([0x1c; 32]),
-//         recipient_chain: Chain::Algorand,
-//         fee: Amount([0u8; 32]),
-//     };
-//     let mut second = create_observation();
-//     second.tx_hash = vec![
-//         0x8e, 0x29, 0xe6, 0xbc, 0xc0, 0x48, 0x88, 0x75, 0x57, 0xeb, 0x50, 0x9e, 0xb8, 0x5a, 0x4d,
-//         0x96, 0x53, 0xc0, 0xd7, 0x0b, 0x2c, 0xcb, 0xf1, 0x7b, 0x4d, 0x7c, 0x6e, 0x9a, 0xa6, 0x5e,
-//         0x2f, 0x1f,
-//     ]
-//     .into();
-//     second.payload = serde_wormhole::to_vec(&msg).map(From::from).unwrap();
-//     let second_data = to_binary(&[second.clone()]).unwrap();
-//     let second_signatures = sign_observations(&wh, &second_data);
-
-//     // Submit a different set of signatures for the second observation.
-//     for s in second_signatures.iter().rev().take(quorum - 1) {
-//         contract
-//             .submit_observations(second_data.clone(), index, *s)
-//             .unwrap();
-//     }
-
-//     let num_signatures = second_signatures.len();
-//     for (i, s) in second_signatures.into_iter().enumerate() {
-//         let resp = contract.query_missing_observations(index, s.index).unwrap();
-//         if i < num_signatures - quorum + 1 {
-//             // We should be missing the second observation.
-//             assert_eq!(resp.missing.len(), 1);
-
-//             let missing = resp.missing.first().unwrap();
-//             assert_eq!(second.emitter_chain, missing.chain_id);
-//             assert_eq!(second.tx_hash, missing.tx_hash);
-//         } else if i >= quorum - 1 {
-//             // We should be missing the first observation.
-//             assert_eq!(resp.missing.len(), 1);
-
-//             let missing = resp.missing.first().unwrap();
-//             assert_eq!(first.emitter_chain, missing.chain_id);
-//             assert_eq!(first.tx_hash, missing.tx_hash);
-//         } else {
-//             // We shouldn't be missing any observations.
-//             assert!(resp.missing.is_empty());
-//         }
-//     }
-// }
-
-// TODO: port test
-// #[test]
-// fn guardian_set_change() {
-//     let (wh, mut contract) = proper_instantiate();
-//     register_emitters(&wh, &mut contract, 3);
-
-//     let first_set = wh.guardian_set_index();
-//     let quorum = wh
-//         .calculate_quorum(first_set, contract.app().block_info().height)
-//         .unwrap() as usize;
-
-//     let o = create_observation();
-//     let data = to_binary(&[o.clone()]).unwrap();
-//     let signatures = sign_observations(&wh, &data);
-
-//     // Don't submit enough signatures for the transfer to reach quorum.
-//     for s in &signatures[..quorum - 1] {
-//         contract
-//             .submit_observations(data.clone(), first_set, *s)
-//             .unwrap();
-//     }
-
-//     // Update the guardian set index and submit a different set of signatures.
-//     let second_set = first_set + 1;
-//     wh.set_index(second_set);
-//     for s in signatures.iter().rev().take(quorum - 1) {
-//         contract
-//             .submit_observations(data.clone(), second_set, *s)
-//             .unwrap();
-//     }
-
-//     let num_signatures = signatures.len();
-//     for (i, s) in signatures.into_iter().enumerate() {
-//         let first_missing = contract
-//             .query_missing_observations(first_set, s.index)
-//             .unwrap()
-//             .missing;
-//         let second_missing = contract
-//             .query_missing_observations(second_set, s.index)
-//             .unwrap()
-//             .missing;
-
-//         if i < num_signatures - quorum + 1 {
-//             // We should be missing signatures for the new guardian set.
-//             assert!(first_missing.is_empty());
-
-//             assert_eq!(second_missing.len(), 1);
-
-//             let missing = second_missing.first().unwrap();
-//             assert_eq!(o.emitter_chain, missing.chain_id);
-//             assert_eq!(o.tx_hash, missing.tx_hash);
-//         } else if i >= quorum - 1 {
-//             // We should be missing signatures for the old guardian set.
-//             assert!(second_missing.is_empty());
-
-//             assert_eq!(first_missing.len(), 1);
-
-//             let missing = first_missing.first().unwrap();
-//             assert_eq!(o.emitter_chain, missing.chain_id);
-//             assert_eq!(o.tx_hash, missing.tx_hash);
-//         } else {
-//             // We shouldn't be missing signatures for either set.
-//             assert!(first_missing.is_empty());
-
-//             assert!(second_missing.is_empty());
-//         }
-//     }
-// }
+// TODO: port guardian_set_change test

cosmwasm/contracts/ntt-global-accountant/tests/query.rs

@@ -30,57 +30,6 @@ fn create_accounts(wh: &fake::WormholeKeeper, contract: &mut Contract, count: us
     }
 }
 
-// fn create_transfers(
-//     wh: &fake::WormholeKeeper,
-//     contract: &mut Contract,
-//     count: usize,
-// ) -> Vec<Transfer> {
-//     let mut out = Vec::with_capacity(count);
-
-//     let mut vaas = Vec::with_capacity(count);
-//     for i in 0..count {
-//         let emitter_chain = i as u16;
-//         let emitter_address = [i as u8; 32];
-//         let sequence = i as u64;
-//         let token_chain = emitter_chain;
-//         let token_address = [i as u8; 32];
-//         let recipient_chain = emitter_chain + 1;
-//         let amount = Uint256::from(i as u128);
-
-//         let body: Body<Message> = Body {
-//             timestamp: i as u32,
-//             nonce: i as u32,
-//             emitter_chain: emitter_chain.into(),
-//             emitter_address: Address(emitter_address),
-//             sequence,
-//             consistency_level: 0,
-//             payload: Message::Transfer {
-//                 amount: Amount(amount.to_be_bytes()),
-//                 token_address: Address(token_address),
-//                 token_chain: token_chain.into(),
-//                 recipient: Address([i as u8; 32]),
-//                 recipient_chain: recipient_chain.into(),
-//                 fee: Amount(Uint256::zero().to_be_bytes()),
-//             },
-//         };
-
-//         let (_, data) = sign_vaa_body(wh, body);
-//         vaas.push(data);
-//         out.push(Transfer {
-//             key: transfer::Key::new(emitter_chain, emitter_address.into(), sequence),
-//             data: transfer::Data {
-//                 amount,
-//                 token_chain,
-//                 token_address: token_address.into(),
-//                 recipient_chain,
-//             },
-//         });
-//     }
-
-//     contract.submit_vaas(vaas).unwrap();
-//     out
-// }
-
 pub fn create_modifications(
     wh: &fake::WormholeKeeper,
     contract: &mut Contract,
@@ -207,117 +156,15 @@ fn all_balances_sub_range() {
     }
 }
 
-// TODO: port test
-// #[test]
-// fn transfer_data() {
-//     let count = 2;
-//     let (wh, mut contract) = proper_instantiate();
-//     register_emitters(&wh, &mut contract, count);
-//     create_transfers(&wh, &mut contract, count);
-
-//     for i in 0..count {
-//         let expected = transfer::Data {
-//             amount: Uint256::from(i as u128),
-//             token_chain: i as u16,
-//             token_address: [i as u8; 32].into(),
-//             recipient_chain: (i + 1) as u16,
-//         };
-
-//         let key = transfer::Key::new(i as u16, [i as u8; 32].into(), i as u64);
-//         let actual = contract.query_transfer(key).unwrap();
-
-//         assert_eq!(expected, actual.data);
-//     }
-// }
-
-// TODO: port test
-// #[test]
-// fn missing_transfer() {
-//     let count = 2;
-//     let (wh, mut contract) = proper_instantiate();
-//     register_emitters(&wh, &mut contract, count);
-//     create_transfers(&wh, &mut contract, count);
-
-//     let missing = transfer::Key::new(
-//         (count + 1) as u16,
-//         [(count + 2) as u8; 32].into(),
-//         (count + 3) as u64,
-//     );
-
-//     let err = contract
-//         .query_transfer(missing)
-//         .expect_err("successfully queried missing transfer key");
-//     assert!(err.to_string().to_lowercase().contains("not found"));
-// }
-
-// TODO: port test
-// #[test]
-// fn all_transfer_data() {
-//     let count = 3;
-//     let (wh, mut contract) = proper_instantiate();
-//     register_emitters(&wh, &mut contract, count);
-//     let transfers = create_transfers(&wh, &mut contract, count);
-
-//     let resp = contract.query_all_transfers(None, None).unwrap();
-//     let found = resp
-//         .transfers
-//         .into_iter()
-//         .map(|(acc, _)| (acc.key, acc.data))
-//         .collect::<BTreeMap<_, _>>();
-//     assert_eq!(found.len(), count);
-
-//     for t in transfers {
-//         assert_eq!(found[&t.key], t.data);
-//     }
-// }
-
-// TODO: port test
-// #[test]
-// fn batch_transfer_status() {
-//     let count = 3;
-//     let (wh, mut contract) = proper_instantiate();
-//     register_emitters(&wh, &mut contract, count);
-//     let transfers = create_transfers(&wh, &mut contract, count);
-
-//     let keys = transfers.iter().map(|t| &t.key).cloned().collect();
-//     let resp = contract.query_batch_transfer_status(keys).unwrap();
-
-//     for (tx, details) in transfers.into_iter().zip(resp.details) {
-//         assert_eq!(tx.key, details.key);
-//         match details.status {
-//             Some(TransferStatus::Committed { data, .. }) => assert_eq!(tx.data, data),
-//             s => panic!("unexpected transfer status: {s:?}"),
-//         }
-//     }
-// }
-
-// TODO: port test
-// #[test]
-// fn all_transfer_data_sub_range() {
-//     let count = 5;
-//     let (wh, mut contract) = proper_instantiate();
-//     register_emitters(&wh, &mut contract, count);
-//     create_transfers(&wh, &mut contract, count);
-
-//     for i in 0..count {
-//         for l in 1..count - i {
-//             let start_after = Some(transfer::Key::new(i as u16, [i as u8; 32].into(), i as u64));
-//             let limit = Some(l as u32);
-//             let resp = contract.query_all_transfers(start_after, limit).unwrap();
-//             let found = resp
-//                 .transfers
-//                 .into_iter()
-//                 .map(|(acc, _)| (acc.key, acc.data))
-//                 .collect::<BTreeMap<_, _>>();
-//             assert_eq!(found.len(), l);
-
-//             for x in i + 1..=i + l {
-//                 let key = transfer::Key::new(x as u16, [x as u8; 32].into(), x as u64);
-//                 assert!(found.contains_key(&key));
-//             }
-//         }
-//     }
-// }
+// TODO: port transfer_data test
+
+// TODO: port missing_transfer test
+
+// TODO: port all_transfer_data test
+
+// TODO: port batch_transfer_status test
+
+// TODO: port all_transfer_data_sub_range test
 
 #[test]
 fn modification_data() {

cosmwasm/contracts/ntt-global-accountant/tests/submit_observations.rs

@@ -37,201 +37,9 @@ fn _set_up(count: usize) -> (Vec<Message>, Vec<Observation>) {
     (txs, observations)
 }
 
-// TODO: port test
-// #[test]
-// fn batch() {
-//     const COUNT: usize = 5;
+// TODO: port batch test
 
-//     let (txs, observations) = set_up(COUNT);
-//     let (wh, mut contract) = proper_instantiate();
-//     register_emitters(&wh, &mut contract, COUNT);
-
-//     let index = wh.guardian_set_index();
-
-//     let obs = to_binary(&observations).unwrap();
-//     let signatures = sign_observations(&wh, &obs);
-//     let quorum = wh
-//         .calculate_quorum(index, contract.app().block_info().height)
-//         .unwrap() as usize;
-
-//     for (i, s) in signatures.into_iter().enumerate() {
-//         let resp = contract.submit_observations(obs.clone(), index, s).unwrap();
-
-//         let status = from_binary::<Vec<SubmitObservationResponse>>(&resp.data.unwrap())
-//             .unwrap()
-//             .into_iter()
-//             .map(|resp| (resp.key, resp.status))
-//             .collect::<BTreeMap<_, _>>();
-
-//         if i < quorum {
-//             // Once there is a quorum the pending transfers are removed.
-//             if i < quorum - 1 {
-//                 for o in &observations {
-//                     let key =
-//                         transfer::Key::new(o.emitter_chain, o.emitter_address.into(), o.sequence);
-//                     let data = contract.query_pending_transfer(key.clone()).unwrap();
-//                     let digest = o.digest().unwrap();
-//                     assert_eq!(&digest, data[0].digest());
-
-//                     // Make sure the transfer hasn't yet been committed.
-//                     assert!(matches!(status[&key], ObservationStatus::Pending));
-//                     let err = contract
-//                         .query_transfer(key)
-//                         .expect_err("transfer committed without quorum");
-//                     assert!(err.to_string().to_lowercase().contains("not found"));
-//                 }
-//             } else {
-//                 for o in &observations {
-//                     let key =
-//                         transfer::Key::new(o.emitter_chain, o.emitter_address.into(), o.sequence);
-//                     assert!(matches!(status[&key], ObservationStatus::Committed));
-//                     let err = contract
-//                         .query_pending_transfer(key)
-//                         .expect_err("found pending transfer for observation with quorum");
-//                     assert!(err.to_string().to_lowercase().contains("not found"));
-//                 }
-//             }
-//         } else {
-//             // Submitting observations for committed transfers is not an error as long as the
-//             // digests match.
-//             for o in &observations {
-//                 let key = transfer::Key::new(o.emitter_chain, o.emitter_address.into(), o.sequence);
-//                 assert!(matches!(status[&key], ObservationStatus::Committed));
-//             }
-//         }
-//     }
-
-//     for (tx, o) in txs.into_iter().zip(observations) {
-//         let expected = if let Message::Transfer {
-//             amount,
-//             token_address,
-//             token_chain,
-//             recipient_chain,
-//             ..
-//         } = tx
-//         {
-//             transfer::Data {
-//                 amount: Uint256::new(amount.0),
-//                 token_chain: token_chain.into(),
-//                 token_address: TokenAddress::new(token_address.0),
-//                 recipient_chain: recipient_chain.into(),
-//             }
-//         } else {
-//             panic!("unexpected tokenbridge payload");
-//         };
-
-//         let key = transfer::Key::new(o.emitter_chain, o.emitter_address.into(), o.sequence);
-//         let actual = contract.query_transfer(key).unwrap();
-//         assert_eq!(expected, actual.data);
-//         assert_eq!(o.digest().unwrap(), actual.digest);
-
-//         let src = contract
-//             .query_balance(account::Key::new(
-//                 o.emitter_chain,
-//                 expected.token_chain,
-//                 expected.token_address,
-//             ))
-//             .unwrap();
-
-//         assert_eq!(expected.amount, *src);
-
-//         let dst = contract
-//             .query_balance(account::Key::new(
-//                 expected.recipient_chain,
-//                 expected.token_chain,
-//                 expected.token_address,
-//             ))
-//             .unwrap();
-
-//         assert_eq!(expected.amount, *dst);
-//     }
-// }
-
-// TODO: port test
-// #[test]
-// fn duplicates() {
-//     const COUNT: usize = 5;
-
-//     let (txs, observations) = set_up(COUNT);
-//     let (wh, mut contract) = proper_instantiate();
-//     register_emitters(&wh, &mut contract, COUNT);
-//     let index = wh.guardian_set_index();
-
-//     let obs = to_binary(&observations).unwrap();
-//     let signatures = sign_observations(&wh, &obs);
-//     let quorum = wh
-//         .calculate_quorum(index, contract.app().block_info().height)
-//         .unwrap() as usize;
-
-//     for (i, s) in signatures.into_iter().enumerate() {
-//         contract.submit_observations(obs.clone(), index, s).unwrap();
-//         // Submitting a duplicate signature is not an error for pending transfers. Submitting any
-//         // signature for a committed transfer is not an error as long as the digests match.
-//         let resp = contract.submit_observations(obs.clone(), index, s).unwrap();
-//         let status = from_binary::<Vec<SubmitObservationResponse>>(&resp.data.unwrap())
-//             .unwrap()
-//             .into_iter()
-//             .map(|details| (details.key, details.status))
-//             .collect::<BTreeMap<_, _>>();
-//         if i < quorum - 1 {
-//             // Resubmitting the same signature without quorum will return an error.
-//             for o in &observations {
-//                 let key = transfer::Key::new(o.emitter_chain, o.emitter_address.into(), o.sequence);
-//                 assert!(matches!(status[&key], ObservationStatus::Pending));
-//             }
-//         } else {
-//             for o in &observations {
-//                 let key = transfer::Key::new(o.emitter_chain, o.emitter_address.into(), o.sequence);
-//                 assert!(matches!(status[&key], ObservationStatus::Committed));
-//             }
-//         }
-//     }
-
-//     for (tx, o) in txs.into_iter().zip(observations) {
-//         let expected = if let Message::Transfer {
-//             amount,
-//             token_address,
-//             token_chain,
-//             recipient_chain,
-//             ..
-//         } = tx
-//         {
-//             transfer::Data {
-//                 amount: Uint256::new(amount.0),
-//                 token_chain: token_chain.into(),
-//                 token_address: TokenAddress::new(token_address.0),
-//                 recipient_chain: recipient_chain.into(),
-//             }
-//         } else {
-//             panic!("unexpected tokenbridge payload");
-//         };
-
-//         let key = transfer::Key::new(o.emitter_chain, o.emitter_address.into(), o.sequence);
-//         let actual = contract.query_transfer(key).unwrap();
-//         assert_eq!(expected, actual.data);
-//         assert_eq!(o.digest().unwrap(), actual.digest);
-
-//         let src = contract
-//             .query_balance(account::Key::new(
-//                 o.emitter_chain,
-//                 expected.token_chain,
-//                 expected.token_address,
-//             ))
-//             .unwrap();
-
-//         assert_eq!(expected.amount, *src);
-
-//         let dst = contract
-//             .query_balance(account::Key::new(
-//                 expected.recipient_chain,
-//                 expected.token_chain,
-//                 expected.token_address,
-//             ))
-//             .unwrap();
-
-//         assert_eq!(expected.amount, *dst);
-//     }
-// }
+// TODO: port duplicates test
 
 fn transfer_tokens(
     wh: &fake::WormholeKeeper,
@@ -265,91 +73,7 @@ fn transfer_tokens(
     Ok((o, responses))
 }
 
-// TODO: port test
-// #[test]
-// fn round_trip() {
-//     let (wh, mut contract) = proper_instantiate();
-//     register_emitters(&wh, &mut contract, 15);
-//     let index = wh.guardian_set_index();
-//     let num_guardians = wh.num_guardians();
-
-//     let emitter_chain = 2;
-//     let amount = Amount(Uint256::from(500u128).to_be_bytes());
-//     let token_address = Address([0xccu8; 32]);
-//     let token_chain = 2u16.into();
-//     let recipient_chain = 14u16.into();
-
-//     let key = transfer::Key::new(emitter_chain, [emitter_chain as u8; 32].into(), 37);
-//     let msg = Message::Transfer {
-//         amount,
-//         token_address,
-//         token_chain,
-//         recipient: Address([0xb9u8; 32]),
-//         recipient_chain,
-//         fee: Amount([0u8; 32]),
-//     };
-
-//     let (o, _) =
-//         transfer_tokens(&wh, &mut contract, key.clone(), msg, index, num_guardians).unwrap();
-
-//     let expected = transfer::Data {
-//         amount: Uint256::new(amount.0),
-//         token_chain: token_chain.into(),
-//         token_address: TokenAddress::new(token_address.0),
-//         recipient_chain: recipient_chain.into(),
-//     };
-//     let actual = contract.query_transfer(key).unwrap();
-//     assert_eq!(expected, actual.data);
-//     assert_eq!(o.digest().unwrap(), actual.digest);
-
-//     // Now send the tokens back.
-//     let key = transfer::Key::new(
-//         recipient_chain.into(),
-//         [u16::from(recipient_chain) as u8; 32].into(),
-//         91156748,
-//     );
-//     let msg = Message::Transfer {
-//         amount,
-//         token_address,
-//         token_chain,
-//         recipient: Address([0xe4u8; 32]),
-//         recipient_chain: emitter_chain.into(),
-//         fee: Amount([0u8; 32]),
-//     };
-//     let (o, _) =
-//         transfer_tokens(&wh, &mut contract, key.clone(), msg, index, num_guardians).unwrap();
-
-//     let expected = transfer::Data {
-//         amount: Uint256::new(amount.0),
-//         token_chain: token_chain.into(),
-//         token_address: TokenAddress::new(token_address.0),
-//         recipient_chain: emitter_chain,
-//     };
-//     let actual = contract.query_transfer(key).unwrap();
-//     assert_eq!(expected, actual.data);
-//     assert_eq!(o.digest().unwrap(), actual.digest);
-
-//     // Now both balances should be zero.
-//     let src = contract
-//         .query_balance(account::Key::new(
-//             emitter_chain,
-//             token_chain.into(),
-//             expected.token_address,
-//         ))
-//         .unwrap();
-
-//     assert_eq!(Uint256::zero(), *src);
-
-//     let dst = contract
-//         .query_balance(account::Key::new(
-//             recipient_chain.into(),
-//             token_chain.into(),
-//             expected.token_address,
-//         ))
-//         .unwrap();
-
-//     assert_eq!(Uint256::zero(), *dst);
-// }
+// TODO: port round_trip test
 
 #[test]
 fn missing_guardian_set() {
@@ -418,597 +142,22 @@ fn expired_guardian_set() {
     );
 }
 
-// TODO: port test
-// #[test]
-// fn no_quorum() {
-//     let (wh, mut contract) = proper_instantiate();
-//     register_emitters(&wh, &mut contract, 3);
-//     let index = wh.guardian_set_index();
-//     let quorum = wh
-//         .calculate_quorum(index, contract.app().block_info().height)
-//         .unwrap() as usize;
-
-//     let emitter_chain = 2;
-//     let emitter_address = [emitter_chain as u8; 32];
-//     let sequence = 37;
-//     let amount = Amount(Uint256::from(500u128).to_be_bytes());
-//     let token_address = Address([0xccu8; 32]);
-//     let token_chain = 2.into();
-//     let recipient_chain = 14.into();
-
-//     let key = transfer::Key::new(emitter_chain, emitter_address.into(), sequence);
-//     let msg = Message::Transfer {
-//         amount,
-//         token_address,
-//         token_chain,
-//         recipient: Address([0xb9u8; 32]),
-//         recipient_chain,
-//         fee: Amount([0u8; 32]),
-//     };
-
-//     let (o, _) = transfer_tokens(&wh, &mut contract, key.clone(), msg, index, quorum - 1).unwrap();
-
-//     let data = contract.query_pending_transfer(key.clone()).unwrap();
-//     assert_eq!(emitter_chain, data[0].emitter_chain());
-//     assert_eq!(&o.digest().unwrap(), data[0].digest());
-//     assert_eq!(&o.tx_hash, data[0].tx_hash());
-
-//     // Make sure the transfer hasn't yet been committed.
-//     let err = contract
-//         .query_transfer(key)
-//         .expect_err("transfer committed without quorum");
-//     assert!(err.to_string().to_lowercase().contains("not found"));
-// }
-
-// TODO: port test
-// #[test]
-// fn missing_wrapped_account() {
-//     let (wh, mut contract) = proper_instantiate();
-//     register_emitters(&wh, &mut contract, 15);
-//     let index = wh.guardian_set_index();
-//     let num_guardians = wh.num_guardians();
-//     let quorum = wh
-//         .calculate_quorum(index, contract.app().block_info().height)
-//         .unwrap() as usize;
-
-//     let emitter_chain = 14;
-//     let amount = Amount(Uint256::from(500u128).to_be_bytes());
-//     let token_address = Address([0xccu8; 32]);
-//     let token_chain = 2.into();
-//     let recipient_chain = 2.into();
-
-//     let key = transfer::Key::new(emitter_chain, [emitter_chain as u8; 32].into(), 37);
-//     let msg = Message::Transfer {
-//         amount,
-//         token_address,
-//         token_chain,
-//         recipient: Address([0xb9u8; 32]),
-//         recipient_chain,
-//         fee: Amount([0u8; 32]),
-//     };
-
-//     let (_, responses) =
-//         transfer_tokens(&wh, &mut contract, key.clone(), msg, index, num_guardians).unwrap();
-//     for mut resp in responses.into_iter().skip(quorum - 1) {
-//         let r = from_binary::<Vec<SubmitObservationResponse>>(&resp.data.take().unwrap()).unwrap();
-//         assert_eq!(key, r[0].key);
-//         if let ObservationStatus::Error(ref err) = r[0].status {
-//             assert!(
-//                 err.contains("cannot burn wrapped tokens without an existing wrapped account"),
-//                 "{err}"
-//             );
-//             resp.assert_event(
-//                 &Event::new("wasm-ObservationError")
-//                     .add_attribute("key", serde_json_wasm::to_string(&key).unwrap()),
-//             );
-//         } else {
-//             panic!(
-//                 "unexpected response for transfer with missing wrapped account {:?}",
-//                 r[0]
-//             );
-//         }
-//     }
-// }
-
-// TODO: port test
-// #[test]
-// fn missing_native_account() {
-//     let emitter_chain = 14;
-//     let recipient_chain = 2;
-//     let amount = Amount(Uint256::from(500u128).to_be_bytes());
-//     let token_address = [0xccu8; 32];
-//     let token_chain = 2;
-
-//     let (wh, mut contract) = proper_instantiate();
-//     register_emitters(&wh, &mut contract, 15);
-//     let index = wh.guardian_set_index();
-//     let num_guardians = wh.num_guardians();
-//     let quorum = wh
-//         .calculate_quorum(index, contract.app().block_info().height)
-//         .unwrap() as usize;
-
-//     // increase the sequence to be large than the vaa's used to register emitters.
-//     contract.sequence += 100;
-
-//     // We need to set up a fake wrapped account so that the initial check succeeds.
-//     let m = Modification {
-//         sequence: 0,
-//         chain_id: emitter_chain,
-//         token_chain,
-//         token_address: token_address.into(),
-//         kind: Kind::Add,
-//         amount: Uint256::new(amount.0),
-//         reason: "fake wrapped balance for testing".into(),
-//     };
-//     contract.modify_balance(m, &wh).unwrap();
-
-//     let key = transfer::Key::new(emitter_chain, [emitter_chain as u8; 32].into(), 37);
-//     let msg = Message::Transfer {
-//         amount,
-//         token_address: Address(token_address),
-//         token_chain: token_chain.into(),
-//         recipient: Address([0xb9u8; 32]),
-//         recipient_chain: recipient_chain.into(),
-//         fee: Amount([0u8; 32]),
-//     };
-
-//     let (_, responses) =
-//         transfer_tokens(&wh, &mut contract, key.clone(), msg, index, num_guardians).unwrap();
-//     for mut resp in responses.into_iter().skip(quorum - 1) {
-//         let r = from_binary::<Vec<SubmitObservationResponse>>(&resp.data.take().unwrap()).unwrap();
-//         assert_eq!(key, r[0].key);
-//         if let ObservationStatus::Error(ref err) = r[0].status {
-//             assert!(
-//                 err.contains("cannot unlock native tokens without an existing native account"),
-//                 "{err}"
-//             );
-//             resp.assert_event(
-//                 &Event::new("wasm-ObservationError")
-//                     .add_attribute("key", serde_json_wasm::to_string(&key).unwrap()),
-//             );
-//         } else {
-//             panic!(
-//                 "unexpected response for transfer with missing native account {:?}",
-//                 r[0]
-//             );
-//         }
-//     }
-// }
-
-// TODO: port test
-// #[test]
-// fn repeated() {
-//     const ITERATIONS: usize = 10;
-
-//     let (wh, mut contract) = proper_instantiate();
-//     register_emitters(&wh, &mut contract, 3);
-//     let index = wh.guardian_set_index();
-//     let num_guardians = wh.num_guardians();
-
-//     let emitter_chain = 2;
-//     let recipient_chain = 14;
-//     let amount = Amount(Uint256::from(500u128).to_be_bytes());
-//     let token_address = [0xccu8; 32];
-//     let token_chain = 2;
-
-//     let msg = Message::Transfer {
-//         amount,
-//         token_address: Address(token_address),
-//         token_chain: token_chain.into(),
-//         recipient: Address([0xb9u8; 32]),
-//         recipient_chain: recipient_chain.into(),
-//         fee: Amount([0u8; 32]),
-//     };
-
-//     for i in 0..ITERATIONS {
-//         let key = transfer::Key::new(emitter_chain, [emitter_chain as u8; 32].into(), i as u64);
-//         transfer_tokens(
-//             &wh,
-//             &mut contract,
-//             key.clone(),
-//             msg.clone(),
-//             index,
-//             num_guardians,
-//         )
-//         .unwrap();
-//     }
-
-//     let expected = Uint256::new(amount.0) * Uint256::from(ITERATIONS as u128);
-//     let src = contract
-//         .query_balance(account::Key::new(
-//             emitter_chain,
-//             token_chain,
-//             token_address.into(),
-//         ))
-//         .unwrap();
-
-//     assert_eq!(expected, *src);
-
-//     let dst = contract
-//         .query_balance(account::Key::new(
-//             recipient_chain,
-//             token_chain,
-//             token_address.into(),
-//         ))
-//         .unwrap();
-
-//     assert_eq!(expected, *dst);
-// }
-
-// TODO: port test
-// #[test]
-// fn wrapped_to_wrapped() {
-//     let emitter_chain = 14;
-//     let recipient_chain = 2;
-//     let amount = Amount(Uint256::from(500u128).to_be_bytes());
-//     let token_address = [0xccu8; 32];
-//     let token_chain = 5;
-
-//     let (wh, mut contract) = proper_instantiate();
-//     register_emitters(&wh, &mut contract, 15);
-//     let index = wh.guardian_set_index();
-//     let num_guardians = wh.num_guardians();
-//     // increase the sequence to be large than the vaa's used to register emitters.
-//     contract.sequence += 100;
-
-//     // We need an initial fake wrapped account.
-//     let m = Modification {
-//         sequence: 0,
-//         chain_id: emitter_chain,
-//         token_chain,
-//         token_address: token_address.into(),
-//         kind: Kind::Add,
-//         amount: Uint256::new(amount.0),
-//         reason: "fake wrapped balance for testing".into(),
-//     };
-//     contract.modify_balance(m, &wh).unwrap();
-
-//     let key = transfer::Key::new(emitter_chain, [emitter_chain as u8; 32].into(), 37);
-//     let msg = Message::Transfer {
-//         amount,
-//         token_address: Address(token_address),
-//         token_chain: token_chain.into(),
-//         recipient: Address([0xb9u8; 32]),
-//         recipient_chain: recipient_chain.into(),
-//         fee: Amount([0u8; 32]),
-//     };
-
-//     let (o, _) =
-//         transfer_tokens(&wh, &mut contract, key.clone(), msg, index, num_guardians).unwrap();
-
-//     let expected = transfer::Data {
-//         amount: Uint256::new(amount.0),
-//         token_chain,
-//         token_address: TokenAddress::new(token_address),
-//         recipient_chain,
-//     };
-//     let actual = contract.query_transfer(key).unwrap();
-//     assert_eq!(expected, actual.data);
-//     assert_eq!(o.digest().unwrap(), actual.digest);
-
-//     let src = contract
-//         .query_balance(account::Key::new(
-//             emitter_chain,
-//             token_chain,
-//             token_address.into(),
-//         ))
-//         .unwrap();
-
-//     assert_eq!(Uint256::zero(), *src);
-
-//     let dst = contract
-//         .query_balance(account::Key::new(
-//             recipient_chain,
-//             token_chain,
-//             token_address.into(),
-//         ))
-//         .unwrap();
-
-//     assert_eq!(Uint256::new(amount.0), *dst);
-// }
-
-// TODO: port test
-// #[test]
-// fn unknown_emitter() {
-//     let (wh, mut contract) = proper_instantiate();
-//     let index = wh.guardian_set_index();
-//     let num_guardians = wh.num_guardians();
-//     let quorum = wh
-//         .calculate_quorum(index, contract.app().block_info().height)
-//         .unwrap() as usize;
-
-//     let emitter_chain = 14;
-//     let amount = Amount(Uint256::from(500u128).to_be_bytes());
-//     let token_address = Address([0xccu8; 32]);
-//     let token_chain = 2.into();
-//     let recipient_chain = 2.into();
-
-//     let key = transfer::Key::new(emitter_chain, [0xde; 32].into(), 37);
-//     let msg = Message::Transfer {
-//         amount,
-//         token_address,
-//         token_chain,
-//         recipient: Address([0xb9u8; 32]),
-//         recipient_chain,
-//         fee: Amount([0u8; 32]),
-//     };
-
-//     let (_, responses) =
-//         transfer_tokens(&wh, &mut contract, key.clone(), msg, index, num_guardians).unwrap();
-//     for mut resp in responses.into_iter().skip(quorum - 1) {
-//         let r = from_binary::<Vec<SubmitObservationResponse>>(&resp.data.take().unwrap()).unwrap();
-//         assert_eq!(key, r[0].key);
-//         if let ObservationStatus::Error(ref err) = r[0].status {
-//             assert!(err.contains("no registered emitter"));
-//             resp.assert_event(
-//                 &Event::new("wasm-ObservationError")
-//                     .add_attribute("key", serde_json_wasm::to_string(&key).unwrap()),
-//             );
-//         } else {
-//             panic!(
-//                 "unexpected response for transfer with unknown emitter address {:?}",
-//                 r[0]
-//             );
-//         }
-//     }
-// }
-
-// TODO: port test
-// #[test]
-// fn different_observations() {
-//     let (wh, mut contract) = proper_instantiate();
-//     register_emitters(&wh, &mut contract, 3);
-//     let index = wh.guardian_set_index();
-//     let quorum = wh
-//         .calculate_quorum(index, contract.app().block_info().height)
-//         .unwrap() as usize;
-
-//     // First submit some observations without enough signatures for quorum.
-//     let emitter_chain = 2;
-//     let fake_amount = Amount(Uint256::from(500u128).to_be_bytes());
-//     let token_address = Address([0xccu8; 32]);
-//     let token_chain = 2.into();
-//     let fake_recipient_chain = 14.into();
-
-//     let key = transfer::Key::new(emitter_chain, [emitter_chain as u8; 32].into(), 37);
-//     let fake = Message::Transfer {
-//         amount: fake_amount,
-//         token_address,
-//         token_chain,
-//         recipient: Address([0xb9u8; 32]),
-//         recipient_chain: fake_recipient_chain,
-//         fee: Amount([0u8; 32]),
-//     };
-
-//     transfer_tokens(&wh, &mut contract, key.clone(), fake, index, quorum - 1).unwrap();
-
-//     // Make sure there is no committed transfer yet.
-//     let err = contract
-//         .query_transfer(key.clone())
-//         .expect_err("committed transfer without quorum");
-//     assert!(err.to_string().to_lowercase().contains("not found"));
-
-//     // Now change the details of the transfer and resubmit with the same key.
-//     let real_amount = Amount(Uint256::from(200u128).to_be_bytes());
-//     let real_recipient_chain = 9.into();
-//     let real = Message::Transfer {
-//         amount: real_amount,
-//         token_address,
-//         token_chain,
-//         recipient: Address([0xb9u8; 32]),
-//         recipient_chain: real_recipient_chain,
-//         fee: Amount([0u8; 32]),
-//     };
-
-//     let (o, _) = transfer_tokens(&wh, &mut contract, key.clone(), real, index, quorum).unwrap();
-
-//     let err = contract
-//         .query_pending_transfer(key.clone())
-//         .expect_err("found pending transfer for observation with quorum");
-//     assert!(err.to_string().to_lowercase().contains("not found"));
-
-//     let expected = transfer::Data {
-//         amount: Uint256::new(real_amount.0),
-//         token_chain: token_chain.into(),
-//         token_address: TokenAddress::new(token_address.0),
-//         recipient_chain: real_recipient_chain.into(),
-//     };
-//     let actual = contract.query_transfer(key).unwrap();
-//     assert_eq!(expected, actual.data);
-//     assert_eq!(o.digest().unwrap(), actual.digest);
-
-//     let src = contract
-//         .query_balance(account::Key::new(
-//             emitter_chain,
-//             token_chain.into(),
-//             expected.token_address,
-//         ))
-//         .unwrap();
-
-//     assert_eq!(Uint256::new(real_amount.0), *src);
-
-//     let dst = contract
-//         .query_balance(account::Key::new(
-//             real_recipient_chain.into(),
-//             token_chain.into(),
-//             expected.token_address,
-//         ))
-//         .unwrap();
-
-//     assert_eq!(Uint256::new(real_amount.0), *dst);
-// }
-
-// TODO: port test
-// #[test]
-// fn emit_event_with_quorum() {
-//     let (wh, mut contract) = proper_instantiate();
-//     register_emitters(&wh, &mut contract, 3);
-
-//     let index = wh.guardian_set_index();
-//     let quorum = wh
-//         .calculate_quorum(index, contract.app().block_info().height)
-//         .unwrap() as usize;
-//     let num_guardians = wh.num_guardians();
-
-//     let emitter_chain = 2;
-//     let amount = Amount(Uint256::from(500u128).to_be_bytes());
-//     let token_address = Address([0xccu8; 32]);
-//     let token_chain = 2.into();
-//     let recipient_chain = 14.into();
-
-//     let key = transfer::Key::new(emitter_chain, [emitter_chain as u8; 32].into(), 37);
-//     let msg = Message::Transfer {
-//         amount,
-//         token_address,
-//         token_chain,
-//         recipient: Address([0xb9u8; 32]),
-//         recipient_chain,
-//         fee: Amount([0u8; 32]),
-//     };
-
-//     let (o, responses) =
-//         transfer_tokens(&wh, &mut contract, key, msg, index, num_guardians).unwrap();
-
-//     let expected = Event::new("wasm-Observation")
-//         .add_attribute("tx_hash", serde_json_wasm::to_string(&o.tx_hash).unwrap())
-//         .add_attribute(
-//             "timestamp",
-//             serde_json_wasm::to_string(&o.timestamp).unwrap(),
-//         )
-//         .add_attribute("nonce", serde_json_wasm::to_string(&o.nonce).unwrap())
-//         .add_attribute(
-//             "emitter_chain",
-//             serde_json_wasm::to_string(&o.emitter_chain).unwrap(),
-//         )
-//         .add_attribute(
-//             "emitter_address",
-//             serde_json_wasm::to_string(&hex::encode(o.emitter_address)).unwrap(),
-//         )
-//         .add_attribute("sequence", serde_json_wasm::to_string(&o.sequence).unwrap())
-//         .add_attribute(
-//             "consistency_level",
-//             serde_json_wasm::to_string(&o.consistency_level).unwrap(),
-//         )
-//         .add_attribute("payload", serde_json_wasm::to_string(&o.payload).unwrap());
-
-//     assert_eq!(responses.len(), num_guardians);
-//     for (i, r) in responses.into_iter().enumerate() {
-//         if i < quorum - 1 || i >= quorum {
-//             assert!(!r.has_event(&expected));
-//         } else {
-//             r.assert_event(&expected);
-//         }
-//     }
-// }
-
-// TODO: port test
-// #[test]
-// fn duplicate_vaa() {
-//     let (wh, mut contract) = proper_instantiate();
-//     register_emitters(&wh, &mut contract, 3);
-
-//     let index = wh.guardian_set_index();
-//     let num_guardians = wh.num_guardians();
-
-//     let emitter_chain = 2;
-//     let amount = Amount(Uint256::from(500u128).to_be_bytes());
-//     let token_address = Address([0xccu8; 32]);
-//     let token_chain = 2.into();
-//     let recipient_chain = 14.into();
-
-//     let key = transfer::Key::new(emitter_chain, [emitter_chain as u8; 32].into(), 37);
-//     let msg = Message::Transfer {
-//         amount,
-//         token_address,
-//         token_chain,
-//         recipient: Address([0xb9u8; 32]),
-//         recipient_chain,
-//         fee: Amount([0u8; 32]),
-//     };
-
-//     let (o, _) = transfer_tokens(&wh, &mut contract, key, msg, index, num_guardians).unwrap();
-
-//     // Now try to submit a VAA for this transfer.  This should fail since the transfer is already
-//     // processed.
-//     let body = Body {
-//         timestamp: o.timestamp,
-//         nonce: o.nonce,
-//         emitter_chain: o.emitter_chain.into(),
-//         emitter_address: Address(o.emitter_address),
-//         sequence: o.sequence,
-//         consistency_level: o.consistency_level,
-//         payload: (),
-//     };
-
-//     let mut body_data = serde_wormhole::to_vec(&body).unwrap();
-//     body_data.extend_from_slice(&o.payload);
-
-//     let mut data = serde_wormhole::to_vec(&Header {
-//         version: 1,
-//         guardian_set_index: index,
-//         signatures: wh.sign(&body_data),
-//     })
-//     .unwrap();
-//     data.extend_from_slice(&body_data);
-
-//     let err = contract
-//         .submit_vaas(vec![data.into()])
-//         .expect_err("successfully submitted duplicate VAA for committed transfer");
-//     assert!(format!("{err:#}").contains("message already processed"));
-// }
+// TODO: port no_quorum test
 
-// TODO: port test
-// #[test]
-// fn digest_mismatch() {
-//     let (wh, mut contract) = proper_instantiate();
-//     register_emitters(&wh, &mut contract, 3);
+// TODO: port missing_wrapped_account test
 
-//     let index = wh.guardian_set_index();
-//     let num_guardians = wh.num_guardians();
+// TODO: port missing_native_account test
 
-//     let emitter_chain = 2;
-//     let amount = Amount(Uint256::from(500u128).to_be_bytes());
-//     let token_address = Address([0xccu8; 32]);
-//     let token_chain = 2.into();
-//     let recipient_chain = 14.into();
+// TODO: port repeated test
 
-//     let key = transfer::Key::new(emitter_chain, [emitter_chain as u8; 32].into(), 37);
-//     let msg = Message::Transfer {
-//         amount,
-//         token_address,
-//         token_chain,
-//         recipient: Address([0xb9u8; 32]),
-//         recipient_chain,
-//         fee: Amount([0u8; 32]),
-//     };
+// TODO: port wrapped_to_wrapped test
 
-//     let (o, _) = transfer_tokens(&wh, &mut contract, key, msg, index, num_guardians).unwrap();
+// TODO: port unknown_emitter test
 
-//     // Now try submitting a VAA with the same (chain, address, sequence) tuple but with
-//     // different details.
-//     let body = Body {
-//         timestamp: o.timestamp,
-//         nonce: o.nonce ^ u32::MAX,
-//         emitter_chain: o.emitter_chain.into(),
-//         emitter_address: Address(o.emitter_address),
-//         sequence: o.sequence,
-//         consistency_level: o.consistency_level,
-//         payload: (),
-//     };
+// TODO: port different_observations test
 
-//     let mut body_data = serde_wormhole::to_vec(&body).unwrap();
-//     body_data.extend_from_slice(&o.payload);
+// TODO: port emit_event_with_quorum test
 
-//     let mut data = serde_wormhole::to_vec(&Header {
-//         version: 1,
-//         guardian_set_index: index,
-//         signatures: wh.sign(&body_data),
-//     })
-//     .unwrap();
-//     data.extend_from_slice(&body_data);
+// TODO: port duplicate_vaa test
 
-//     let err = contract
-//         .submit_vaas(vec![data.into()])
-//         .expect_err("successfully submitted duplicate VAA for committed transfer");
-//     assert!(format!("{err:#}").contains("digest mismatch"));
-// }
+// TODO: port digest_mismatch test

cosmwasm/contracts/ntt-global-accountant/tests/submit_vaas.rs

@@ -42,63 +42,7 @@ fn create_vaa_body(i: usize) -> Body<Message> {
     }
 }
 
-// fn transfer_data_from_token_message<P>(msg: Message<P>) -> transfer::Data {
-//     match msg {
-//         Message::Transfer {
-//             amount,
-//             token_address,
-//             token_chain,
-//             recipient_chain,
-//             ..
-//         }
-//         | Message::TransferWithPayload {
-//             amount,
-//             token_address,
-//             token_chain,
-//             recipient_chain,
-//             ..
-//         } => transfer::Data {
-//             amount: Uint256::from_be_bytes(amount.0),
-//             token_address: TokenAddress::new(token_address.0),
-//             token_chain: token_chain.into(),
-//             recipient_chain: recipient_chain.into(),
-//         },
-//         _ => panic!("not a transfer payload"),
-//     }
-// }
-
-// TODO: port test
-// #[test]
-// fn basic() {
-//     const COUNT: usize = 7;
-
-//     let (wh, mut contract) = proper_instantiate();
-
-//     register_emitters(&wh, &mut contract, COUNT);
-
-//     let (vaas, payloads) = create_transfer_vaas(&wh, COUNT);
-
-//     let resp = contract.submit_vaas(payloads).unwrap();
-
-//     for v in vaas {
-//         let key = transfer::Key::new(
-//             v.emitter_chain.into(),
-//             TokenAddress::new(v.emitter_address.0),
-//             v.sequence,
-//         );
-//         let (_, body) = v.into();
-//         let digest = body.digest().unwrap().secp256k_hash;
-//         let data = transfer_data_from_token_message(body.payload);
-//         let tx = contract.query_transfer(key.clone()).unwrap();
-//         assert_eq!(data, tx.data);
-//         assert_eq!(&digest[..], &*tx.digest);
-//         resp.assert_event(
-//             &Event::new("wasm-Transfer")
-//                 .add_attribute("key", serde_json_wasm::to_string(&key).unwrap())
-//                 .add_attribute("data", serde_json_wasm::to_string(&data).unwrap()),
-//         );
-//     }
-// }
+// TODO: port basic test
 
 #[test]
 fn invalid_emitter() {
@@ -241,62 +185,6 @@ fn non_transfer_message() {
     );
 }
 
-// TODO: port test
-// #[test]
-// fn transfer_with_payload() {
-//     let (wh, mut contract) = proper_instantiate();
-//     register_emitters(&wh, &mut contract, 3);
-//     let payload = [0x88; 17];
-//     let body = Body {
-//         timestamp: 2,
-//         nonce: 2,
-//         emitter_chain: Chain::Ethereum,
-//         emitter_address: Address([2u8; 32]),
-//         sequence: 2,
-//         consistency_level: 32,
-//         payload: Message::TransferWithPayload {
-//             amount: Amount(Uint256::from(2u128).to_be_bytes()),
-//             token_address: Address([3u8; 32]),
-//             token_chain: Chain::Ethereum,
-//             recipient: Address([2u8; 32]),
-//             recipient_chain: Chain::Bsc,
-//             sender_address: Address([0u8; 32]),
-//             payload: RawMessage::new(&payload[..]),
-//         },
-//     };
-
-//     let data = serde_wormhole::to_vec(&body).unwrap();
-
-//     let signatures = wh.sign(&data);
-//     let header = Header {
-//         version: 1,
-//         guardian_set_index: wh.guardian_set_index(),
-//         signatures,
-//     };
-
-//     let v = Vaa::from((header, body));
-
-//     let data = serde_wormhole::to_vec(&v).unwrap();
-//     let resp = contract.submit_vaas(vec![data.into()]).unwrap();
-
-//     let key = transfer::Key::new(
-//         v.emitter_chain.into(),
-//         TokenAddress::new(v.emitter_address.0),
-//         v.sequence,
-//     );
-//     let (_, body) = v.into();
-//     let digest = body.digest().unwrap().secp256k_hash;
-//     let data = transfer_data_from_token_message(body.payload);
-//     let tx = contract.query_transfer(key.clone()).unwrap();
-//     assert_eq!(data, tx.data);
-//     assert_eq!(&digest[..], &*tx.digest);
-//     resp.assert_event(
-//         &Event::new("wasm-Transfer")
-//             .add_attribute("key", serde_json_wasm::to_string(&key).unwrap())
-//             .add_attribute("data", serde_json_wasm::to_string(&data).unwrap()),
-//     );
-// }
-
 #[test]
 fn unsupported_version() {
     let (wh, mut contract) = proper_instantiate();
@@ -315,85 +203,6 @@ fn unsupported_version() {
     );
 }
 
-// TODO: port test
-// #[test]
-// fn reobservation() {
-//     let (wh, mut contract) = proper_instantiate();
-//     register_emitters(&wh, &mut contract, 7);
-
-//     let (v, data) = sign_vaa_body(&wh, create_vaa_body(6));
-//     contract
-//         .submit_vaas(vec![data])
-//         .expect("failed to submit VAA");
-
-//     // Now try submitting the same transfer as an observation.  This can happen when a guardian
-//     // re-observes a tx.
-//     let o = Observation {
-//         tx_hash: vec![0x55u8; 20].into(),
-//         timestamp: v.timestamp,
-//         nonce: v.nonce,
-//         emitter_chain: v.emitter_chain.into(),
-//         emitter_address: v.emitter_address.0,
-//         sequence: v.sequence,
-//         consistency_level: v.consistency_level,
-//         payload: serde_wormhole::to_vec(&v.payload).unwrap().into(),
-//     };
-//     let key = transfer::Key::new(o.emitter_chain, o.emitter_address.into(), o.sequence);
-
-//     let obs = to_binary(&vec![o]).unwrap();
-//     let index = wh.guardian_set_index();
-//     let signatures = sign_observations(&wh, &obs);
-//     for s in signatures {
-//         let resp = contract.submit_observations(obs.clone(), index, s).unwrap();
-//         let mut responses: Vec<SubmitObservationResponse> =
-//             from_binary(&resp.data.unwrap()).unwrap();
-
-//         assert_eq!(1, responses.len());
-//         let d = responses.remove(0);
-//         assert_eq!(key, d.key);
-//         assert!(matches!(d.status, ObservationStatus::Committed));
-//     }
-// }
-
-// TODO: port test
-// #[test]
-// fn digest_mismatch() {
-//     let (wh, mut contract) = proper_instantiate();
-//     register_emitters(&wh, &mut contract, 7);
-
-//     let (v, data) = sign_vaa_body(&wh, create_vaa_body(6));
-//     contract
-//         .submit_vaas(vec![data])
-//         .expect("failed to submit VAA");
-
-//     // Now try submitting an observation with the same (chain, address, sequence) tuple but with
-//     // different details.
-//     let o = Observation {
-//         tx_hash: vec![0x55u8; 20].into(),
-//         timestamp: v.timestamp,
-//         nonce: v.nonce ^ u32::MAX,
-//         emitter_chain: v.emitter_chain.into(),
-//         emitter_address: v.emitter_address.0,
-//         sequence: v.sequence,
-//         consistency_level: v.consistency_level,
-//         payload: serde_wormhole::to_vec(&v.payload).unwrap().into(),
-//     };
-
-//     let key = transfer::Key::new(o.emitter_chain, o.emitter_address.into(), o.sequence);
-//     let obs = to_binary(&vec![o]).unwrap();
-//     let index = wh.guardian_set_index();
-//     let signatures = sign_observations(&wh, &obs);
-//     for s in signatures {
-//         let resp = contract.submit_observations(obs.clone(), index, s).unwrap();
-//         let responses = from_binary::<Vec<SubmitObservationResponse>>(&resp.data.unwrap()).unwrap();
-//         assert_eq!(key, responses[0].key);
-//         if let ObservationStatus::Error(ref err) = responses[0].status {
-//             assert!(err.contains("digest mismatch"));
-//         } else {
-//             panic!(
-//                 "unexpected status for observation with mismatched digest: {:?}",
-//                 responses[0].status
-//             );
-//         }
-//     }
-// }
+// TODO: port reobservation test
+
+// TODO: port digest_mismatch test