20240813 peer container

src/common/types.rs

@@ -631,6 +631,9 @@ impl<X: ToClvm<NodePtr>> Sha256tree for X {
 pub struct Program(pub Vec<u8>);
 
 impl Program {
+    pub fn to_nodeptr(&self, allocator: &mut AllocEncoder) -> Result<NodePtr, Error> {
+        clvmr::serde::node_from_bytes(allocator.allocator(), &self.0).into_gen()
+    }
     pub fn from_nodeptr(allocator: &mut AllocEncoder, n: NodePtr) -> Result<Program, Error> {
         let bytes = clvmr::serde::node_to_bytes(allocator.allocator(), n).into_gen()?;
         Ok(Program(bytes))
@@ -640,6 +643,10 @@ impl Program {
         Program(by.to_vec())
     }
 
+    pub fn bytes(&self) -> &[u8] {
+        &self.0
+    }
+
     pub fn to_hex(&self) -> String {
         hex::encode(&self.0)
     }
@@ -724,6 +731,14 @@ impl Timeout {
     }
 }
 
+impl Add for Timeout {
+    type Output = Timeout;
+
+    fn add(self, rhs: Self) -> Timeout {
+        Timeout::new(self.0 + rhs.0)
+    }
+}
+
 impl ToClvm<NodePtr> for Timeout {
     fn to_clvm(
         &self,

src/lib.rs

@@ -2,6 +2,9 @@ pub mod channel_handler;
 mod common;
 mod log;
 pub mod outside;
+/// Provides as simple as possible a full blockchain interface that can be spoken
+/// with via a trait interface that's either local and synchronous or over a pipe.
+pub mod peer_container;
 mod referee;
 
 #[cfg(test)]

src/outside.rs

@@ -383,6 +383,7 @@ enum GameAction {
 /// the message through to the channel handler.
 #[allow(dead_code)]
 pub struct PotatoHandler {
+    initiator: bool,
     have_potato: PotatoState,
 
     handshake_state: HandshakeState,
@@ -456,6 +457,7 @@ impl PotatoHandler {
         reward_puzzle_hash: PuzzleHash,
     ) -> PotatoHandler {
         PotatoHandler {
+            initiator: have_potato,
             have_potato: if have_potato {
                 PotatoState::Present
             } else {
@@ -488,6 +490,10 @@ impl PotatoHandler {
         }
     }
 
+    pub fn is_initiator(&self) -> bool {
+        self.initiator
+    }
+
     pub fn channel_handler(&self) -> Result<&ChannelHandler, Error> {
         if let Some(ch) = &self.channel_handler {
             Ok(ch)
@@ -608,11 +614,13 @@ impl PotatoHandler {
                 }
                 self.update_channel_coin_after_receive(penv, &spend_info)?;
             }
-            PeerMessage::Accept(game_id, _amount, sigs) => {
+            PeerMessage::Accept(game_id, amount, sigs) => {
                 let spend_info = {
-                    let (env, _) = penv.env();
-                    ch.received_potato_accept(env, &sigs, &game_id)?
-                };
+                    let (env, system_interface) = penv.env();
+                    let result = ch.received_potato_accept(env, &sigs, &game_id)?;
+                    system_interface.game_finished(&game_id, amount)?;
+                    Ok(result)
+                }?;
                 self.update_channel_coin_after_receive(penv, &spend_info)?;
             }
             _ => {
@@ -667,6 +675,7 @@ impl PotatoHandler {
     {
         // Haven't got the channel coin yet.
         if self.waiting_to_start {
+            debug!("waiting to start");
             return Ok(());
         }
 
@@ -767,9 +776,10 @@ impl PotatoHandler {
                 let (_, system_interface) = penv.env();
                 system_interface.send_message(&PeerMessage::Accept(
                     game_id.clone(),
-                    amount,
+                    amount.clone(),
                     sigs,
                 ))?;
+                system_interface.game_finished(&game_id, amount)?;
                 self.have_potato = PotatoState::Absent;
 
                 Ok(true)
@@ -1203,6 +1213,8 @@ impl PotatoHandler {
                 match msg_envelope {
                     PeerMessage::HandshakeF { bundle } => {
                         self.channel_finished_transaction = Some(bundle.clone());
+                        let (_, system_interface) = penv.env();
+                        system_interface.received_channel_offer(&bundle)?;
                     }
                     PeerMessage::RequestPotato(_) => {
                         assert!(matches!(self.have_potato, PotatoState::Present));