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

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

@@ -3129,10 +3129,12 @@ dependencies = [
 
 [[package]]
 name = "ddx-python"
-version = "1.0.6"
+version = "1.1.7"
 dependencies = [
  "core-common",
+ "core-crypto",
  "core-ddx",
+ "getrandom 0.3.4",
  "pyo3",
  "pyo3-stub-gen",
 ]

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ddx-python
-Version: 1.0.6
+Version: 1.1.7
 Classifier: Development Status :: 4 - Beta
 Classifier: Intended Audience :: Developers
 Classifier: Topic :: Office/Business :: Financial :: Investment
@@ -31,8 +31,6 @@ Requires-Dist: simplejson>=3.19.2,<4
 Requires-Dist: sphinx>=8.0.2,<9
 Requires-Dist: verboselogs>=1.7,<2
 Requires-Dist: btrees>=6.0,<7
-Requires-Dist: ccxt>=4.3.79,<5
-Requires-Dist: coincurve>=20.0.0,<21
 Requires-Dist: dash-bootstrap-components>=1.6.0,<2
 Requires-Dist: python-dotenv>=1.0.1,<2
 Requires-Dist: sexpdata>=1.0.2,<2

{ddx_python-1.0.6 → ddx_python-1.1.7}/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.7/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.7}/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.0.6 → ddx_python-1.1.7}/core/macros/src/lib.rs

@@ -124,7 +124,7 @@ pub fn nonced(input: TokenStream) -> TokenStream {
             let name = s.ident;
             let expanded = quote! {
                 impl Nonced for #name {
-                    fn nonce(&self) -> Nonce {
+                    fn get_nonce(&self) -> Nonce {
                         self.nonce
                     }
                 }
@@ -137,12 +137,12 @@ pub fn nonced(input: TokenStream) -> TokenStream {
             for v in e.variants.into_iter() {
                 let vname = v.ident;
                 arms.push(parse_quote! {
-                    #name::#vname(inner) => inner.nonce(),
+                    #name::#vname(inner) => inner.get_nonce(),
                 });
             }
             let expanded = quote! {
                 impl Nonced for #name {
-                        fn nonce(&self) -> Nonce {
+                        fn get_nonce(&self) -> Nonce {
                         match self {
                             #(#arms)*
                         }

{ddx_python-1.0.6 → ddx_python-1.1.7}/ddx-operator/core/Cargo.toml

@@ -13,7 +13,6 @@ default = [
     "fixed_expiry_future",
     "index_fund",
     "pred_market_future",
-    "private_equity_perp",
     "price_feed_fuzzer",
 ]
 alpha1 = []
@@ -40,7 +39,6 @@ eth-base = ["alloy", "alloy-sol-types"]
 multi_strategies = []
 insurance_fund_client_req = []
 index_fund = []
-private_equity_perp = []
 fixed_expiry_future = ["pyo3?/chrono"]
 pred_market_future = ["pyo3?/chrono"]
 

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

@@ -0,0 +1,331 @@
+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, OrderIntentPayload, 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::new(
+            OrderIntentPayload {
+                symbol: "ETHP".into(),
+                strategy: Default::default(),
+                side: OrderSide::Bid,
+                order_type: OrderType::Limit { post_only: false },
+                amount: unscaled!(10),
+                price: unscaled!(200),
+                stop_price: Default::default(),
+            },
+            Default::default(),
+            0,
+            crate::types::request::DEFAULT_RECV_WINDOW_MS,
+            Some(session_key_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.7}/ddx-operator/core/src/constants.rs

@@ -278,15 +278,9 @@ pub const COINGECKO_ID: &str = "coingecko";
 // The current polling threshold is set to 10 minutes.
 pub const COINGECKO_POLL_THRESHOLD: usize = 600;
 
-// Gecko terminal Hostname and SPCX contract address
-pub const GECKO_TERMINAL_ID: &str = "gecko-terminal";
-
 // Elections Kalshi Hostname and WAS contract address
 pub const ELECTIONS_KALSHI_ID: &str = "kalshi";
 
-// Due to rate limit and low liquidity, we need to poll less often for SPCX
-pub const SPCX_POLL_THRESHOLD: usize = 10;
-
 // Default limit on strategies a trader can have
 pub const MAX_STRATEGIES: u8 = 10;
 

{ddx_python-1.0.6 → ddx_python-1.1.7}/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);
     }