[WIP] add v2 integration tests

benalleng · benalleng · commit 549c95686074 · 2025-05-01T08:50:45.000-04:00
diff --git a/Cargo.lock b/Cargo.lock
diff --git a/Cargo.toml b/Cargo.toml
@@ -23,11 +23,13 @@ uniffi = { version = "0.29.1", features = ["build"] }
 
 [dependencies]
 base64 = "0.22.1"
-bitcoin-ffi = { git = "https://github.com/bitcoindevkit/bitcoin-ffi.git", rev = "6b1d131" }
+bitcoin-ffi = { git = "https://github.com/benalleng/bitcoin-ffi.git", rev = "37f47c8" }
 hex = "0.4.3"
+lazy_static = "1.5.0"
 ohttp = { package = "bitcoin-ohttp", version = "0.6.0" }
 payjoin = { version = "0.23.0", features = ["v1", "v2", "io"] }
 payjoin-test-utils = { version = "0.0.0", optional = true }
+reqwest = { version = "0.12", default-features = false, features = ["rustls-tls"] }
 serde = { version = "1.0.200", features = ["derive"] }
 serde_json = "1.0.128"
 thiserror = "1.0.58"
@@ -42,7 +44,6 @@ bitcoincore-rpc = "0.19.0"
 http = "1"
 ohttp-relay = "0.0.8"
 rcgen = { version = "0.11" }
-reqwest = { version = "0.12", default-features = false, features = ["rustls-tls"] }
 rustls = "0.22.2"
 testcontainers = "0.15.0"
 testcontainers-modules = { version = "0.1.3", features = ["redis"] }
diff --git a/python/requirements-dev.txt b/python/requirements-dev.txt
@@ -1,4 +1,4 @@
 python-bitcoinlib==0.12.2
 toml==0.10.2
 yapf==0.43.0
-
+httpx==0.28.1
diff --git a/python/test/payjoin_integration_test.py b/python/test/payjoin_integration_test.py
@@ -2,8 +2,10 @@
 from binascii import unhexlify
 import os
 import sys
+import httpx
 
 from payjoin import *
+from typing import Optional
 
 # The below sys path setting is required to use the 'payjoin' module in the 'src' directory
 # This script is in the 'tests' directory and the 'payjoin' module is in the 'src' directory
@@ -25,6 +27,11 @@
 
 SelectParams("regtest")
 
+def get_rpc_credentials_from_cookie(cookie_path):
+    """Reads the RPC credentials from the cookie file"""
+    with open(cookie_path, "r") as cookie_file:
+        credentials = cookie_file.read().strip()
+    return credentials.split(":")
 
 # Function to create and load a wallet if it doesn't already exist
 def create_and_load_wallet(rpc_connection, wallet_name):
@@ -47,141 +54,163 @@ def create_and_load_wallet(rpc_connection, wallet_name):
 rpc_password = os.environ.get("RPC_PASSWORD", "123")
 rpc_host = os.environ.get("RPC_HOST", "localhost")
 rpc_port = os.environ.get("RPC_PORT", "18443")
-
-
-class TestPayjoin(unittest.TestCase):
+#ensure this is where your access cookie is located
+rpc_data_dir = os.environ.get("RPC_DATA_DIR", "~/.bitcoin/regtest") 
+cookie_path = os.path.expanduser(os.path.join(rpc_data_dir, ".cookie"))
+rpc_user, rpc_password = get_rpc_credentials_from_cookie(cookie_path)
+
+class InMemoryReceiverPersister(payjoin_ffi.ReceiverPersister):
+    def __init__(self):
+        super().__init__()
+        self.receivers = {}
+
+    def save(self, receiver: Receiver) -> ReceiverToken:
+        self.receivers[receiver.key().as_string()] = receiver.to_json()
+
+        return receiver.key()
+
+    def load(self, token: ReceiverToken) -> Receiver:
+        token = token.as_string()
+        if token not in self.receivers.keys():
+            raise ValueError(f"Token not found: {token}")
+        return Receiver.from_json(self.receivers[token])
+
+class InMemorySenderPersister(payjoin_ffi.SenderPersister):
+    def __init__(self):
+        super().__init__()
+        self.senders = {}
+
+    def save(self, sender: Sender) -> SenderToken:
+        self.senders[sender.key().as_string()] = sender.to_json()
+        return sender.key()
+
+    def load(self, token: SenderToken) -> Sender:
+        token = token.as_string()
+        if token not in self.senders.keys():
+            raise ValueError(f"Token not found: {token}")
+        return Sender.from_json(self.senders[token])
+
+class TestPayjoin(unittest.IsolatedAsyncioTestCase):
     @classmethod
     def setUpClass(cls):
         # Initialize wallets once before all tests
         sender_wallet_name = "sender"
         sender_rpc_url = f"http://{rpc_user}:{rpc_password}@{rpc_host}:{rpc_port}/wallet/{sender_wallet_name}"
         cls.sender = Proxy(service_url=sender_rpc_url)
         create_and_load_wallet(cls.sender, sender_wallet_name)
-
+ 
         receiver_wallet_name = "receiver"
         receiver_rpc_url = f"http://{rpc_user}:{rpc_password}@{rpc_host}:{rpc_port}/wallet/{receiver_wallet_name}"
         cls.receiver = Proxy(service_url=receiver_rpc_url)
         create_and_load_wallet(cls.receiver, receiver_wallet_name)
+ 
 
-    def test_integration(self):
-        # Generate a new address for the sender
-        sender_address = self.sender.getnewaddress()
-        print(f"\nsender_address: {sender_address}")
-
-        # Generate a new address for the receiver
-        receiver_address = self.receiver.getnewaddress()
-        print(f"\nreceiver_address: {receiver_address}")
-
-        self.sender.generatetoaddress(101, str(sender_address))
-        self.receiver.generatetoaddress(101, str(receiver_address))
-
-        # Fetch and print the balance of the sender address
-        sender_balance = self.sender.getbalance()
-        print(f"Sender address balance: {sender_balance}")
-
-        # Fetch and print the balance of the receiver address
-        receiver_balance = self.receiver.getbalance()
-        print(f"Receiver address balance: {receiver_balance}")
-
-        pj_uri_address = self.receiver.getnewaddress()
-        pj_uri_string = "{}?amount={}&pj=https://example.com".format(
-            f"bitcoin:{str(pj_uri_address)}", 1
-        )
-        prj_uri = Uri.from_str(pj_uri_string).check_pj_supported()
-        print(f"\nprj_uri: {prj_uri.as_string()}")
-        outputs = {}
-        outputs[prj_uri.address()] = prj_uri.amount()
-        pre_processed_psbt = self.sender._call(
-            "walletcreatefundedpsbt",
-            [],
-            outputs,
-            0,
-            {"lockUnspents": True, "feeRate": 0.000020},
-        )["psbt"]
-        processed_psbt_base64 = self.sender._call("walletprocesspsbt", pre_processed_psbt)[
-            "psbt"
-        ]
-        req_ctx = RequestBuilder.from_psbt_and_uri(processed_psbt_base64, prj_uri ).build_with_additional_fee(10000, None, 0, False).extract_v1()
-        req = req_ctx.request
-        ctx = req_ctx.context_v1
-        headers = Headers.from_vec(req.body)
-        # **********************
-        # Inside the Receiver:
-        # this data would transit from one party to another over the network in production
-        response = self.handle_pj_request(
-            req=req,
-            headers=headers,
-            connection=self.receiver,
-        )
-        # this response would be returned as http response to the sender
-
-        # **********************
-        # Inside the Sender:
-        # Sender checks, signs, finalizes, extracts, and broadcasts
-        checked_payjoin_proposal_psbt = ctx.process_response(bytes(response, encoding='utf8'))
-        payjoin_processed_psbt = self.sender._call(
-            "walletprocesspsbt",
-            checked_payjoin_proposal_psbt,
-        )["psbt"]
-
-        payjoin_tx_hex = self.sender._call(
-            "finalizepsbt",
-            payjoin_processed_psbt,
-        )["hex"]
-
-        txid = self.sender._call("sendrawtransaction", payjoin_tx_hex)
-        print(f"\nBroadcast sucessful. Txid: {txid}")
-
-    def handle_pj_request(self, req: Request, headers: Headers, connection: Proxy):
-        proposal = UncheckedProposal.from_request(req.body, req.url.query(), headers)
-        _to_broadcast_in_failure_case = proposal.extract_tx_to_schedule_broadcast()
-        maybe_inputs_owned = proposal.check_broadcast_suitability(None,
-            can_broadcast=MempoolAcceptanceCallback(connection=connection)
-        )
-
-        mixed_inputs_scripts = maybe_inputs_owned.check_inputs_not_owned(
-            ScriptOwnershipCallback(connection)
-        )
-        inputs_seen = mixed_inputs_scripts.check_no_mixed_input_scripts()
-        payjoin = inputs_seen.check_no_inputs_seen_before(
-            OutputOwnershipCallback()
-        ).identify_receiver_outputs(ScriptOwnershipCallback(connection))
-        available_inputs = connection._call("listunspent")
-        candidate_inputs = {
-            int(int(i["amount"] * 100000000)): OutPoint(txid=(str(i["txid"])), vout=i["vout"])
-            for i in available_inputs
-        }
-
-        selected_outpoint = payjoin.try_preserving_privacy(
-            candidate_inputs=candidate_inputs
-        )
-
-        selected_utxo = next(
-            (
-                i
-                for i in available_inputs
-                if i["txid"] == selected_outpoint.txid
-                   and i["vout"] == selected_outpoint.vout
-            ),
-            None,
-        )
-
-        txo_to_contribute = TxOut(
-            value=int(selected_utxo["amount"] * 100000000),
-            script_pubkey=[int(byte) for byte in unhexlify(selected_utxo["scriptPubKey"])]
-        )
-        outpoint_to_contribute = OutPoint(
-            txid=selected_utxo["txid"], vout=int(selected_utxo["vout"])
-        )
-        payjoin.contribute_witness_input(txo_to_contribute, outpoint_to_contribute)
-        payjoin_proposal = payjoin.finalize_proposal(
-            ProcessPartiallySignedTransactionCallBack(connection=connection),
-            1,
-        )
-        psbt = payjoin_proposal.psbt()
-        print(f"\n Receiver's Payjoin proposal PSBT: {psbt}")
-        return psbt
-
+    async def test_integration_v2_to_v2(self):
+        try:
+            receiver_address = bitcoin.Address(str(self.receiver.getnewaddress()), bitcoin.Network.REGTEST)
+            init_tracing()
+            services = TestServices.initialize()
+
+            # agent = services.http_agent()
+            services.wait_for_services_ready()
+            directory = services.directory_url()
+            ohttp_keys = services.fetch_ohttp_keys()
+
+            # **********************
+            # Inside the Receiver:
+            expiry: Optional[int] = None
+            new_receiver = NewReceiver(receiver_address, directory.as_string(), ohttp_keys, expiry)
+            persister = InMemoryReceiverPersister()
+            token = new_receiver.persist(persister)
+            session: Receiver = Receiver.load(token, persister)
+            print(f"session: {session.to_json()}")
+            # Poll receive request
+            ohttp_relay = services.ohttp_relay_url()
+            request: RequestResponse = session.extract_req(ohttp_relay.as_string())
+            agent = httpx.AsyncClient()
+            response = await agent.post(
+                url=request.request.url.as_string(),
+                headers={"Content-Type": request.request.content_type},
+                content=request.request.body
+            )
+            response_body = session.process_res(response.content, request.client_response)
+            # No proposal yet since sender has not responded
+            self.assertIsNone(response_body)
+            
+            # **********************
+            # Inside the Sender:
+            # Create a funded PSBT (not broadcasted) to address with amount given in the pj_uri
+            pj_uri = session.pj_uri()
+            outputs = {}
+            outputs[pj_uri.address()] = 50
+            psbt = self.sender._call(
+                "walletcreatefundedpsbt",
+                [],
+                outputs,
+                0,
+                {"lockUnspents": True, "feeRate": 0.000020},
+                )["psbt"]
+            new_sender = SenderBuilder(psbt, pj_uri).build_recommended(1000)
+            persister = InMemorySenderPersister()
+            token = new_sender.persist(persister)
+            req_ctx: Sender = Sender.load(token, persister)
+            request: RequestV2PostContext = req_ctx.extract_v2(ohttp_relay)
+            response = await agent.post(
+                url=request.request.url.as_string(),
+                headers={"Content-Type": request.request.content_type},
+                content=request.request.body
+            )
+            send_ctx: V2GetContext = request.context.process_response(response.content)
+            # POST Original PSBT
+
+            # **********************
+            # Inside the Receiver:
+
+            # GET fallback psbt
+            request: RequestResponse = session.extract_req(ohttp_relay.as_string())
+            response = await agent.post(
+                url=request.request.url.as_string(),
+                headers={"Content-Type": request.request.content_type},
+                content=request.request.body
+            )
+            # POST payjoin
+            #proposal = session.process_res(response.content, request.client_response)
+            #pj_proposal = proposal
+            #payjoin_proposal = handle_directory_proposal(receiver, proposal, None)
+            #request: RequestResponse = payjoin_proposal.extract_req(ohttp_relay.as_string())
+            #response = await agent.post(
+            #    url=request.request.url.as_string(),
+            #    headers={"Content-Type": request.request.content_type},
+            #    content=request.request.body
+            #)
+            #payjoin_proposal.process_res(response, request.client_response)
+
+            # **********************
+            # Inside the Sender:
+            # Sender checks, signs, finalizes, extracts, and broadcasts
+            # Replay post fallback to get the response
+            request: RequestOhttpContext = send_ctx.extract_req(ohttp_relay.as_string())
+            response = await agent.post(
+                url=request.request.url.as_string(),
+                headers={"Content-Type": request.request.content_type},
+                content=request.request.body
+            )
+            checked_payjoin_proposal_psbt: Optional[str] = send_ctx.process_response(response.content, request.ohttp_ctx)
+            await sleep(10)
+            self.assertIsNotNone(checked_payjoin_proposal_psbt)
+            payjoin_tx = bitcoin.Psbt.extract_tx(checked_payjoin_proposal_psbt)
+            self.sender.sendrawtransaction(payjoin_tx)
+
+            # Check resulting transaction and balances
+            network_fees = bitcoin.blockdata.predicted_tx_weight(payjoin_tx) * 1000;
+            # Sender sent the entire value of their utxo to receiver (minus fees)
+            self.assertEqual(payjoin_tx.input.len(), 2);
+            self.assertEqual(payjoin_tx.output.len(), 1);
+            self.assertEqual(self.receiver.getbalance(), bitcoin.Amount.from_btc(100.0) - network_fees)
+            self.assertEqual(self.sender.getbalance(), bitcoin.Amount.from_btc(0.0))
+        except Exception as e:
+            print("Caught:", e)
+            raise
 
 class ProcessPartiallySignedTransactionCallBack:
     def __init__(self, connection: Proxy):
@@ -211,9 +240,9 @@ def callback(self, tx):
             return None      
 
 
-class OutputOwnershipCallback(IsOutputKnown):
-    def callback(self, outpoint: OutPoint):
-        return False
+# class OutputOwnershipCallback(IsOutputKnown):
+#     def callback(self, outpoint: OutPoint):
+#         return False
 
 
 class ScriptOwnershipCallback(IsScriptOwned):
diff --git a/src/receive/uni.rs b/src/receive/uni.rs
@@ -119,11 +119,7 @@ impl Receiver {
         persister: Arc<dyn ReceiverPersister>,
     ) -> Result<Self, ImplementationError> {
         Ok(super::Receiver::from(
-<<<<<<< HEAD
             (*persister.load(token).map_err(|e| ImplementationError::from(e.to_string()))?).clone(),
-=======
-            persister.load(token).map_err(|e| ImplementationError::from(e.to_string()))?,
->>>>>>> ff988e3 (Handle internal errors on `load()`)
         )
         .into())
     }
diff --git a/src/test_utils.rs b/src/test_utils.rs

Original file line number	Diff line number	Diff line change
`@@ -119,11 +119,7 @@ impl Receiver {`
`119`	`119`	`persister: Arc<dyn ReceiverPersister>,`
`120`	`120`	`) -> Result<Self, ImplementationError> {`
`121`	`121`	`Ok(super::Receiver::from(`
`122`		`-<<<<<<< HEAD`
`123`	`122`	`(*persister.load(token).map_err(\|e\| ImplementationError::from(e.to_string()))?).clone(),`
`124`		`-=======`
`125`		`- persister.load(token).map_err(\|e\| ImplementationError::from(e.to_string()))?,`
`126`		->>>>>>> ff988e3 (Handle internal errors on `load()`)
`127`	`123`	`)`
`128`	`124`	`.into())`
`129`	`125`	`}`