acta_maker_sdk/orders/
mod.rs

1use ed25519_dalek::{Signature, Signer, SigningKey, Verifier, VerifyingKey};
2use sha2::{Digest, Sha256};
3use thiserror::Error;
4use zeroize::{Zeroize, ZeroizeOnDrop};
5
6use crate::signing::sign_verified;
7use crate::types::PositionType;
8use crate::wire::{WireError, decode_base58_32, decode_base58_64, encode_base58, encode_hex};
9use crate::{AsyncSignerLike, SigningError};
10
11pub const ORDER_ID_LEN: usize = 32;
12pub const ORDER_DOMAIN_TAG: [u8; 4] = *b"ACTA";
13
14const TAG_LEN: usize = 4;
15const CHAIN_ID_LEN: usize = 8;
16const PUBKEY_LEN: usize = 32;
17const BOOL_LEN: usize = 1;
18const U64_LEN: usize = 8;
19const HEADER_LEN: usize = TAG_LEN + CHAIN_ID_LEN + PUBKEY_LEN;
20
21// Body field offsets (relative to HEADER_LEN).
22const OFF_IS_TAKER_BUY: usize = 0;
23const OFF_POSITION_TYPE: usize = OFF_IS_TAKER_BUY + BOOL_LEN;
24const OFF_MARKET: usize = OFF_POSITION_TYPE + BOOL_LEN;
25const OFF_STRIKE: usize = OFF_MARKET + PUBKEY_LEN;
26const OFF_QUANTITY: usize = OFF_STRIKE + U64_LEN;
27const OFF_GROSS_PRICE: usize = OFF_QUANTITY + U64_LEN;
28const OFF_VALID_UNTIL: usize = OFF_GROSS_PRICE + U64_LEN;
29const OFF_MAKER: usize = OFF_VALID_UNTIL + U64_LEN;
30const OFF_TAKER: usize = OFF_MAKER + PUBKEY_LEN;
31const OFF_NONCE: usize = OFF_TAKER + PUBKEY_LEN;
32const _: () = assert!(HEADER_LEN + OFF_NONCE + U64_LEN == ORDER_PREIMAGE_LEN);
33
34/// Layout: tag(4) + chain_id(8) + program_id(32) + is_taker_buy(1) +
35///         position_type(1) + market(32) + strike(8) + quantity(8) +
36///         gross_price(8) + valid_until(8) + maker(32) + taker(32) + nonce(8)
37pub const ORDER_PREIMAGE_LEN: usize = TAG_LEN
38    + CHAIN_ID_LEN
39    + PUBKEY_LEN
40    + BOOL_LEN
41    + BOOL_LEN
42    + PUBKEY_LEN
43    + U64_LEN
44    + U64_LEN
45    + U64_LEN
46    + U64_LEN
47    + PUBKEY_LEN
48    + PUBKEY_LEN
49    + U64_LEN;
50
51/// Synchronous order signer.
52pub trait SignerLike {
53    fn pubkey_bytes(&self) -> [u8; 32];
54    fn sign_message(&self, msg: &[u8]) -> [u8; 64];
55
56    fn pubkey_base58(&self) -> String {
57        encode_base58(&self.pubkey_bytes())
58    }
59
60    fn sign_message_base58(&self, msg: &[u8]) -> String {
61        encode_base58(&self.sign_message(msg))
62    }
63}
64
65/// In-memory Ed25519 signer. Secret material is zeroized on drop.
66#[derive(Clone)]
67pub struct BytesSigner {
68    signing_key: SigningKey,
69    pubkey: [u8; 32],
70}
71
72impl Zeroize for BytesSigner {
73    fn zeroize(&mut self) {
74        let _ = std::mem::replace(&mut self.signing_key, SigningKey::from_bytes(&[0u8; 32]));
75    }
76}
77
78impl ZeroizeOnDrop for BytesSigner {}
79
80impl BytesSigner {
81    pub fn from_secret(mut secret: [u8; 32]) -> Self {
82        let signing_key = SigningKey::from_bytes(&secret);
83        let pubkey = signing_key.verifying_key().to_bytes();
84        secret.zeroize();
85        Self {
86            signing_key,
87            pubkey,
88        }
89    }
90
91    pub fn from_keypair(keypair: &[u8; 64]) -> Result<Self, OrderError> {
92        let mut secret = [0u8; 32];
93        secret.copy_from_slice(&keypair[0..32]);
94        let signer = Self::from_secret(secret);
95        secret.zeroize();
96
97        if signer.pubkey != keypair[32..64] {
98            return Err(OrderError::KeypairPublicKeyMismatch);
99        }
100
101        Ok(signer)
102    }
103}
104
105impl SignerLike for BytesSigner {
106    fn pubkey_bytes(&self) -> [u8; 32] {
107        self.pubkey
108    }
109
110    fn sign_message(&self, msg: &[u8]) -> [u8; 64] {
111        let signature: Signature = self.signing_key.sign(msg);
112        signature.to_bytes()
113    }
114}
115
116#[derive(Debug, Clone)]
117pub struct OrderPreimageArgs {
118    pub chain_id: u64,
119    pub program_id: [u8; 32],
120    pub is_taker_buy: bool,
121    pub position_type: PositionType,
122    pub market: [u8; 32],
123    pub strike: u64,
124    pub quantity: u64,
125    pub gross_price: u64,
126    pub valid_until: u64,
127    pub maker: [u8; 32],
128    pub taker: [u8; 32],
129    pub nonce: u64,
130}
131
132#[derive(Debug, Error)]
133pub enum OrderError {
134    #[error("keypair public key does not match its secret key")]
135    KeypairPublicKeyMismatch,
136    #[error("invalid signing key: {0}")]
137    InvalidSigningKey(String),
138    #[error("invalid verifying key: {0}")]
139    InvalidVerifyingKey(String),
140    #[error("signature verification failed")]
141    InvalidSignature,
142    #[error(transparent)]
143    Wire(#[from] WireError),
144}
145
146pub fn build_order_preimage(args: &OrderPreimageArgs) -> [u8; ORDER_PREIMAGE_LEN] {
147    let mut buf = [0u8; ORDER_PREIMAGE_LEN];
148    buf[0..TAG_LEN].copy_from_slice(&ORDER_DOMAIN_TAG);
149    buf[TAG_LEN..TAG_LEN + CHAIN_ID_LEN].copy_from_slice(&args.chain_id.to_le_bytes());
150    buf[TAG_LEN + CHAIN_ID_LEN..HEADER_LEN].copy_from_slice(&args.program_id);
151
152    let b = HEADER_LEN;
153    buf[b + OFF_IS_TAKER_BUY] = u8::from(args.is_taker_buy);
154    buf[b + OFF_POSITION_TYPE] = args.position_type.into();
155    buf[b + OFF_MARKET..b + OFF_MARKET + PUBKEY_LEN].copy_from_slice(&args.market);
156    buf[b + OFF_STRIKE..b + OFF_STRIKE + U64_LEN].copy_from_slice(&args.strike.to_le_bytes());
157    buf[b + OFF_QUANTITY..b + OFF_QUANTITY + U64_LEN].copy_from_slice(&args.quantity.to_le_bytes());
158    buf[b + OFF_GROSS_PRICE..b + OFF_GROSS_PRICE + U64_LEN]
159        .copy_from_slice(&args.gross_price.to_le_bytes());
160    buf[b + OFF_VALID_UNTIL..b + OFF_VALID_UNTIL + U64_LEN]
161        .copy_from_slice(&args.valid_until.to_le_bytes());
162    buf[b + OFF_MAKER..b + OFF_MAKER + PUBKEY_LEN].copy_from_slice(&args.maker);
163    buf[b + OFF_TAKER..b + OFF_TAKER + PUBKEY_LEN].copy_from_slice(&args.taker);
164    buf[b + OFF_NONCE..b + OFF_NONCE + U64_LEN].copy_from_slice(&args.nonce.to_le_bytes());
165    buf
166}
167
168pub fn hash_order_preimage(preimage: &[u8; ORDER_PREIMAGE_LEN]) -> [u8; ORDER_ID_LEN] {
169    let digest = Sha256::digest(preimage);
170    digest.into()
171}
172
173pub fn compute_order_id(args: &OrderPreimageArgs) -> [u8; ORDER_ID_LEN] {
174    hash_order_preimage(&build_order_preimage(args))
175}
176
177pub fn order_id_hex(order_id: &[u8; ORDER_ID_LEN]) -> String {
178    encode_hex(order_id)
179}
180
181pub fn order_preimage_hex(preimage: &[u8; ORDER_PREIMAGE_LEN]) -> String {
182    encode_hex(preimage)
183}
184
185/// Sign an order id from raw secret bytes.
186///
187/// Expanding the secret derives the public key, which costs about as much as
188/// the signature itself. Quoting in a loop should hold a [`BytesSigner`] and
189/// call [`sign_order_id_with_signer`] instead, so the key is expanded once.
190pub fn sign_order_id_bytes(
191    order_id: &[u8; ORDER_ID_LEN],
192    signing_key_bytes: &[u8; 32],
193) -> Result<[u8; 64], OrderError> {
194    let signing_key = SigningKey::from_bytes(signing_key_bytes);
195    let signature: Signature = signing_key.sign(order_id);
196    Ok(signature.to_bytes())
197}
198
199/// Base58 form of [`sign_order_id_bytes`], and it re-expands the key the same way.
200pub fn sign_order_id_base58(
201    order_id: &[u8; ORDER_ID_LEN],
202    signing_key_bytes: &[u8; 32],
203) -> Result<String, OrderError> {
204    let sig = sign_order_id_bytes(order_id, signing_key_bytes)?;
205    Ok(encode_base58(&sig))
206}
207
208pub fn sign_order_id_with_signer<S: SignerLike>(
209    order_id: &[u8; ORDER_ID_LEN],
210    signer: &S,
211) -> [u8; 64] {
212    signer.sign_message(order_id)
213}
214
215pub fn sign_order_id_with_signer_base58<S: SignerLike>(
216    order_id: &[u8; ORDER_ID_LEN],
217    signer: &S,
218) -> String {
219    signer.sign_message_base58(order_id)
220}
221
222pub async fn sign_order_id_with_async_signer<S: AsyncSignerLike + ?Sized>(
223    order_id: &[u8; ORDER_ID_LEN],
224    signer: &S,
225) -> Result<[u8; 64], SigningError> {
226    sign_verified(signer, order_id).await
227}
228
229pub fn verify_order_id_signature_bytes(
230    order_id: &[u8; ORDER_ID_LEN],
231    signature: &[u8; 64],
232    verifying_key_bytes: &[u8; 32],
233) -> Result<(), OrderError> {
234    let verifying_key = VerifyingKey::from_bytes(verifying_key_bytes)
235        .map_err(|err| OrderError::InvalidVerifyingKey(err.to_string()))?;
236    let signature = Signature::from_bytes(signature);
237    verifying_key
238        .verify(order_id, &signature)
239        .map_err(|_| OrderError::InvalidSignature)
240}
241
242pub fn verify_order_id_signature_base58(
243    order_id_hex: &str,
244    signature_base58: &str,
245    pubkey_base58: &str,
246) -> Result<(), OrderError> {
247    let order_id = decode_hex32(order_id_hex)?;
248    let signature = decode_base58_64(signature_base58)?;
249    let pubkey = decode_base58_32(pubkey_base58)?;
250    verify_order_id_signature_bytes(&order_id, &signature, &pubkey)
251}
252
253pub fn sign_order_id_from_base58_keypair(
254    order_id_hex: &str,
255    keypair_base58: &str,
256) -> Result<String, OrderError> {
257    let order_id = decode_hex32(order_id_hex)?;
258    let keypair = decode_base58_64(keypair_base58)?;
259    let signer = BytesSigner::from_keypair(&keypair)?;
260    Ok(sign_order_id_with_signer_base58(&order_id, &signer))
261}
262
263fn decode_hex32(hex_str: &str) -> Result<[u8; 32], OrderError> {
264    crate::wire::decode_hex_32(hex_str).map_err(OrderError::Wire)
265}
acta_maker_sdk/orders/mod.rs

acta_maker_sdk/orders/
mod.rs
