auction: define action balances

crates/core/asset/src/asset/registry.rs

@@ -417,5 +417,13 @@ pub static REGISTRY: Lazy<Registry> = Lazy::new(|| {
                     },
                 ])
             }) as for<'r> fn(&'r str) -> _)
+            .add_asset(
+                "^auctionnft_(?P<seq_num>[0-9]+)_(?P<auction_id>paucid1[a-zA-HJ-NP-Z0-9]+)$",
+                &[ /* no display units - nft, unit 1 */ ],
+                (|data: &str| {
+                    assert!(!data.is_empty());
+                    denom_metadata::Inner::new(format!("auctionnft_{data}"), vec![])
+                }) as for<'r> fn(&'r str) -> _,
+            )
         .build()
 });

crates/core/component/auction/Cargo.toml

@@ -45,6 +45,7 @@ bech32 = {workspace = true}
 bitvec = {workspace = true}
 cnidarium = {workspace = true, default-features = false, optional = true}
 cnidarium-component = {workspace = true, default-features = false, optional = true}
+blake2b_simd = {workspace = true}
 decaf377 = {workspace = true, features = ["r1cs"], default-features = true}
 decaf377-rdsa = {workspace = true}
 futures = {workspace = true, optional = true}

crates/core/component/auction/src/auction.rs

@@ -1,3 +1,6 @@
 pub mod dutch;
 pub mod id;
 pub mod nft;
+
+pub use id::AuctionId;
+pub use nft::AuctionNft;

crates/core/component/auction/src/auction/dutch.rs

@@ -5,8 +5,12 @@ use penumbra_num::Amount;
 use penumbra_proto::{core::component::auction::v1alpha1 as pb, DomainType};
 use serde::{Deserialize, Serialize};
 
+use crate::auction::AuctionId;
+
 pub mod actions;
 
+pub const DUTCH_AUCTION_DOMAIN_SEP: &[u8] = b"penumbra_DA_nft";
+
 /// A deployed Dutch Auction, containing an immutable description
 /// and stateful data about its current state.
 #[derive(Clone, Serialize, Deserialize, PartialEq, Eq)]
@@ -65,6 +69,28 @@ pub struct DutchAuctionDescription {
     pub nonce: [u8; 32],
 }
 
+impl DutchAuctionDescription {
+    /// Compute the unique identifier for the auction description.
+    pub fn id(&self) -> AuctionId {
+        let mut state = blake2b_simd::Params::default()
+            .personal(DUTCH_AUCTION_DOMAIN_SEP)
+            .to_state();
+
+        state.update(&self.nonce);
+        state.update(&self.input.asset_id.to_bytes());
+        state.update(&self.input.amount.to_le_bytes());
+        state.update(&self.max_output.to_le_bytes());
+        state.update(&self.start_height.to_le_bytes());
+        state.update(&self.end_height.to_le_bytes());
+        state.update(&self.step_count.to_le_bytes());
+
+        let hash = state.finalize();
+        let mut bytes = [0; 32];
+        bytes[0..32].copy_from_slice(&hash.as_bytes()[0..32]);
+        AuctionId(bytes)
+    }
+}
+
 /* Protobuf impls */
 impl DomainType for DutchAuctionDescription {
     type Proto = pb::DutchAuctionDescription;

crates/core/component/auction/src/auction/dutch/actions/end.rs

@@ -1,8 +1,9 @@
 use anyhow::anyhow;
+use penumbra_asset::{Balance, Value};
 use penumbra_proto::{core::component::auction::v1alpha1 as pb, DomainType};
 use serde::{Deserialize, Serialize};
 
-use crate::auction::id::AuctionId;
+use crate::auction::{id::AuctionId, AuctionNft};
 
 #[derive(Debug, Clone, Serialize, Deserialize)]
 #[serde(
@@ -13,6 +14,31 @@ pub struct ActionDutchAuctionEnd {
     pub auction_id: AuctionId,
 }
 
+impl ActionDutchAuctionEnd {
+    /// Compute the value balance for this action
+    ///
+    /// # Diagram
+    ///
+    ///  ┌────────────────────┬──────────────────────┐
+    ///  │      Burn (-)      │       Mint (+)       │
+    ///  ├────────────────────┼──────────────────────┤
+    ///  │ opened auction nft │  closed auction nft  │
+    ///  └────────────────────┴──────────────────────┘
+    pub fn balance(&self) -> Balance {
+        let start_auction = Value {
+            amount: 1u128.into(),
+            asset_id: AuctionNft::new(self.auction_id, 0u64).asset_id(),
+        };
+
+        let end_auction = Value {
+            amount: 1u128.into(),
+            asset_id: AuctionNft::new(self.auction_id, 1u64).asset_id(),
+        };
+
+        Balance::from(end_auction) - Balance::from(start_auction)
+    }
+}
+
 /* Protobuf impls */
 impl DomainType for ActionDutchAuctionEnd {
     type Proto = pb::ActionDutchAuctionEnd;

crates/core/component/auction/src/auction/dutch/actions/mod.rs

@@ -1,14 +1,8 @@
 pub mod schedule;
 pub use schedule::ActionDutchAuctionSchedule;
 
-pub mod schedule_view;
-pub use schedule_view::ActionDutchAuctionScheduleView;
-
 pub mod end;
 pub use end::ActionDutchAuctionEnd;
 
 pub mod withdraw;
 pub use withdraw::ActionDutchAuctionWithdraw;
-
-pub mod withdraw_view;
-pub use withdraw_view::ActionDutchAuctionWithdrawView;

crates/core/component/auction/src/auction/dutch/actions/schedule.rs

@@ -1,5 +1,6 @@
-use crate::auction::dutch::DutchAuctionDescription;
+use crate::auction::{dutch::DutchAuctionDescription, nft::AuctionNft};
 use anyhow::anyhow;
+use penumbra_asset::{Balance, Value};
 use penumbra_proto::{core::component::auction::v1alpha1 as pb, DomainType};
 use serde::{Deserialize, Serialize};
 
@@ -12,6 +13,30 @@ pub struct ActionDutchAuctionSchedule {
     pub description: DutchAuctionDescription,
 }
 
+impl ActionDutchAuctionSchedule {
+    /// Compute the value balance corresponding to this action:
+    ///
+    /// # Diagram
+    ///
+    ///  ┌────────────────────┬──────────────────────┐
+    ///  │      Burn (-)      │       Mint (+)       │
+    ///  ├────────────────────┼──────────────────────┤
+    ///  │    input value     │  opened auction nft  │
+    ///  └────────────────────┴──────────────────────┘                  
+    pub fn balance(&self) -> Balance {
+        let opened_auction_nft = AuctionNft::new(self.description.id(), 0u64);
+        let opened_auction_nft_value = Value {
+            asset_id: opened_auction_nft.metadata.id(),
+            amount: 1u128.into(),
+        };
+
+        let output_nft_balance = Balance::from(opened_auction_nft_value);
+        let input_balance = Balance::from(self.description.input);
+
+        output_nft_balance - input_balance
+    }
+}
+
 /* Protobuf impls */
 impl DomainType for ActionDutchAuctionSchedule {
     type Proto = pb::ActionDutchAuctionSchedule;

crates/core/component/auction/src/auction/dutch/actions/withdraw.rs

@@ -1,6 +1,8 @@
-use crate::auction::id::AuctionId;
+use crate::auction::{id::AuctionId, AuctionNft};
 use anyhow::anyhow;
-use penumbra_asset::balance;
+use ark_ff::Zero;
+use decaf377_rdsa::Fr;
+use penumbra_asset::{balance, Balance, Value};
 use penumbra_proto::{core::component::auction::v1alpha1 as pb, DomainType};
 use serde::{Deserialize, Serialize};
 
@@ -15,6 +17,44 @@ pub struct ActionDutchAuctionWithdraw {
     pub reserves_commitment: balance::Commitment,
 }
 
+impl ActionDutchAuctionWithdraw {
+    /// Compute a balance **commitment** for this action.
+    ///
+    /// # Diagram
+    ///
+    /// The value balance commitment is built from the balance:
+    ///  ┌────────────────────┬──────────────────────┐
+    ///  │      Burn (-)      │       Mint (+)       │
+    ///  ├────────────────────┼──────────────────────┤
+    ///  │    auction nft     │       auction        │
+    ///  │   with seq >= 1    │    value balance     │
+    ///  └────────────────────┼──────────────────────┤
+    ///                       │withdrawn auction nft │
+    ///                       │      with seq+1      │
+    ///                       └──────────────────────┘
+    ///
+    /// More context: [Actions and Value balance][protocol-spec]
+    /// [protocol-spec]: https://protocol.penumbra.zone/main/transactions.html#actions-and-value-balance
+    pub fn balance_commitment(&self) -> balance::Commitment {
+        let prev_auction_nft = Balance::from(Value {
+            amount: 1u128.into(),
+            // The sequence number should always be >= 1, because we can
+            // only withdraw an auction that has ended (i.e. with sequence number `>=1`).
+            // We use a saturating operation defensively so that we don't underflow.
+            asset_id: AuctionNft::new(self.auction_id, self.seq.saturating_sub(1)).asset_id(),
+        })
+        .commit(Fr::zero());
+
+        let next_auction_nft = Balance::from(Value {
+            amount: 1u128.into(),
+            asset_id: AuctionNft::new(self.auction_id, self.seq).asset_id(),
+        })
+        .commit(Fr::zero());
+
+        self.reserves_commitment + next_auction_nft - prev_auction_nft
+    }
+}
+
 /* Protobuf impls */
 impl DomainType for ActionDutchAuctionWithdraw {
     type Proto = pb::ActionDutchAuctionWithdraw;

crates/core/component/auction/src/auction/nft.rs

@@ -1,15 +1,31 @@
 use crate::auction::id::AuctionId;
 use anyhow::{anyhow, Result};
+use penumbra_asset::asset::{self};
 use penumbra_proto::{core::component::auction::v1alpha1 as pb, DomainType};
 
 /// An non-fungible token (NFT) tracking the state and ownership of an auction.
 #[derive(Debug, Clone)]
 pub struct AuctionNft {
     /// The unique identifier for the auction this nft resolves to.
-    id: AuctionId,
+    pub id: AuctionId,
     /// The state of an auction, its specific semantics depend on the
     /// type of auction the NFT resolves to.
-    seq: u64,
+    pub seq: u64,
+    /// The metadata corresponding to the nft denom.
+    pub metadata: asset::Metadata,
+}
+
+impl AuctionNft {
+    pub fn new(id: AuctionId, seq: u64) -> AuctionNft {
+        let metadata = asset::REGISTRY
+            .parse_denom(&format!("auctionnft_{seq}_{id}"))
+            .expect("auction nft denom is valid");
+        AuctionNft { id, seq, metadata }
+    }
+
+    pub fn asset_id(&self) -> asset::Id {
+        self.metadata.id()
+    }
 }
 
 /* Protobuf impls ;*/
@@ -30,12 +46,11 @@ impl TryFrom<pb::AuctionNft> for AuctionNft {
     type Error = anyhow::Error;
 
     fn try_from(msg: pb::AuctionNft) -> Result<Self, Self::Error> {
-        Ok(Self {
-            id: msg
-                .id
-                .ok_or_else(|| anyhow!("AuctionNft message is missing an auction id"))?
-                .try_into()?,
-            seq: msg.seq,
-        })
+        let id: AuctionId = msg
+            .id
+            .ok_or_else(|| anyhow!("AuctionNft message is missing an auction id"))?
+            .try_into()?;
+        let seq = msg.seq;
+        Ok(AuctionNft::new(id, seq))
     }
 }

crates/core/transaction/src/is_action.rs

@@ -1,6 +1,9 @@
 use ark_ff::Zero;
 use decaf377::Fr;
 use penumbra_asset::{balance, Value};
+use penumbra_auction::auction::dutch::actions::{
+    ActionDutchAuctionEnd, ActionDutchAuctionSchedule, ActionDutchAuctionWithdraw,
+};
 use penumbra_community_pool::{CommunityPoolDeposit, CommunityPoolOutput, CommunityPoolSpend};
 use penumbra_dex::{
     lp::{
@@ -406,3 +409,33 @@ impl IsAction for SwapClaim {
         }
     }
 }
+
+impl IsAction for ActionDutchAuctionSchedule {
+    fn balance_commitment(&self) -> balance::Commitment {
+        self.balance().commit(Fr::zero())
+    }
+
+    fn view_from_perspective(&self, _txp: &TransactionPerspective) -> ActionView {
+        todo!()
+    }
+}
+
+impl IsAction for ActionDutchAuctionEnd {
+    fn balance_commitment(&self) -> balance::Commitment {
+        self.balance().commit(Fr::zero())
+    }
+
+    fn view_from_perspective(&self, _txp: &TransactionPerspective) -> ActionView {
+        todo!()
+    }
+}
+
+impl IsAction for ActionDutchAuctionWithdraw {
+    fn balance_commitment(&self) -> balance::Commitment {
+        self.balance_commitment()
+    }
+
+    fn view_from_perspective(&self, _txp: &TransactionPerspective) -> ActionView {
+        todo!()
+    }
+}