df-papertrade-core 0.0.11-beta

Papertrade SDK for Rust on df-hyperliquid-core: intents, relayer, live account, session keys, signed writes, deposits and exact venue math. Wasm-ready.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93

//! A patch frame against a named revision: changed state fields, the closes and intent outcomes
//! it reports, and the positions and operations it removes and adds. Removing what is not held
//! or adding what already is means the stream is out of sync.

use df_hyperliquid_core::utils::Json;

use super::closed::read_outcome;
use super::{Account, AccountError, ClosedPosition, Lifetime, Operation, Position};
use crate::utils::wire::{array_of, field, hash_of, u64_of, u128_of};

impl Account {
    /// The account after `json`, a patch against this account's revision.
    pub(super) fn patch(&self, json: &Json) -> Result<Account, AccountError> {
        let base = u64_of(field(json, "baseAccountRevision")?, "account_revision")?;
        if base != self.account_revision {
            return Err(AccountError::OutOfSync("the patch is for another revision"));
        }
        let mut next = self.clone();
        next.account_revision = u64_of(field(json, "accountRevision")?, "account_revision")?;
        if next.account_revision <= self.account_revision {
            return Err(AccountError::OutOfSync("the patch does not move the revision on"));
        }
        if let Some(state) = json.get("state") {
            next.fields(state, true)?;
        }
        if let Some(lifetime) = json.get("lifetime") {
            next.lifetime = Lifetime::read(lifetime)?;
        }
        next.closed = match json.get("closedPositions") {
            Some(rows) => {
                array_of(rows, "closed_positions")?.iter().map(ClosedPosition::read).collect::<Result<_, _>>()?
            }
            None => Vec::new(),
        };
        next.outcomes = match json.get("intentOutcomes") {
            Some(rows) => array_of(rows, "intent_outcomes")?.iter().map(read_outcome).collect::<Result<_, _>>()?,
            None => Vec::new(),
        };
        next.patch_positions(json)?;
        next.patch_operations(json)?;
        next.check()?;
        Ok(next)
    }

    /// Removes and adds positions, keeping them newest first.
    fn patch_positions(&mut self, json: &Json) -> Result<(), AccountError> {
        let removed = array_of(field(json, "removedPositionIds")?, "wallet_patch")?
            .iter()
            .map(|id| u128_of(id, "removed_position_id"))
            .collect::<Result<Vec<_>, _>>()?;
        for (index, id) in removed.iter().enumerate() {
            if removed[..index].contains(id) || !self.positions.iter().any(|position| position.position_id == *id) {
                return Err(AccountError::OutOfSync("removes a position it does not hold"));
            }
        }
        self.positions.retain(|position| !removed.contains(&position.position_id));
        for row in array_of(field(json, "addedPositions")?, "wallet_patch")? {
            let position = Position::read(row)?;
            if removed.contains(&position.position_id)
                || self.positions.iter().any(|held| held.position_id == position.position_id)
            {
                return Err(AccountError::OutOfSync("adds a position it already holds"));
            }
            self.positions.push(position);
        }
        self.positions.sort_by(|a, b| b.position_id.cmp(&a.position_id));
        Ok(())
    }

    /// Removes and adds operations by intent id.
    fn patch_operations(&mut self, json: &Json) -> Result<(), AccountError> {
        let removed = array_of(field(json, "removedOperationIds")?, "wallet_patch")?
            .iter()
            .map(|id| hash_of(id, "operation_intent"))
            .collect::<Result<Vec<_>, _>>()?;
        for (index, id) in removed.iter().enumerate() {
            if removed[..index].contains(id) || !self.operations.iter().any(|operation| operation.intent_id == *id) {
                return Err(AccountError::OutOfSync("removes an operation it does not hold"));
            }
        }
        self.operations.retain(|operation| !removed.contains(&operation.intent_id));
        for row in array_of(field(json, "addedOperations")?, "wallet_patch")? {
            let operation = Operation::read(row)?;
            if removed.contains(&operation.intent_id)
                || self.operations.iter().any(|held| held.intent_id == operation.intent_id)
            {
                return Err(AccountError::OutOfSync("adds an operation it already holds"));
            }
            self.operations.push(operation);
        }
        Ok(())
    }
}