add tests from app side

Author: 0xh3rman

crates/gem_bitcoin/src/signer/chain_signer.rs

@@ -48,7 +48,7 @@ mod tests {
     use primitives::ChainSigner;
 
     use super::*;
-    use crate::testkit::signer_mock::{TEST_PRIVATE_KEY, transfer_input};
+    use crate::testkit::signer_mock::{TEST_PRIVATE_KEY, funded_transfer_input, transfer_input, transfer_swap_input};
 
     fn sign_transfer(chain: BitcoinChain) -> String {
         BitcoinChainSigner::new(chain).sign_transfer(&transfer_input(chain), &TEST_PRIVATE_KEY).unwrap()
@@ -65,6 +65,18 @@ mod tests {
         assert_eq!(script[signature_len], 0x01);
     }
 
+    #[test]
+    fn test_sign_transfer_doge() {
+        let input = funded_transfer_input(BitcoinChain::Doge);
+        let raw = BitcoinChainSigner::new(BitcoinChain::Doge).sign_transfer(&input, &TEST_PRIVATE_KEY).unwrap();
+        let transaction: bitcoin::Transaction = deserialize(&hex::decode(raw).unwrap()).unwrap();
+        let script = transaction.input[0].script_sig.as_bytes();
+        let signature_len = script[0] as usize;
+        assert_eq!(transaction.input.len(), 1);
+        assert_eq!(transaction.output[0].value.to_sat(), 10_000);
+        assert_eq!(script[signature_len], 0x01);
+    }
+
     #[test]
     fn test_sign_transfer_bitcoin_cash() {
         let raw = sign_transfer(BitcoinChain::BitcoinCash);
@@ -82,4 +94,22 @@ mod tests {
         let zcash_bytes = hex::decode(raw).unwrap();
         assert_eq!(&zcash_bytes[..20], hex::decode("050000800a27a726f04dec4d0000000000000000").unwrap().as_slice());
     }
+
+    #[test]
+    fn test_sign_swap_memo_op_return() {
+        let memo = "=:s:0xEe7E9CcFb529f2c1Cc02C0Aea8aCed7Ec7e98B5e:0/1/0:g1:50";
+        let input = transfer_swap_input(BitcoinChain::Doge, memo);
+        let raw = BitcoinChainSigner::new(BitcoinChain::Doge).sign_swap(&input, &TEST_PRIVATE_KEY).unwrap().remove(0);
+        let transaction: bitcoin::Transaction = deserialize(&hex::decode(raw).unwrap()).unwrap();
+        let memo_output = transaction
+            .output
+            .iter()
+            .find(|output| output.script_pubkey.is_op_return())
+            .expect("expected OP_RETURN memo output");
+        let script = memo_output.script_pubkey.as_bytes();
+        assert_eq!(memo_output.value.to_sat(), 0);
+        assert_eq!(script[0], 0x6a);
+        assert_eq!(script[1] as usize, memo.len());
+        assert_eq!(&script[2..], memo.as_bytes());
+    }
 }

crates/gem_bitcoin/src/testkit/signer_mock.rs

@@ -3,7 +3,10 @@ use bitcoin::{
     secp256k1::{PublicKey as Secp256k1PublicKey, Secp256k1, SecretKey},
 };
 use num_bigint::BigInt;
-use primitives::{Asset, BitcoinChain, GasPriceType, SignerInput, TransactionFee, TransactionInputType, TransactionLoadInput, TransactionLoadMetadata, UTXO};
+use primitives::{
+    Asset, BitcoinChain, GasPriceType, SignerInput, SwapProvider, TransactionFee, TransactionInputType, TransactionLoadInput, TransactionLoadMetadata, UTXO,
+    swap::{SwapData, SwapProviderData, SwapQuote, SwapQuoteData},
+};
 
 use crate::{signer::address::public_key_hash, testkit::address_mock::address_for_hash};
 
@@ -60,6 +63,47 @@ pub fn transfer_input(chain: BitcoinChain) -> SignerInput {
     )
 }
 
+pub fn funded_transfer_input(chain: BitcoinChain) -> SignerInput {
+    let mut input = transfer_input(chain);
+    match &mut input.input.metadata {
+        TransactionLoadMetadata::Bitcoin { utxos } | TransactionLoadMetadata::Zcash { utxos, .. } => {
+            utxos[0].value = "100000000".to_string();
+        }
+        _ => {}
+    }
+    input
+}
+
+pub fn transfer_swap_input(chain: BitcoinChain, memo: &str) -> SignerInput {
+    let mut input = funded_transfer_input(chain);
+    let sender_address = input.sender_address.clone();
+    let destination_address = input.destination_address.clone();
+    let value = input.value.clone();
+
+    input.input.input_type = TransactionInputType::Swap(
+        Asset::from_chain(chain.get_chain()),
+        Asset::from_chain(BitcoinChain::Bitcoin.get_chain()),
+        SwapData {
+            quote: SwapQuote {
+                from_address: sender_address,
+                from_value: value.clone(),
+                to_address: destination_address.clone(),
+                to_value: value.clone(),
+                provider_data: SwapProviderData {
+                    provider: SwapProvider::Thorchain,
+                    name: "THORChain".to_string(),
+                    protocol_name: "thorchain".to_string(),
+                },
+                slippage_bps: 50,
+                eta_in_seconds: None,
+                use_max_amount: Some(false),
+            },
+            data: SwapQuoteData::new_tranfer(destination_address, value, Some(memo.to_string())),
+        },
+    );
+    input
+}
+
 pub(crate) fn utxo_with(transaction_id: &str, vout: i32, value: &str, address: &str) -> UTXO {
     UTXO {
         transaction_id: transaction_id.to_string(),