ddx-python 1.0.6__tar.gz → 1.1.6__tar.gz

{ddx_python-1.0.6 → ddx_python-1.1.6}/Cargo.lock

@@ -3129,7 +3129,7 @@ dependencies = [
 
 [[package]]
 name = "ddx-python"
-version = "1.0.6"
+version = "1.1.6"
 dependencies = [
  "core-common",
  "core-ddx",

{ddx_python-1.0.6 → ddx_python-1.1.6}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ddx-python
-Version: 1.0.6
+Version: 1.1.6
 Classifier: Development Status :: 4 - Beta
 Classifier: Intended Audience :: Developers
 Classifier: Topic :: Office/Business :: Financial :: Investment

{ddx_python-1.0.6 → ddx_python-1.1.6}/core/common/src/error.rs

@@ -5,6 +5,13 @@ use std::string::String;
 pub enum Error {
     #[error("Error with crypto tooling: {0}")]
     Crypto(String),
+    #[error("failed to deserialize {context}: {detail}")]
+    Deserialize {
+        context: &'static str,
+        detail: String,
+    },
+    #[error("Ecall failed with sgx_status={status} retval={retval}")]
+    Ecall { status: String, retval: String },
     #[error(transparent)]
     EnvVar(#[from] std::env::VarError),
     #[error(transparent)]
@@ -22,6 +29,11 @@ pub enum Error {
     Conversion(String),
     #[error(transparent)]
     Regex(#[from] regex::Error),
+    #[error("failed to serialize {context}: {detail}")]
+    Serialize {
+        context: &'static str,
+        detail: String,
+    },
     #[error("Error with serde serialize/deserialize: {0}")]
     Serde(String),
     #[error("Error with Sparse Merkle Tree tooling: {0}")]
@@ -32,6 +44,19 @@ pub enum Error {
 
 pub type Result<T, E = Error> = std::result::Result<T, E>;
 
+impl Error {
+    pub fn ecall(
+        status: impl ToString,
+        retval: Option<impl ToString + std::default::Default>,
+    ) -> Self {
+        let retval = retval.unwrap_or_default().to_string();
+        Self::Ecall {
+            status: status.to_string(),
+            retval,
+        }
+    }
+}
+
 impl From<sparse_merkle_tree::error::Error> for Error {
     fn from(e: sparse_merkle_tree::error::Error) -> Self {
         Error::SparseMerkleTree(format!("{e:?}"))

ddx_python-1.1.6/core/common/src/util/cbor.rs

@@ -0,0 +1,16 @@
+use crate::{Error, Result};
+use serde::{Serialize, de::DeserializeOwned};
+
+pub fn serialize<T: Serialize>(value: &T, context: &'static str) -> Result<Vec<u8>> {
+    cbor4ii::serde::to_vec(vec![], value).map_err(|err| Error::Serialize {
+        context,
+        detail: err.to_string(),
+    })
+}
+
+pub fn deserialize<T: DeserializeOwned>(bytes: &[u8], context: &'static str) -> Result<T> {
+    cbor4ii::serde::from_slice(bytes).map_err(|err| Error::Deserialize {
+        context,
+        detail: err.to_string(),
+    })
+}

{ddx_python-1.0.6 → ddx_python-1.1.6}/core/common/src/util/mod.rs

@@ -4,12 +4,15 @@ use std::time::{Duration, UNIX_EPOCH};
 
 #[cfg(not(target_family = "wasm"))]
 pub mod backoff;
+pub mod cbor;
 #[cfg(not(target_family = "wasm"))]
 pub mod mem;
 pub mod tokenize;
 #[cfg(not(target_family = "wasm"))]
 pub mod tracing;
 
+pub use cbor::{deserialize, serialize};
+
 pub fn get_app_share_dir(app_name: &str) -> String {
     let mut share_dir =
         std::env::var("APP_SHARE").expect("APP_SHARE must be set before running operator tooling");

ddx_python-1.1.6/ddx-operator/core/src/adapter.rs

@@ -0,0 +1,329 @@
+use crate::{
+    ExecutionOutcome,
+    types::request::{
+        AdvanceEpoch, AdvanceSettlementEpoch, Block, CancelAllIntent, CancelOrderIntent,
+        ClientRequest, ClientSequencingOutcome, Cmd, IndexPrice, MarketClose, MintPriceCheckpoint,
+        ModifyOrderIntent, OrderIntent, PreProcessedRequest, ProfileUpdateIntent, Receipt, Request,
+        RequestWithReceipt, SettlementValue, UpdateProductListings, UpgradeParams,
+        WithdrawDDXIntent, WithdrawIntent,
+    },
+};
+use anyhow::Error;
+use core_common::types::{auth::EnrollmentEvent, primitives::StampedTimeValue};
+use serde::{Deserialize, Serialize, de::DeserializeOwned};
+use thiserror::Error;
+
+#[derive(Debug, Error)]
+pub enum AdapterError {
+    #[error("failed to serialize {context}")]
+    Serialize {
+        context: &'static str,
+        #[source]
+        source: Error,
+    },
+    #[error("failed to deserialize {context}")]
+    Deserialize {
+        context: &'static str,
+        #[source]
+        source: Error,
+    },
+}
+
+fn serialize<T: Serialize>(value: &T, context: &'static str) -> Result<Vec<u8>, AdapterError> {
+    cbor4ii::serde::to_vec(vec![], value).map_err(|err| AdapterError::Serialize {
+        context,
+        source: Error::new(err),
+    })
+}
+
+fn deserialize<T: DeserializeOwned>(
+    bytes: &[u8],
+    context: &'static str,
+) -> Result<T, AdapterError> {
+    cbor4ii::serde::from_slice(bytes).map_err(|err| AdapterError::Deserialize {
+        context,
+        source: Error::new(err),
+    })
+}
+
+#[derive(Debug, Clone, PartialEq, Deserialize, Serialize)]
+#[serde(tag = "t", content = "c")]
+pub enum RequestWire {
+    Order(OrderIntent),
+    ModifyOrder(ModifyOrderIntent),
+    CancelOrder(CancelOrderIntent),
+    CancelAll(CancelAllIntent),
+    Withdraw(WithdrawIntent),
+    WithdrawDDX(WithdrawDDXIntent),
+    #[cfg(feature = "insurance_fund_client_req")]
+    InsuranceFundWithdraw(crate::types::request::InsuranceFundWithdrawIntent),
+    ProfileUpdate(ProfileUpdateIntent),
+    Genesis,
+    IndexPrice(IndexPrice),
+    MarketClose(MarketClose),
+    SettlementValue(SettlementValue),
+    Block(Block),
+    AdvanceTime(StampedTimeValue),
+    AdvanceEpoch(AdvanceEpoch),
+    AdvanceSettlementEpoch(AdvanceSettlementEpoch),
+    PriceCheckpoint(MintPriceCheckpoint),
+    UpdateProductListings(UpdateProductListings),
+    UpdateEnrollment(EnrollmentEvent),
+    Upgrade(UpgradeParams),
+}
+
+#[derive(Debug, Clone, PartialEq, Deserialize, Serialize)]
+pub struct RequestWithReceiptWire {
+    pub request: RequestWire,
+    pub receipt: Receipt,
+}
+
+impl From<&Request> for RequestWire {
+    fn from(value: &Request) -> Self {
+        match value {
+            Request::ClientRequest(request) => match request {
+                ClientRequest::Order(request) => Self::Order(request.clone()),
+                ClientRequest::ModifyOrder(request) => Self::ModifyOrder(request.clone()),
+                ClientRequest::CancelOrder(request) => Self::CancelOrder(request.clone()),
+                ClientRequest::CancelAll(request) => Self::CancelAll(request.clone()),
+                ClientRequest::Withdraw(request) => Self::Withdraw(request.clone()),
+                ClientRequest::WithdrawDDX(request) => Self::WithdrawDDX(request.clone()),
+                #[cfg(feature = "insurance_fund_client_req")]
+                ClientRequest::InsuranceFundWithdraw(request) => {
+                    Self::InsuranceFundWithdraw(request.clone())
+                }
+                ClientRequest::ProfileUpdate(request) => Self::ProfileUpdate(request.clone()),
+            },
+            Request::Cmd(cmd) => match cmd {
+                Cmd::Genesis => Self::Genesis,
+                Cmd::IndexPrice(cmd) => Self::IndexPrice(cmd.clone()),
+                Cmd::MarketClose(cmd) => Self::MarketClose(cmd.clone()),
+                Cmd::SettlementValue(cmd) => Self::SettlementValue(cmd.clone()),
+                Cmd::Block(cmd) => Self::Block(cmd.clone()),
+                Cmd::AdvanceTime(cmd) => Self::AdvanceTime(*cmd),
+                Cmd::AdvanceEpoch(cmd) => Self::AdvanceEpoch(cmd.clone()),
+                Cmd::AdvanceSettlementEpoch(cmd) => Self::AdvanceSettlementEpoch(cmd.clone()),
+                Cmd::PriceCheckpoint(cmd) => Self::PriceCheckpoint(cmd.clone()),
+                Cmd::UpdateProductListings(cmd) => Self::UpdateProductListings(cmd.clone()),
+                Cmd::UpdateEnrollment(cmd) => Self::UpdateEnrollment(cmd.clone()),
+                Cmd::Upgrade(cmd) => Self::Upgrade(cmd.clone()),
+            },
+        }
+    }
+}
+
+impl From<RequestWire> for Request {
+    fn from(value: RequestWire) -> Self {
+        match value {
+            RequestWire::Order(request) => Self::ClientRequest(ClientRequest::Order(request)),
+            RequestWire::ModifyOrder(request) => {
+                Self::ClientRequest(ClientRequest::ModifyOrder(request))
+            }
+            RequestWire::CancelOrder(request) => {
+                Self::ClientRequest(ClientRequest::CancelOrder(request))
+            }
+            RequestWire::CancelAll(request) => {
+                Self::ClientRequest(ClientRequest::CancelAll(request))
+            }
+            RequestWire::Withdraw(request) => Self::ClientRequest(ClientRequest::Withdraw(request)),
+            RequestWire::WithdrawDDX(request) => {
+                Self::ClientRequest(ClientRequest::WithdrawDDX(request))
+            }
+            #[cfg(feature = "insurance_fund_client_req")]
+            RequestWire::InsuranceFundWithdraw(request) => {
+                Self::ClientRequest(ClientRequest::InsuranceFundWithdraw(request))
+            }
+            RequestWire::ProfileUpdate(request) => {
+                Self::ClientRequest(ClientRequest::ProfileUpdate(request))
+            }
+            RequestWire::Genesis => Self::Cmd(Cmd::Genesis),
+            RequestWire::IndexPrice(cmd) => Self::Cmd(Cmd::IndexPrice(cmd)),
+            RequestWire::MarketClose(cmd) => Self::Cmd(Cmd::MarketClose(cmd)),
+            RequestWire::SettlementValue(cmd) => Self::Cmd(Cmd::SettlementValue(cmd)),
+            RequestWire::Block(cmd) => Self::Cmd(Cmd::Block(cmd)),
+            RequestWire::AdvanceTime(cmd) => Self::Cmd(Cmd::AdvanceTime(cmd)),
+            RequestWire::AdvanceEpoch(cmd) => Self::Cmd(Cmd::AdvanceEpoch(cmd)),
+            RequestWire::AdvanceSettlementEpoch(cmd) => Self::Cmd(Cmd::AdvanceSettlementEpoch(cmd)),
+            RequestWire::PriceCheckpoint(cmd) => Self::Cmd(Cmd::PriceCheckpoint(cmd)),
+            RequestWire::UpdateProductListings(cmd) => Self::Cmd(Cmd::UpdateProductListings(cmd)),
+            RequestWire::UpdateEnrollment(cmd) => Self::Cmd(Cmd::UpdateEnrollment(cmd)),
+            RequestWire::Upgrade(cmd) => Self::Cmd(Cmd::Upgrade(cmd)),
+        }
+    }
+}
+
+impl From<&RequestWithReceipt> for RequestWithReceiptWire {
+    fn from(value: &RequestWithReceipt) -> Self {
+        Self {
+            request: RequestWire::from(&value.request),
+            receipt: value.receipt.clone(),
+        }
+    }
+}
+
+impl From<RequestWithReceiptWire> for RequestWithReceipt {
+    fn from(value: RequestWithReceiptWire) -> Self {
+        Self {
+            request: value.request.into(),
+            receipt: value.receipt,
+        }
+    }
+}
+
+pub fn serialize_preprocessed_request(
+    request: &PreProcessedRequest,
+) -> Result<Vec<u8>, AdapterError> {
+    serialize(request, "pre-processed request")
+}
+
+pub fn deserialize_preprocessed_request(bytes: &[u8]) -> Result<PreProcessedRequest, AdapterError> {
+    deserialize(bytes, "pre-processed request")
+}
+
+pub fn serialize_execution_outcome(outcome: &ExecutionOutcome) -> Result<Vec<u8>, AdapterError> {
+    serialize(outcome, "execution outcome")
+}
+
+pub fn deserialize_execution_outcome(bytes: &[u8]) -> Result<ExecutionOutcome, AdapterError> {
+    deserialize(bytes, "execution outcome")
+}
+
+pub fn serialize_request_with_receipt(value: &RequestWithReceipt) -> Result<Vec<u8>, AdapterError> {
+    serialize(&RequestWithReceiptWire::from(value), "request with receipt")
+}
+
+pub fn deserialize_request_with_receipt(bytes: &[u8]) -> Result<RequestWithReceipt, AdapterError> {
+    deserialize::<RequestWithReceiptWire>(bytes, "request with receipt").map(Into::into)
+}
+
+pub fn serialize_client_sequencing_outcome(
+    value: &ClientSequencingOutcome,
+) -> Result<Vec<u8>, AdapterError> {
+    serialize(value, "client sequencing outcome")
+}
+
+pub fn deserialize_client_sequencing_outcome(
+    bytes: &[u8],
+) -> Result<ClientSequencingOutcome, AdapterError> {
+    deserialize(bytes, "client sequencing outcome")
+}
+
+pub fn serialize_request(request: &Request) -> Result<Vec<u8>, AdapterError> {
+    serialize(&RequestWire::from(request), "request")
+}
+
+pub fn deserialize_request(bytes: &[u8]) -> Result<Request, AdapterError> {
+    deserialize::<RequestWire>(bytes, "request").map(Into::into)
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::{
+        ExecutionOutcome,
+        types::{
+            request::{
+                ClientRequest, ClientSequencingOutcome, Cmd, DdxSessionDelegatedPayload,
+                OrderIntent, OrderType, PreProcessedRequest, Receipt, Request, RequestWithReceipt,
+                SessionAction,
+            },
+            transaction::ExecutionOps,
+        },
+    };
+    use core_common::types::primitives::{CompressedKey, OrderSide};
+    use core_crypto::eip712::encode_delegated_policy_proof_v2;
+    use core_macros::unscaled;
+    use std::collections::BTreeSet;
+
+    fn order_request_with_session_key_signature() -> Request {
+        let session_key_signature = encode_delegated_policy_proof_v2(&DdxSessionDelegatedPayload {
+            session_signature: Default::default(),
+            expiry: 42,
+            acl_scope: BTreeSet::from([SessionAction::Order]),
+            session_public_key: CompressedKey::from_slice(&[0_u8; 33]),
+        })
+        .expect("encode delegated payload");
+
+        Request::ClientRequest(ClientRequest::Order(OrderIntent {
+            symbol: "ETHP".into(),
+            strategy: Default::default(),
+            side: OrderSide::Bid,
+            order_type: OrderType::Limit { post_only: false },
+            nonce: Default::default(),
+            client_timestamp_ms: 0,
+            recv_window_ms: crate::types::request::DEFAULT_RECV_WINDOW_MS,
+            amount: unscaled!(10),
+            price: unscaled!(200),
+            stop_price: Default::default(),
+            session_key_signature: Some(session_key_signature),
+            signature: Default::default(),
+        }))
+    }
+
+    #[test]
+    fn round_trip_preprocessed_request() {
+        let request = PreProcessedRequest::AdvanceTime(Default::default());
+        let encoded = serialize_preprocessed_request(&request).unwrap();
+        let decoded = deserialize_preprocessed_request(&encoded).unwrap();
+        assert_eq!(request, decoded);
+    }
+
+    #[test]
+    fn round_trip_execution_outcome() {
+        let outcome = ExecutionOutcome::Success(ExecutionOps::NonStateTransitioning(Vec::new()));
+        let encoded = serialize_execution_outcome(&outcome).unwrap();
+        let decoded = deserialize_execution_outcome(&encoded).unwrap();
+        assert_eq!(format!("{outcome:?}"), format!("{decoded:?}"));
+    }
+
+    #[test]
+    fn round_trip_request_with_receipt() {
+        let request = RequestWithReceipt {
+            request: Request::Cmd(Cmd::AdvanceTime(Default::default())),
+            receipt: Receipt::Sequenced {
+                nonce: Default::default(),
+                request_hash: Default::default(),
+                request_index: 1,
+                sender: Default::default(),
+                enclave_signature: Default::default(),
+            },
+        };
+        let encoded = serialize_request_with_receipt(&request).unwrap();
+        let decoded = deserialize_request_with_receipt(&encoded).unwrap();
+        assert_eq!(request, decoded);
+    }
+
+    #[test]
+    fn round_trip_retained_client_sequencing_outcome() {
+        let outcome = ClientSequencingOutcome::retained_retry(RequestWithReceipt {
+            request: Request::Cmd(Cmd::AdvanceTime(Default::default())),
+            receipt: Receipt::Sequenced {
+                nonce: Default::default(),
+                request_hash: Default::default(),
+                request_index: 9,
+                sender: Default::default(),
+                enclave_signature: Default::default(),
+            },
+        });
+        let encoded = serialize_client_sequencing_outcome(&outcome).unwrap();
+        let decoded = deserialize_client_sequencing_outcome(&encoded).unwrap();
+        assert_eq!(outcome, decoded);
+        assert!(!decoded.is_fresh());
+    }
+
+    #[test]
+    fn round_trip_request() {
+        let request = Request::Cmd(Cmd::AdvanceTime(Default::default()));
+        let encoded = serialize_request(&request).unwrap();
+        let decoded = deserialize_request(&encoded).unwrap();
+        assert_eq!(request, decoded);
+    }
+
+    #[test]
+    fn round_trip_order_request_with_session_key_signature() {
+        let request = order_request_with_session_key_signature();
+        let encoded = serialize_request(&request).unwrap();
+        let decoded = deserialize_request(&encoded).unwrap();
+        assert_eq!(request, decoded);
+    }
+}

{ddx_python-1.0.6 → ddx_python-1.1.6}/ddx-operator/core/src/execution/accounting.rs

@@ -243,9 +243,12 @@ pub mod tests {
     fn test_calculate_fees() {
         let amount = dec!(10);
         let price = dec!(100);
+        let maker_fee = TradeSide::Maker.trading_fee(amount, price);
         let taker_fee = TradeSide::Taker.trading_fee(amount, price);
         let notional = amount * price;
         let fee = notional * *TAKER_FEE_BPS;
+        assert_eq!(maker_fee, Decimal::ZERO);
+        assert_eq!(taker_fee, dec!(0.5));
         assert_eq!(taker_fee, fee);
     }
 

{ddx_python-1.0.6 → ddx_python-1.1.6}/ddx-operator/core/src/execution/validation.rs

@@ -1694,6 +1694,7 @@ pub mod test {
                     ask_amount: amount,
                 },
             },
+            // NOTE: Treat nonzero fixture fee_percentage values as algebra inputs, not current fee-policy constants.
             // Substituting values into derivation 1:
             //
             // delta = 100 / (10 * 1 / 20 + 0.002 * 10) = 100 / (52 / 100) = 10000 / 52

{ddx_python-1.0.6 → ddx_python-1.1.6}/ddx-operator/core/src/types/accounting.rs

@@ -43,9 +43,9 @@ pub const DEFAULT_MAX_LEVERAGE: u64 = 3;
 
 lazy_static! {
     static ref EMA_PERIODS: Decimal = Decimal::from(30);
-    pub static ref MAKER_FEE_BPS: Decimal = Decimal::from_f32(0.0).unwrap();
-    // The taker fee is currently set to 20 bps
-    pub static ref TAKER_FEE_BPS: Decimal = Decimal::from_f32(0.002).unwrap();
+    pub static ref MAKER_FEE_BPS: Decimal = dec!(0);
+    // The taker fee is currently set to 5 bps
+    pub static ref TAKER_FEE_BPS: Decimal = dec!(0.0005);
     // The maintenance margin fraction. A maintenance margin fraction of
     // 0.15 gives a maintenance margin ratio of 0.15 / 3 = 0.05.
     pub static ref MMR_FRACTION: Decimal = Decimal::from_f32(0.15).unwrap();

{ddx_python-1.0.6 → ddx_python-1.1.6}/ddx-python/Cargo.toml

@@ -1,7 +1,7 @@
 [package]
 name = "ddx-python"
 # NOTE: The maturin.bash build script replaces this by the SEMVER env variable for distribution.
-version = "1.0.6"
+version = "1.1.6"
 edition = "2024"
 
 [lib]

{ddx_python-1.0.6 → ddx_python-1.1.6}/ddx-python/python/tests/affiliate_tests.py

@@ -108,8 +108,8 @@ async def test_affiliate_split_standard_usdc():
                 Decimal("0"),
             )
 
-            # Compute expected split on taker fee: 1 * 100 * 0.002 = 0.2 USDC.
-            fee = Decimal("0.2")
+            # Compute expected split on taker fee: 1 * 100 * 0.0005 = 0.05 USDC.
+            fee = Decimal("0.05")
             expected_l1 = fee * Decimal("0.10")
             expected_l2 = fee * Decimal("0.05")
             expected_rebate = fee * Decimal("0.10")