lukechilds
/
itchysats
mirror of https://github.com/lukechilds/itchysats.git
1
0
Fork 0
Code Issues Projects Releases Wiki Activity
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
618 Commits
67 Branches
8 Tags
4.4 MiB
Tree: 6f448f3c76
Branches Tags
${ item.name }
Create tag ${ searchTerm }
Create branch ${ searchTerm }
from '6f448f3c76'
${ noResults }
itchysats/daemon/sqlx-data.json

479 lines
18 KiB
Raw Normal View History

Initial daemon and frontend for taker and maker Co-authored-by: Mariusz Klochowicz <mariusz@klochowicz.com>
3 years ago
{
"db": "SQLite",
DB code rebasing for #88 The primary goal was to remove all of the calls to `serde_json::to_string()` for the data-handling, thus enabling us to do (more or less): ```rust Order { row.column, ... } ``` as well as clean up the SQL for easier reading. This has mostly been accomplished, with further refinements easily accomplished once the upstream issues in `sqlx` are addressed. See #314 for issues we are tracking.
3 years ago
"0862abd1900c5c5ae4a145635c19aef1a563ea470530d83325839868ffacd7bf": {
"query": "\n with ord as (\n select\n id as order_id,\n uuid,\n trading_pair,\n position,\n initial_price,\n min_quantity,\n max_quantity,\n leverage,\n liquidation_price,\n creation_timestamp_seconds as ts_secs,\n creation_timestamp_nanoseconds as ts_nanos,\n term_seconds as term_secs,\n term_nanoseconds as term_nanos,\n origin,\n oracle_event_id\n from orders\n ),\n\n cfd as (\n select\n id as cfd_id,\n order_id,\n quantity_usd\n from cfds\n ),\n\n tmp as (\n select\n id as state_id,\n cfd_id,\n state\n from cfd_states\n ),\n\n state as (\n select\n tmp.state,\n cfd.order_id,\n cfd.quantity_usd\n from tmp\n inner join cfd on tmp.cfd_id = cfd.cfd_id\n where tmp.state_id in (\n select max(state_id)\n from tmp\n group by state_id\n )\n )\n\n select\n ord.uuid as \"uuid: crate::model::cfd::OrderId\",\n ord.trading_pair as \"trading_pair: crate::model::TradingPair\",\n ord.position as \"position: crate::model::Position\",\n ord.initial_price,\n ord.min_quantity,\n ord.max_quantity,\n ord.leverage as \"leverage: crate::model::Leverage\",\n ord.liquidation_price,\n ord.ts_secs as \"ts_secs: i64\",\n ord.ts_nanos as \"ts_nanos: i32\",\n ord.term_secs as \"term_secs: i64\",\n ord.term_nanos as \"term_nanos: i32\",\n ord.origin as \"origin: crate::model::cfd::Origin\",\n ord.oracle_event_id,\n state.quantity_usd,\n state.state\n\n from ord\n inner join state on state.order_id = ord.order_id\n\n where ord.uuid = $1\n ",
Initial daemon and frontend for taker and maker Co-authored-by: Mariusz Klochowicz <mariusz@klochowicz.com>
3 years ago
"describe": {
"columns": [
{
DB code rebasing for #88 The primary goal was to remove all of the calls to `serde_json::to_string()` for the data-handling, thus enabling us to do (more or less): ```rust Order { row.column, ... } ``` as well as clean up the SQL for easier reading. This has mostly been accomplished, with further refinements easily accomplished once the upstream issues in `sqlx` are addressed. See #314 for issues we are tracking.
3 years ago
"name": "uuid: crate::model::cfd::OrderId",
Wire in automatic CET publication - Handles the Oracle's attestation in the cfd actor, transition according to the knowledge we have about the timelock expiry already. - Tries to publish the CET if we are in `CetStatus::Ready`, i.e. both the attestation and timelock expiry happened. We try publishing if either event happened, and just print a log in case it's not ready yet. - Tries to re-publish CET if we are in `PendingCet` upon restart. - Re-triggers CET monitoring upon startup. - Extends any state after `ContractSetup` to be able to store the attestation. (see below for ideas to change that) Things that could be done different: Currently we are carrying on the attestation through a lot of states - because we cannot just transition the user to `OpenCommitted` because it is a user decision to go for commit, but we have to keep the attestation around once it happened. To reduce the state complexity, we could store the attestation independent of the state, but associated with the cfd. This would make things a lot simpler, but we would then always have to go to the database to check if the attestation is already around (which might make other parts more complex).
3 years ago
"ordinal": 0,
Initial daemon and frontend for taker and maker Co-authored-by: Mariusz Klochowicz <mariusz@klochowicz.com>
3 years ago
"type_info": "Text"
},
{
DB code rebasing for #88 The primary goal was to remove all of the calls to `serde_json::to_string()` for the data-handling, thus enabling us to do (more or less): ```rust Order { row.column, ... } ``` as well as clean up the SQL for easier reading. This has mostly been accomplished, with further refinements easily accomplished once the upstream issues in `sqlx` are addressed. See #314 for issues we are tracking.
3 years ago
"name": "trading_pair: crate::model::TradingPair",
Wire in automatic CET publication - Handles the Oracle's attestation in the cfd actor, transition according to the knowledge we have about the timelock expiry already. - Tries to publish the CET if we are in `CetStatus::Ready`, i.e. both the attestation and timelock expiry happened. We try publishing if either event happened, and just print a log in case it's not ready yet. - Tries to re-publish CET if we are in `PendingCet` upon restart. - Re-triggers CET monitoring upon startup. - Extends any state after `ContractSetup` to be able to store the attestation. (see below for ideas to change that) Things that could be done different: Currently we are carrying on the attestation through a lot of states - because we cannot just transition the user to `OpenCommitted` because it is a user decision to go for commit, but we have to keep the attestation around once it happened. To reduce the state complexity, we could store the attestation independent of the state, but associated with the cfd. This would make things a lot simpler, but we would then always have to go to the database to check if the attestation is already around (which might make other parts more complex).
3 years ago
"ordinal": 1,
Initial daemon and frontend for taker and maker Co-authored-by: Mariusz Klochowicz <mariusz@klochowicz.com>
3 years ago
"type_info": "Text"
},
{
DB code rebasing for #88 The primary goal was to remove all of the calls to `serde_json::to_string()` for the data-handling, thus enabling us to do (more or less): ```rust Order { row.column, ... } ``` as well as clean up the SQL for easier reading. This has mostly been accomplished, with further refinements easily accomplished once the upstream issues in `sqlx` are addressed. See #314 for issues we are tracking.
3 years ago
"name": "position: crate::model::Position",
Wire in automatic CET publication - Handles the Oracle's attestation in the cfd actor, transition according to the knowledge we have about the timelock expiry already. - Tries to publish the CET if we are in `CetStatus::Ready`, i.e. both the attestation and timelock expiry happened. We try publishing if either event happened, and just print a log in case it's not ready yet. - Tries to re-publish CET if we are in `PendingCet` upon restart. - Re-triggers CET monitoring upon startup. - Extends any state after `ContractSetup` to be able to store the attestation. (see below for ideas to change that) Things that could be done different: Currently we are carrying on the attestation through a lot of states - because we cannot just transition the user to `OpenCommitted` because it is a user decision to go for commit, but we have to keep the attestation around once it happened. To reduce the state complexity, we could store the attestation independent of the state, but associated with the cfd. This would make things a lot simpler, but we would then always have to go to the database to check if the attestation is already around (which might make other parts more complex).
3 years ago
"ordinal": 2,
Refactor Cfd to be based on Order Flattening the Cfd out in the internal mode has caused duplication and confusion. This refactor puts the Order into the Cfd to make relations clearer. Note that once we have multiple leverage the leverage and liquidation price will have to move into the Cfd because they depend on the user's choice then. This should be trivial to do.
3 years ago
"type_info": "Text"
},
{
DB code rebasing for #88 The primary goal was to remove all of the calls to `serde_json::to_string()` for the data-handling, thus enabling us to do (more or less): ```rust Order { row.column, ... } ``` as well as clean up the SQL for easier reading. This has mostly been accomplished, with further refinements easily accomplished once the upstream issues in `sqlx` are addressed. See #314 for issues we are tracking.
3 years ago
"name": "initial_price",
Wire in automatic CET publication - Handles the Oracle's attestation in the cfd actor, transition according to the knowledge we have about the timelock expiry already. - Tries to publish the CET if we are in `CetStatus::Ready`, i.e. both the attestation and timelock expiry happened. We try publishing if either event happened, and just print a log in case it's not ready yet. - Tries to re-publish CET if we are in `PendingCet` upon restart. - Re-triggers CET monitoring upon startup. - Extends any state after `ContractSetup` to be able to store the attestation. (see below for ideas to change that) Things that could be done different: Currently we are carrying on the attestation through a lot of states - because we cannot just transition the user to `OpenCommitted` because it is a user decision to go for commit, but we have to keep the attestation around once it happened. To reduce the state complexity, we could store the attestation independent of the state, but associated with the cfd. This would make things a lot simpler, but we would then always have to go to the database to check if the attestation is already around (which might make other parts more complex).
3 years ago
"ordinal": 3,
Refactor Cfd to be based on Order Flattening the Cfd out in the internal mode has caused duplication and confusion. This refactor puts the Order into the Cfd to make relations clearer. Note that once we have multiple leverage the leverage and liquidation price will have to move into the Cfd because they depend on the user's choice then. This should be trivial to do.
3 years ago
"type_info": "Text"
},
{
DB code rebasing for #88 The primary goal was to remove all of the calls to `serde_json::to_string()` for the data-handling, thus enabling us to do (more or less): ```rust Order { row.column, ... } ``` as well as clean up the SQL for easier reading. This has mostly been accomplished, with further refinements easily accomplished once the upstream issues in `sqlx` are addressed. See #314 for issues we are tracking.
3 years ago
"name": "min_quantity",
Wire in automatic CET publication - Handles the Oracle's attestation in the cfd actor, transition according to the knowledge we have about the timelock expiry already. - Tries to publish the CET if we are in `CetStatus::Ready`, i.e. both the attestation and timelock expiry happened. We try publishing if either event happened, and just print a log in case it's not ready yet. - Tries to re-publish CET if we are in `PendingCet` upon restart. - Re-triggers CET monitoring upon startup. - Extends any state after `ContractSetup` to be able to store the attestation. (see below for ideas to change that) Things that could be done different: Currently we are carrying on the attestation through a lot of states - because we cannot just transition the user to `OpenCommitted` because it is a user decision to go for commit, but we have to keep the attestation around once it happened. To reduce the state complexity, we could store the attestation independent of the state, but associated with the cfd. This would make things a lot simpler, but we would then always have to go to the database to check if the attestation is already around (which might make other parts more complex).
3 years ago
"ordinal": 4,
DB code rebasing for #88 The primary goal was to remove all of the calls to `serde_json::to_string()` for the data-handling, thus enabling us to do (more or less): ```rust Order { row.column, ... } ``` as well as clean up the SQL for easier reading. This has mostly been accomplished, with further refinements easily accomplished once the upstream issues in `sqlx` are addressed. See #314 for issues we are tracking.
3 years ago
"type_info": "Text"
Initial daemon and frontend for taker and maker Co-authored-by: Mariusz Klochowicz <mariusz@klochowicz.com>
3 years ago
},
{
DB code rebasing for #88 The primary goal was to remove all of the calls to `serde_json::to_string()` for the data-handling, thus enabling us to do (more or less): ```rust Order { row.column, ... } ``` as well as clean up the SQL for easier reading. This has mostly been accomplished, with further refinements easily accomplished once the upstream issues in `sqlx` are addressed. See #314 for issues we are tracking.
3 years ago
"name": "max_quantity",
Wire in automatic CET publication - Handles the Oracle's attestation in the cfd actor, transition according to the knowledge we have about the timelock expiry already. - Tries to publish the CET if we are in `CetStatus::Ready`, i.e. both the attestation and timelock expiry happened. We try publishing if either event happened, and just print a log in case it's not ready yet. - Tries to re-publish CET if we are in `PendingCet` upon restart. - Re-triggers CET monitoring upon startup. - Extends any state after `ContractSetup` to be able to store the attestation. (see below for ideas to change that) Things that could be done different: Currently we are carrying on the attestation through a lot of states - because we cannot just transition the user to `OpenCommitted` because it is a user decision to go for commit, but we have to keep the attestation around once it happened. To reduce the state complexity, we could store the attestation independent of the state, but associated with the cfd. This would make things a lot simpler, but we would then always have to go to the database to check if the attestation is already around (which might make other parts more complex).
3 years ago
"ordinal": 5,
Initial daemon and frontend for taker and maker Co-authored-by: Mariusz Klochowicz <mariusz@klochowicz.com>
3 years ago
"type_info": "Text"
},
{
DB code rebasing for #88 The primary goal was to remove all of the calls to `serde_json::to_string()` for the data-handling, thus enabling us to do (more or less): ```rust Order { row.column, ... } ``` as well as clean up the SQL for easier reading. This has mostly been accomplished, with further refinements easily accomplished once the upstream issues in `sqlx` are addressed. See #314 for issues we are tracking.
3 years ago
"name": "leverage: crate::model::Leverage",
Wire in automatic CET publication - Handles the Oracle's attestation in the cfd actor, transition according to the knowledge we have about the timelock expiry already. - Tries to publish the CET if we are in `CetStatus::Ready`, i.e. both the attestation and timelock expiry happened. We try publishing if either event happened, and just print a log in case it's not ready yet. - Tries to re-publish CET if we are in `PendingCet` upon restart. - Re-triggers CET monitoring upon startup. - Extends any state after `ContractSetup` to be able to store the attestation. (see below for ideas to change that) Things that could be done different: Currently we are carrying on the attestation through a lot of states - because we cannot just transition the user to `OpenCommitted` because it is a user decision to go for commit, but we have to keep the attestation around once it happened. To reduce the state complexity, we could store the attestation independent of the state, but associated with the cfd. This would make things a lot simpler, but we would then always have to go to the database to check if the attestation is already around (which might make other parts more complex).
3 years ago
"ordinal": 6,
DB code rebasing for #88 The primary goal was to remove all of the calls to `serde_json::to_string()` for the data-handling, thus enabling us to do (more or less): ```rust Order { row.column, ... } ``` as well as clean up the SQL for easier reading. This has mostly been accomplished, with further refinements easily accomplished once the upstream issues in `sqlx` are addressed. See #314 for issues we are tracking.
3 years ago
"type_info": "Int64"
Initial daemon and frontend for taker and maker Co-authored-by: Mariusz Klochowicz <mariusz@klochowicz.com>
3 years ago
},
{
DB code rebasing for #88 The primary goal was to remove all of the calls to `serde_json::to_string()` for the data-handling, thus enabling us to do (more or less): ```rust Order { row.column, ... } ``` as well as clean up the SQL for easier reading. This has mostly been accomplished, with further refinements easily accomplished once the upstream issues in `sqlx` are addressed. See #314 for issues we are tracking.
3 years ago
"name": "liquidation_price",
Wire in automatic CET publication - Handles the Oracle's attestation in the cfd actor, transition according to the knowledge we have about the timelock expiry already. - Tries to publish the CET if we are in `CetStatus::Ready`, i.e. both the attestation and timelock expiry happened. We try publishing if either event happened, and just print a log in case it's not ready yet. - Tries to re-publish CET if we are in `PendingCet` upon restart. - Re-triggers CET monitoring upon startup. - Extends any state after `ContractSetup` to be able to store the attestation. (see below for ideas to change that) Things that could be done different: Currently we are carrying on the attestation through a lot of states - because we cannot just transition the user to `OpenCommitted` because it is a user decision to go for commit, but we have to keep the attestation around once it happened. To reduce the state complexity, we could store the attestation independent of the state, but associated with the cfd. This would make things a lot simpler, but we would then always have to go to the database to check if the attestation is already around (which might make other parts more complex).
3 years ago
"ordinal": 7,
Initial daemon and frontend for taker and maker Co-authored-by: Mariusz Klochowicz <mariusz@klochowicz.com>
3 years ago
"type_info": "Text"
},
{
DB code rebasing for #88 The primary goal was to remove all of the calls to `serde_json::to_string()` for the data-handling, thus enabling us to do (more or less): ```rust Order { row.column, ... } ``` as well as clean up the SQL for easier reading. This has mostly been accomplished, with further refinements easily accomplished once the upstream issues in `sqlx` are addressed. See #314 for issues we are tracking.
3 years ago
"name": "ts_secs: i64",
Wire in automatic CET publication - Handles the Oracle's attestation in the cfd actor, transition according to the knowledge we have about the timelock expiry already. - Tries to publish the CET if we are in `CetStatus::Ready`, i.e. both the attestation and timelock expiry happened. We try publishing if either event happened, and just print a log in case it's not ready yet. - Tries to re-publish CET if we are in `PendingCet` upon restart. - Re-triggers CET monitoring upon startup. - Extends any state after `ContractSetup` to be able to store the attestation. (see below for ideas to change that) Things that could be done different: Currently we are carrying on the attestation through a lot of states - because we cannot just transition the user to `OpenCommitted` because it is a user decision to go for commit, but we have to keep the attestation around once it happened. To reduce the state complexity, we could store the attestation independent of the state, but associated with the cfd. This would make things a lot simpler, but we would then always have to go to the database to check if the attestation is already around (which might make other parts more complex).
3 years ago
"ordinal": 8,
DB code rebasing for #88 The primary goal was to remove all of the calls to `serde_json::to_string()` for the data-handling, thus enabling us to do (more or less): ```rust Order { row.column, ... } ``` as well as clean up the SQL for easier reading. This has mostly been accomplished, with further refinements easily accomplished once the upstream issues in `sqlx` are addressed. See #314 for issues we are tracking.
3 years ago
"type_info": "Int64"
Refactor Cfd to be based on Order Flattening the Cfd out in the internal mode has caused duplication and confusion. This refactor puts the Order into the Cfd to make relations clearer. Note that once we have multiple leverage the leverage and liquidation price will have to move into the Cfd because they depend on the user's choice then. This should be trivial to do.
3 years ago
},
{
DB code rebasing for #88 The primary goal was to remove all of the calls to `serde_json::to_string()` for the data-handling, thus enabling us to do (more or less): ```rust Order { row.column, ... } ``` as well as clean up the SQL for easier reading. This has mostly been accomplished, with further refinements easily accomplished once the upstream issues in `sqlx` are addressed. See #314 for issues we are tracking.
3 years ago
"name": "ts_nanos: i32",
Wire in automatic CET publication - Handles the Oracle's attestation in the cfd actor, transition according to the knowledge we have about the timelock expiry already. - Tries to publish the CET if we are in `CetStatus::Ready`, i.e. both the attestation and timelock expiry happened. We try publishing if either event happened, and just print a log in case it's not ready yet. - Tries to re-publish CET if we are in `PendingCet` upon restart. - Re-triggers CET monitoring upon startup. - Extends any state after `ContractSetup` to be able to store the attestation. (see below for ideas to change that) Things that could be done different: Currently we are carrying on the attestation through a lot of states - because we cannot just transition the user to `OpenCommitted` because it is a user decision to go for commit, but we have to keep the attestation around once it happened. To reduce the state complexity, we could store the attestation independent of the state, but associated with the cfd. This would make things a lot simpler, but we would then always have to go to the database to check if the attestation is already around (which might make other parts more complex).
3 years ago
"ordinal": 9,
DB code rebasing for #88 The primary goal was to remove all of the calls to `serde_json::to_string()` for the data-handling, thus enabling us to do (more or less): ```rust Order { row.column, ... } ``` as well as clean up the SQL for easier reading. This has mostly been accomplished, with further refinements easily accomplished once the upstream issues in `sqlx` are addressed. See #314 for issues we are tracking.
3 years ago
"type_info": "Int64"
Refactor Cfd to be based on Order Flattening the Cfd out in the internal mode has caused duplication and confusion. This refactor puts the Order into the Cfd to make relations clearer. Note that once we have multiple leverage the leverage and liquidation price will have to move into the Cfd because they depend on the user's choice then. This should be trivial to do.
3 years ago
},
{
DB code rebasing for #88 The primary goal was to remove all of the calls to `serde_json::to_string()` for the data-handling, thus enabling us to do (more or less): ```rust Order { row.column, ... } ``` as well as clean up the SQL for easier reading. This has mostly been accomplished, with further refinements easily accomplished once the upstream issues in `sqlx` are addressed. See #314 for issues we are tracking.
3 years ago
"name": "term_secs: i64",
Wire in automatic CET publication - Handles the Oracle's attestation in the cfd actor, transition according to the knowledge we have about the timelock expiry already. - Tries to publish the CET if we are in `CetStatus::Ready`, i.e. both the attestation and timelock expiry happened. We try publishing if either event happened, and just print a log in case it's not ready yet. - Tries to re-publish CET if we are in `PendingCet` upon restart. - Re-triggers CET monitoring upon startup. - Extends any state after `ContractSetup` to be able to store the attestation. (see below for ideas to change that) Things that could be done different: Currently we are carrying on the attestation through a lot of states - because we cannot just transition the user to `OpenCommitted` because it is a user decision to go for commit, but we have to keep the attestation around once it happened. To reduce the state complexity, we could store the attestation independent of the state, but associated with the cfd. This would make things a lot simpler, but we would then always have to go to the database to check if the attestation is already around (which might make other parts more complex).
3 years ago
"ordinal": 10,
DB code rebasing for #88 The primary goal was to remove all of the calls to `serde_json::to_string()` for the data-handling, thus enabling us to do (more or less): ```rust Order { row.column, ... } ``` as well as clean up the SQL for easier reading. This has mostly been accomplished, with further refinements easily accomplished once the upstream issues in `sqlx` are addressed. See #314 for issues we are tracking.
3 years ago
"type_info": "Int64"
},
{
"name": "term_nanos: i32",
"ordinal": 11,
"type_info": "Int64"
},
{
"name": "origin: crate::model::cfd::Origin",
"ordinal": 12,
Initial daemon and frontend for taker and maker Co-authored-by: Mariusz Klochowicz <mariusz@klochowicz.com>
3 years ago
"type_info": "Text"
},
{
Maker publishes `OracleEventId` as part of offer The latest announcement known to the maker's cfd actor is used for extracting the event id.
3 years ago
"name": "oracle_event_id",
DB code rebasing for #88 The primary goal was to remove all of the calls to `serde_json::to_string()` for the data-handling, thus enabling us to do (more or less): ```rust Order { row.column, ... } ``` as well as clean up the SQL for easier reading. This has mostly been accomplished, with further refinements easily accomplished once the upstream issues in `sqlx` are addressed. See #314 for issues we are tracking.
3 years ago
"ordinal": 13,
Initial daemon and frontend for taker and maker Co-authored-by: Mariusz Klochowicz <mariusz@klochowicz.com>
3 years ago
"type_info": "Text"
Margin calculation The buy margin is calculated from `initial_price`, `quantity` and `leverage`. The sell margin is calculated from `initial_price` and `quantity` (no leverage trading for the seller at the moment). Includes several refactors: - Separate API interface for `Cfd` and `CfdOffer` when mapping `toSseEvent`. This allows internal modelling to be different than the exposed API. - Remove the profit calculation internally, it is only relevant on the UI feed API level. - Move code that is specific to taker/maker http API from `model` to the respective `routes` module. - Some simplification of the calculation model of `Usd` (could be further improved by deriving calculation traits) - Introduces `OfferOrigin` used to save the offer's origin as `mine` and `others` in the database. This is used to properly derive the CFD position from the offer.
3 years ago
},
{
Maker publishes `OracleEventId` as part of offer The latest announcement known to the maker's cfd actor is used for extracting the event id.
3 years ago
"name": "quantity_usd",
DB code rebasing for #88 The primary goal was to remove all of the calls to `serde_json::to_string()` for the data-handling, thus enabling us to do (more or less): ```rust Order { row.column, ... } ``` as well as clean up the SQL for easier reading. This has mostly been accomplished, with further refinements easily accomplished once the upstream issues in `sqlx` are addressed. See #314 for issues we are tracking.
3 years ago
"ordinal": 14,
Margin calculation The buy margin is calculated from `initial_price`, `quantity` and `leverage`. The sell margin is calculated from `initial_price` and `quantity` (no leverage trading for the seller at the moment). Includes several refactors: - Separate API interface for `Cfd` and `CfdOffer` when mapping `toSseEvent`. This allows internal modelling to be different than the exposed API. - Remove the profit calculation internally, it is only relevant on the UI feed API level. - Move code that is specific to taker/maker http API from `model` to the respective `routes` module. - Some simplification of the calculation model of `Usd` (could be further improved by deriving calculation traits) - Introduces `OfferOrigin` used to save the offer's origin as `mine` and `others` in the database. This is used to properly derive the CFD position from the offer.
3 years ago
"type_info": "Text"
Maker publishes `OracleEventId` as part of offer The latest announcement known to the maker's cfd actor is used for extracting the event id.
3 years ago
},
{
"name": "state",
DB code rebasing for #88 The primary goal was to remove all of the calls to `serde_json::to_string()` for the data-handling, thus enabling us to do (more or less): ```rust Order { row.column, ... } ``` as well as clean up the SQL for easier reading. This has mostly been accomplished, with further refinements easily accomplished once the upstream issues in `sqlx` are addressed. See #314 for issues we are tracking.
3 years ago
"ordinal": 15,
Maker publishes `OracleEventId` as part of offer The latest announcement known to the maker's cfd actor is used for extracting the event id.
3 years ago
"type_info": "Text"
Initial daemon and frontend for taker and maker Co-authored-by: Mariusz Klochowicz <mariusz@klochowicz.com>
3 years ago
}
],
"parameters": {
DB code rebasing for #88 The primary goal was to remove all of the calls to `serde_json::to_string()` for the data-handling, thus enabling us to do (more or less): ```rust Order { row.column, ... } ``` as well as clean up the SQL for easier reading. This has mostly been accomplished, with further refinements easily accomplished once the upstream issues in `sqlx` are addressed. See #314 for issues we are tracking.
3 years ago
"Right": 1
Initial daemon and frontend for taker and maker Co-authored-by: Mariusz Klochowicz <mariusz@klochowicz.com>
3 years ago
},
"nullable": [
false,
false,
false,
false,
false,
false,
false,
false,
Margin calculation The buy margin is calculated from `initial_price`, `quantity` and `leverage`. The sell margin is calculated from `initial_price` and `quantity` (no leverage trading for the seller at the moment). Includes several refactors: - Separate API interface for `Cfd` and `CfdOffer` when mapping `toSseEvent`. This allows internal modelling to be different than the exposed API. - Remove the profit calculation internally, it is only relevant on the UI feed API level. - Move code that is specific to taker/maker http API from `model` to the respective `routes` module. - Some simplification of the calculation model of `Usd` (could be further improved by deriving calculation traits) - Introduces `OfferOrigin` used to save the offer's origin as `mine` and `others` in the database. This is used to properly derive the CFD position from the offer.
3 years ago
false,
Refactor Cfd to be based on Order Flattening the Cfd out in the internal mode has caused duplication and confusion. This refactor puts the Order into the Cfd to make relations clearer. Note that once we have multiple leverage the leverage and liquidation price will have to move into the Cfd because they depend on the user's choice then. This should be trivial to do.
3 years ago
false,
false,
false,
false,
DB code rebasing for #88 The primary goal was to remove all of the calls to `serde_json::to_string()` for the data-handling, thus enabling us to do (more or less): ```rust Order { row.column, ... } ``` as well as clean up the SQL for easier reading. This has mostly been accomplished, with further refinements easily accomplished once the upstream issues in `sqlx` are addressed. See #314 for issues we are tracking.
3 years ago
false,
false,
Initial daemon and frontend for taker and maker Co-authored-by: Mariusz Klochowicz <mariusz@klochowicz.com>
3 years ago
false
]
}
},
DB code rebasing for #88 The primary goal was to remove all of the calls to `serde_json::to_string()` for the data-handling, thus enabling us to do (more or less): ```rust Order { row.column, ... } ``` as well as clean up the SQL for easier reading. This has mostly been accomplished, with further refinements easily accomplished once the upstream issues in `sqlx` are addressed. See #314 for issues we are tracking.
3 years ago
"221a6283db798bacaba99e7e85130f9a8bbea1299d8cb99d272b1d478dc19775": {
"query": "\n select\n state\n from cfd_states\n where cfd_id = $1\n order by id desc\n limit 1;\n ",
Maker publishes `OracleEventId` as part of offer The latest announcement known to the maker's cfd actor is used for extracting the event id.
3 years ago
"describe": {
"columns": [
{
DB code rebasing for #88 The primary goal was to remove all of the calls to `serde_json::to_string()` for the data-handling, thus enabling us to do (more or less): ```rust Order { row.column, ... } ``` as well as clean up the SQL for easier reading. This has mostly been accomplished, with further refinements easily accomplished once the upstream issues in `sqlx` are addressed. See #314 for issues we are tracking.
3 years ago
"name": "state",
Maker publishes `OracleEventId` as part of offer The latest announcement known to the maker's cfd actor is used for extracting the event id.
3 years ago
"ordinal": 0,
DB code rebasing for #88 The primary goal was to remove all of the calls to `serde_json::to_string()` for the data-handling, thus enabling us to do (more or less): ```rust Order { row.column, ... } ``` as well as clean up the SQL for easier reading. This has mostly been accomplished, with further refinements easily accomplished once the upstream issues in `sqlx` are addressed. See #314 for issues we are tracking.
3 years ago
"type_info": "Text"
Maker publishes `OracleEventId` as part of offer The latest announcement known to the maker's cfd actor is used for extracting the event id.
3 years ago
}
],
"parameters": {
"Right": 1
},
"nullable": [
DB code rebasing for #88 The primary goal was to remove all of the calls to `serde_json::to_string()` for the data-handling, thus enabling us to do (more or less): ```rust Order { row.column, ... } ``` as well as clean up the SQL for easier reading. This has mostly been accomplished, with further refinements easily accomplished once the upstream issues in `sqlx` are addressed. See #314 for issues we are tracking.
3 years ago
false
Maker publishes `OracleEventId` as part of offer The latest announcement known to the maker's cfd actor is used for extracting the event id.
3 years ago
]
}
},
DB code rebasing for #88 The primary goal was to remove all of the calls to `serde_json::to_string()` for the data-handling, thus enabling us to do (more or less): ```rust Order { row.column, ... } ``` as well as clean up the SQL for easier reading. This has mostly been accomplished, with further refinements easily accomplished once the upstream issues in `sqlx` are addressed. See #314 for issues we are tracking.
3 years ago
"62c4b31272cc2c889ebc946f4eaa3160ef2cf8c272412a77e9339249468d14bf": {
"query": "\n with ord as (\n select\n id as order_id,\n uuid,\n trading_pair,\n position,\n initial_price,\n min_quantity,\n max_quantity,\n leverage,\n liquidation_price,\n creation_timestamp_seconds as ts_secs,\n creation_timestamp_nanoseconds as ts_nanos,\n term_seconds as term_secs,\n term_nanoseconds as term_nanos,\n origin,\n oracle_event_id\n from orders\n ),\n\n cfd as (\n select\n id as cfd_id,\n order_id,\n quantity_usd as quantity_usd\n from cfds\n ),\n\n tmp as (\n select\n id as state_id,\n cfd_id,\n state\n from cfd_states\n ),\n\n state as (\n select\n tmp.state,\n cfd.order_id,\n cfd.quantity_usd\n from tmp\n inner join cfd on tmp.cfd_id = cfd.cfd_id\n where tmp.state_id in (\n select max(state_id)\n from tmp\n group by state_id\n )\n )\n\n select\n ord.uuid as \"uuid: crate::model::cfd::OrderId\",\n ord.trading_pair as \"trading_pair: crate::model::TradingPair\",\n ord.position as \"position: crate::model::Position\",\n ord.initial_price,\n ord.min_quantity,\n ord.max_quantity,\n ord.leverage as \"leverage: crate::model::Leverage\",\n ord.liquidation_price,\n ord.ts_secs as \"ts_secs: i64\",\n ord.ts_nanos as \"ts_nanos: i32\",\n ord.term_secs as \"term_secs: i64\",\n ord.term_nanos as \"term_nanos: i32\",\n ord.origin as \"origin: crate::model::cfd::Origin\",\n ord.oracle_event_id,\n state.quantity_usd,\n state.state\n\n from ord\n inner join state on state.order_id = ord.order_id\n\n where ord.oracle_event_id = $1\n ",
Use actual margin value for contract setup Includes validating that the amount the other party commits to is the expected amount based on calculating the counterparty margin out of the CFD values. Note: We could also remove the lock amount from the messages and use the calculation on both sides - that would simplify things.
3 years ago
"describe": {
"columns": [
{
DB code rebasing for #88 The primary goal was to remove all of the calls to `serde_json::to_string()` for the data-handling, thus enabling us to do (more or less): ```rust Order { row.column, ... } ``` as well as clean up the SQL for easier reading. This has mostly been accomplished, with further refinements easily accomplished once the upstream issues in `sqlx` are addressed. See #314 for issues we are tracking.
3 years ago
"name": "uuid: crate::model::cfd::OrderId",
Use actual margin value for contract setup Includes validating that the amount the other party commits to is the expected amount based on calculating the counterparty margin out of the CFD values. Note: We could also remove the lock amount from the messages and use the calculation on both sides - that would simplify things.
3 years ago
"ordinal": 0,
Wire in automatic CET publication - Handles the Oracle's attestation in the cfd actor, transition according to the knowledge we have about the timelock expiry already. - Tries to publish the CET if we are in `CetStatus::Ready`, i.e. both the attestation and timelock expiry happened. We try publishing if either event happened, and just print a log in case it's not ready yet. - Tries to re-publish CET if we are in `PendingCet` upon restart. - Re-triggers CET monitoring upon startup. - Extends any state after `ContractSetup` to be able to store the attestation. (see below for ideas to change that) Things that could be done different: Currently we are carrying on the attestation through a lot of states - because we cannot just transition the user to `OpenCommitted` because it is a user decision to go for commit, but we have to keep the attestation around once it happened. To reduce the state complexity, we could store the attestation independent of the state, but associated with the cfd. This would make things a lot simpler, but we would then always have to go to the database to check if the attestation is already around (which might make other parts more complex).
3 years ago
"type_info": "Text"
},
{
DB code rebasing for #88 The primary goal was to remove all of the calls to `serde_json::to_string()` for the data-handling, thus enabling us to do (more or less): ```rust Order { row.column, ... } ``` as well as clean up the SQL for easier reading. This has mostly been accomplished, with further refinements easily accomplished once the upstream issues in `sqlx` are addressed. See #314 for issues we are tracking.
3 years ago
"name": "trading_pair: crate::model::TradingPair",
Wire in automatic CET publication - Handles the Oracle's attestation in the cfd actor, transition according to the knowledge we have about the timelock expiry already. - Tries to publish the CET if we are in `CetStatus::Ready`, i.e. both the attestation and timelock expiry happened. We try publishing if either event happened, and just print a log in case it's not ready yet. - Tries to re-publish CET if we are in `PendingCet` upon restart. - Re-triggers CET monitoring upon startup. - Extends any state after `ContractSetup` to be able to store the attestation. (see below for ideas to change that) Things that could be done different: Currently we are carrying on the attestation through a lot of states - because we cannot just transition the user to `OpenCommitted` because it is a user decision to go for commit, but we have to keep the attestation around once it happened. To reduce the state complexity, we could store the attestation independent of the state, but associated with the cfd. This would make things a lot simpler, but we would then always have to go to the database to check if the attestation is already around (which might make other parts more complex).
3 years ago
"ordinal": 1,
"type_info": "Text"
},
{
DB code rebasing for #88 The primary goal was to remove all of the calls to `serde_json::to_string()` for the data-handling, thus enabling us to do (more or less): ```rust Order { row.column, ... } ``` as well as clean up the SQL for easier reading. This has mostly been accomplished, with further refinements easily accomplished once the upstream issues in `sqlx` are addressed. See #314 for issues we are tracking.
3 years ago
"name": "position: crate::model::Position",
Wire in automatic CET publication - Handles the Oracle's attestation in the cfd actor, transition according to the knowledge we have about the timelock expiry already. - Tries to publish the CET if we are in `CetStatus::Ready`, i.e. both the attestation and timelock expiry happened. We try publishing if either event happened, and just print a log in case it's not ready yet. - Tries to re-publish CET if we are in `PendingCet` upon restart. - Re-triggers CET monitoring upon startup. - Extends any state after `ContractSetup` to be able to store the attestation. (see below for ideas to change that) Things that could be done different: Currently we are carrying on the attestation through a lot of states - because we cannot just transition the user to `OpenCommitted` because it is a user decision to go for commit, but we have to keep the attestation around once it happened. To reduce the state complexity, we could store the attestation independent of the state, but associated with the cfd. This would make things a lot simpler, but we would then always have to go to the database to check if the attestation is already around (which might make other parts more complex).
3 years ago
"ordinal": 2,
"type_info": "Text"
},
{
DB code rebasing for #88 The primary goal was to remove all of the calls to `serde_json::to_string()` for the data-handling, thus enabling us to do (more or less): ```rust Order { row.column, ... } ``` as well as clean up the SQL for easier reading. This has mostly been accomplished, with further refinements easily accomplished once the upstream issues in `sqlx` are addressed. See #314 for issues we are tracking.
3 years ago
"name": "initial_price",
Wire in automatic CET publication - Handles the Oracle's attestation in the cfd actor, transition according to the knowledge we have about the timelock expiry already. - Tries to publish the CET if we are in `CetStatus::Ready`, i.e. both the attestation and timelock expiry happened. We try publishing if either event happened, and just print a log in case it's not ready yet. - Tries to re-publish CET if we are in `PendingCet` upon restart. - Re-triggers CET monitoring upon startup. - Extends any state after `ContractSetup` to be able to store the attestation. (see below for ideas to change that) Things that could be done different: Currently we are carrying on the attestation through a lot of states - because we cannot just transition the user to `OpenCommitted` because it is a user decision to go for commit, but we have to keep the attestation around once it happened. To reduce the state complexity, we could store the attestation independent of the state, but associated with the cfd. This would make things a lot simpler, but we would then always have to go to the database to check if the attestation is already around (which might make other parts more complex).
3 years ago
"ordinal": 3,
"type_info": "Text"
},
{
DB code rebasing for #88 The primary goal was to remove all of the calls to `serde_json::to_string()` for the data-handling, thus enabling us to do (more or less): ```rust Order { row.column, ... } ``` as well as clean up the SQL for easier reading. This has mostly been accomplished, with further refinements easily accomplished once the upstream issues in `sqlx` are addressed. See #314 for issues we are tracking.
3 years ago
"name": "min_quantity",
Wire in automatic CET publication - Handles the Oracle's attestation in the cfd actor, transition according to the knowledge we have about the timelock expiry already. - Tries to publish the CET if we are in `CetStatus::Ready`, i.e. both the attestation and timelock expiry happened. We try publishing if either event happened, and just print a log in case it's not ready yet. - Tries to re-publish CET if we are in `PendingCet` upon restart. - Re-triggers CET monitoring upon startup. - Extends any state after `ContractSetup` to be able to store the attestation. (see below for ideas to change that) Things that could be done different: Currently we are carrying on the attestation through a lot of states - because we cannot just transition the user to `OpenCommitted` because it is a user decision to go for commit, but we have to keep the attestation around once it happened. To reduce the state complexity, we could store the attestation independent of the state, but associated with the cfd. This would make things a lot simpler, but we would then always have to go to the database to check if the attestation is already around (which might make other parts more complex).
3 years ago
"ordinal": 4,
DB code rebasing for #88 The primary goal was to remove all of the calls to `serde_json::to_string()` for the data-handling, thus enabling us to do (more or less): ```rust Order { row.column, ... } ``` as well as clean up the SQL for easier reading. This has mostly been accomplished, with further refinements easily accomplished once the upstream issues in `sqlx` are addressed. See #314 for issues we are tracking.
3 years ago
"type_info": "Text"
Use actual margin value for contract setup Includes validating that the amount the other party commits to is the expected amount based on calculating the counterparty margin out of the CFD values. Note: We could also remove the lock amount from the messages and use the calculation on both sides - that would simplify things.
3 years ago
},
Wire in automatic CET publication - Handles the Oracle's attestation in the cfd actor, transition according to the knowledge we have about the timelock expiry already. - Tries to publish the CET if we are in `CetStatus::Ready`, i.e. both the attestation and timelock expiry happened. We try publishing if either event happened, and just print a log in case it's not ready yet. - Tries to re-publish CET if we are in `PendingCet` upon restart. - Re-triggers CET monitoring upon startup. - Extends any state after `ContractSetup` to be able to store the attestation. (see below for ideas to change that) Things that could be done different: Currently we are carrying on the attestation through a lot of states - because we cannot just transition the user to `OpenCommitted` because it is a user decision to go for commit, but we have to keep the attestation around once it happened. To reduce the state complexity, we could store the attestation independent of the state, but associated with the cfd. This would make things a lot simpler, but we would then always have to go to the database to check if the attestation is already around (which might make other parts more complex).
3 years ago
{
DB code rebasing for #88 The primary goal was to remove all of the calls to `serde_json::to_string()` for the data-handling, thus enabling us to do (more or less): ```rust Order { row.column, ... } ``` as well as clean up the SQL for easier reading. This has mostly been accomplished, with further refinements easily accomplished once the upstream issues in `sqlx` are addressed. See #314 for issues we are tracking.
3 years ago
"name": "max_quantity",
Wire in automatic CET publication - Handles the Oracle's attestation in the cfd actor, transition according to the knowledge we have about the timelock expiry already. - Tries to publish the CET if we are in `CetStatus::Ready`, i.e. both the attestation and timelock expiry happened. We try publishing if either event happened, and just print a log in case it's not ready yet. - Tries to re-publish CET if we are in `PendingCet` upon restart. - Re-triggers CET monitoring upon startup. - Extends any state after `ContractSetup` to be able to store the attestation. (see below for ideas to change that) Things that could be done different: Currently we are carrying on the attestation through a lot of states - because we cannot just transition the user to `OpenCommitted` because it is a user decision to go for commit, but we have to keep the attestation around once it happened. To reduce the state complexity, we could store the attestation independent of the state, but associated with the cfd. This would make things a lot simpler, but we would then always have to go to the database to check if the attestation is already around (which might make other parts more complex).
3 years ago
"ordinal": 5,
"type_info": "Text"
},
{
DB code rebasing for #88 The primary goal was to remove all of the calls to `serde_json::to_string()` for the data-handling, thus enabling us to do (more or less): ```rust Order { row.column, ... } ``` as well as clean up the SQL for easier reading. This has mostly been accomplished, with further refinements easily accomplished once the upstream issues in `sqlx` are addressed. See #314 for issues we are tracking.
3 years ago
"name": "leverage: crate::model::Leverage",
Wire in automatic CET publication - Handles the Oracle's attestation in the cfd actor, transition according to the knowledge we have about the timelock expiry already. - Tries to publish the CET if we are in `CetStatus::Ready`, i.e. both the attestation and timelock expiry happened. We try publishing if either event happened, and just print a log in case it's not ready yet. - Tries to re-publish CET if we are in `PendingCet` upon restart. - Re-triggers CET monitoring upon startup. - Extends any state after `ContractSetup` to be able to store the attestation. (see below for ideas to change that) Things that could be done different: Currently we are carrying on the attestation through a lot of states - because we cannot just transition the user to `OpenCommitted` because it is a user decision to go for commit, but we have to keep the attestation around once it happened. To reduce the state complexity, we could store the attestation independent of the state, but associated with the cfd. This would make things a lot simpler, but we would then always have to go to the database to check if the attestation is already around (which might make other parts more complex).
3 years ago
"ordinal": 6,
DB code rebasing for #88 The primary goal was to remove all of the calls to `serde_json::to_string()` for the data-handling, thus enabling us to do (more or less): ```rust Order { row.column, ... } ``` as well as clean up the SQL for easier reading. This has mostly been accomplished, with further refinements easily accomplished once the upstream issues in `sqlx` are addressed. See #314 for issues we are tracking.
3 years ago
"type_info": "Int64"
Wire in automatic CET publication - Handles the Oracle's attestation in the cfd actor, transition according to the knowledge we have about the timelock expiry already. - Tries to publish the CET if we are in `CetStatus::Ready`, i.e. both the attestation and timelock expiry happened. We try publishing if either event happened, and just print a log in case it's not ready yet. - Tries to re-publish CET if we are in `PendingCet` upon restart. - Re-triggers CET monitoring upon startup. - Extends any state after `ContractSetup` to be able to store the attestation. (see below for ideas to change that) Things that could be done different: Currently we are carrying on the attestation through a lot of states - because we cannot just transition the user to `OpenCommitted` because it is a user decision to go for commit, but we have to keep the attestation around once it happened. To reduce the state complexity, we could store the attestation independent of the state, but associated with the cfd. This would make things a lot simpler, but we would then always have to go to the database to check if the attestation is already around (which might make other parts more complex).
3 years ago
},
{
DB code rebasing for #88 The primary goal was to remove all of the calls to `serde_json::to_string()` for the data-handling, thus enabling us to do (more or less): ```rust Order { row.column, ... } ``` as well as clean up the SQL for easier reading. This has mostly been accomplished, with further refinements easily accomplished once the upstream issues in `sqlx` are addressed. See #314 for issues we are tracking.
3 years ago
"name": "liquidation_price",
Wire in automatic CET publication - Handles the Oracle's attestation in the cfd actor, transition according to the knowledge we have about the timelock expiry already. - Tries to publish the CET if we are in `CetStatus::Ready`, i.e. both the attestation and timelock expiry happened. We try publishing if either event happened, and just print a log in case it's not ready yet. - Tries to re-publish CET if we are in `PendingCet` upon restart. - Re-triggers CET monitoring upon startup. - Extends any state after `ContractSetup` to be able to store the attestation. (see below for ideas to change that) Things that could be done different: Currently we are carrying on the attestation through a lot of states - because we cannot just transition the user to `OpenCommitted` because it is a user decision to go for commit, but we have to keep the attestation around once it happened. To reduce the state complexity, we could store the attestation independent of the state, but associated with the cfd. This would make things a lot simpler, but we would then always have to go to the database to check if the attestation is already around (which might make other parts more complex).
3 years ago
"ordinal": 7,
"type_info": "Text"
},
{
DB code rebasing for #88 The primary goal was to remove all of the calls to `serde_json::to_string()` for the data-handling, thus enabling us to do (more or less): ```rust Order { row.column, ... } ``` as well as clean up the SQL for easier reading. This has mostly been accomplished, with further refinements easily accomplished once the upstream issues in `sqlx` are addressed. See #314 for issues we are tracking.
3 years ago
"name": "ts_secs: i64",
Wire in automatic CET publication - Handles the Oracle's attestation in the cfd actor, transition according to the knowledge we have about the timelock expiry already. - Tries to publish the CET if we are in `CetStatus::Ready`, i.e. both the attestation and timelock expiry happened. We try publishing if either event happened, and just print a log in case it's not ready yet. - Tries to re-publish CET if we are in `PendingCet` upon restart. - Re-triggers CET monitoring upon startup. - Extends any state after `ContractSetup` to be able to store the attestation. (see below for ideas to change that) Things that could be done different: Currently we are carrying on the attestation through a lot of states - because we cannot just transition the user to `OpenCommitted` because it is a user decision to go for commit, but we have to keep the attestation around once it happened. To reduce the state complexity, we could store the attestation independent of the state, but associated with the cfd. This would make things a lot simpler, but we would then always have to go to the database to check if the attestation is already around (which might make other parts more complex).
3 years ago
"ordinal": 8,
DB code rebasing for #88 The primary goal was to remove all of the calls to `serde_json::to_string()` for the data-handling, thus enabling us to do (more or less): ```rust Order { row.column, ... } ``` as well as clean up the SQL for easier reading. This has mostly been accomplished, with further refinements easily accomplished once the upstream issues in `sqlx` are addressed. See #314 for issues we are tracking.
3 years ago
"type_info": "Int64"
Wire in automatic CET publication - Handles the Oracle's attestation in the cfd actor, transition according to the knowledge we have about the timelock expiry already. - Tries to publish the CET if we are in `CetStatus::Ready`, i.e. both the attestation and timelock expiry happened. We try publishing if either event happened, and just print a log in case it's not ready yet. - Tries to re-publish CET if we are in `PendingCet` upon restart. - Re-triggers CET monitoring upon startup. - Extends any state after `ContractSetup` to be able to store the attestation. (see below for ideas to change that) Things that could be done different: Currently we are carrying on the attestation through a lot of states - because we cannot just transition the user to `OpenCommitted` because it is a user decision to go for commit, but we have to keep the attestation around once it happened. To reduce the state complexity, we could store the attestation independent of the state, but associated with the cfd. This would make things a lot simpler, but we would then always have to go to the database to check if the attestation is already around (which might make other parts more complex).
3 years ago
},
{
DB code rebasing for #88 The primary goal was to remove all of the calls to `serde_json::to_string()` for the data-handling, thus enabling us to do (more or less): ```rust Order { row.column, ... } ``` as well as clean up the SQL for easier reading. This has mostly been accomplished, with further refinements easily accomplished once the upstream issues in `sqlx` are addressed. See #314 for issues we are tracking.
3 years ago
"name": "ts_nanos: i32",
Wire in automatic CET publication - Handles the Oracle's attestation in the cfd actor, transition according to the knowledge we have about the timelock expiry already. - Tries to publish the CET if we are in `CetStatus::Ready`, i.e. both the attestation and timelock expiry happened. We try publishing if either event happened, and just print a log in case it's not ready yet. - Tries to re-publish CET if we are in `PendingCet` upon restart. - Re-triggers CET monitoring upon startup. - Extends any state after `ContractSetup` to be able to store the attestation. (see below for ideas to change that) Things that could be done different: Currently we are carrying on the attestation through a lot of states - because we cannot just transition the user to `OpenCommitted` because it is a user decision to go for commit, but we have to keep the attestation around once it happened. To reduce the state complexity, we could store the attestation independent of the state, but associated with the cfd. This would make things a lot simpler, but we would then always have to go to the database to check if the attestation is already around (which might make other parts more complex).
3 years ago
"ordinal": 9,
DB code rebasing for #88 The primary goal was to remove all of the calls to `serde_json::to_string()` for the data-handling, thus enabling us to do (more or less): ```rust Order { row.column, ... } ``` as well as clean up the SQL for easier reading. This has mostly been accomplished, with further refinements easily accomplished once the upstream issues in `sqlx` are addressed. See #314 for issues we are tracking.
3 years ago
"type_info": "Int64"
Wire in automatic CET publication - Handles the Oracle's attestation in the cfd actor, transition according to the knowledge we have about the timelock expiry already. - Tries to publish the CET if we are in `CetStatus::Ready`, i.e. both the attestation and timelock expiry happened. We try publishing if either event happened, and just print a log in case it's not ready yet. - Tries to re-publish CET if we are in `PendingCet` upon restart. - Re-triggers CET monitoring upon startup. - Extends any state after `ContractSetup` to be able to store the attestation. (see below for ideas to change that) Things that could be done different: Currently we are carrying on the attestation through a lot of states - because we cannot just transition the user to `OpenCommitted` because it is a user decision to go for commit, but we have to keep the attestation around once it happened. To reduce the state complexity, we could store the attestation independent of the state, but associated with the cfd. This would make things a lot simpler, but we would then always have to go to the database to check if the attestation is already around (which might make other parts more complex).
3 years ago
},
{
DB code rebasing for #88 The primary goal was to remove all of the calls to `serde_json::to_string()` for the data-handling, thus enabling us to do (more or less): ```rust Order { row.column, ... } ``` as well as clean up the SQL for easier reading. This has mostly been accomplished, with further refinements easily accomplished once the upstream issues in `sqlx` are addressed. See #314 for issues we are tracking.
3 years ago
"name": "term_secs: i64",
Wire in automatic CET publication - Handles the Oracle's attestation in the cfd actor, transition according to the knowledge we have about the timelock expiry already. - Tries to publish the CET if we are in `CetStatus::Ready`, i.e. both the attestation and timelock expiry happened. We try publishing if either event happened, and just print a log in case it's not ready yet. - Tries to re-publish CET if we are in `PendingCet` upon restart. - Re-triggers CET monitoring upon startup. - Extends any state after `ContractSetup` to be able to store the attestation. (see below for ideas to change that) Things that could be done different: Currently we are carrying on the attestation through a lot of states - because we cannot just transition the user to `OpenCommitted` because it is a user decision to go for commit, but we have to keep the attestation around once it happened. To reduce the state complexity, we could store the attestation independent of the state, but associated with the cfd. This would make things a lot simpler, but we would then always have to go to the database to check if the attestation is already around (which might make other parts more complex).
3 years ago
"ordinal": 10,
DB code rebasing for #88 The primary goal was to remove all of the calls to `serde_json::to_string()` for the data-handling, thus enabling us to do (more or less): ```rust Order { row.column, ... } ``` as well as clean up the SQL for easier reading. This has mostly been accomplished, with further refinements easily accomplished once the upstream issues in `sqlx` are addressed. See #314 for issues we are tracking.
3 years ago
"type_info": "Int64"
},
{
"name": "term_nanos: i32",
"ordinal": 11,
"type_info": "Int64"
},
{
"name": "origin: crate::model::cfd::Origin",
"ordinal": 12,
Wire in automatic CET publication - Handles the Oracle's attestation in the cfd actor, transition according to the knowledge we have about the timelock expiry already. - Tries to publish the CET if we are in `CetStatus::Ready`, i.e. both the attestation and timelock expiry happened. We try publishing if either event happened, and just print a log in case it's not ready yet. - Tries to re-publish CET if we are in `PendingCet` upon restart. - Re-triggers CET monitoring upon startup. - Extends any state after `ContractSetup` to be able to store the attestation. (see below for ideas to change that) Things that could be done different: Currently we are carrying on the attestation through a lot of states - because we cannot just transition the user to `OpenCommitted` because it is a user decision to go for commit, but we have to keep the attestation around once it happened. To reduce the state complexity, we could store the attestation independent of the state, but associated with the cfd. This would make things a lot simpler, but we would then always have to go to the database to check if the attestation is already around (which might make other parts more complex).
3 years ago
"type_info": "Text"
},
{
"name": "oracle_event_id",
DB code rebasing for #88 The primary goal was to remove all of the calls to `serde_json::to_string()` for the data-handling, thus enabling us to do (more or less): ```rust Order { row.column, ... } ``` as well as clean up the SQL for easier reading. This has mostly been accomplished, with further refinements easily accomplished once the upstream issues in `sqlx` are addressed. See #314 for issues we are tracking.
3 years ago
"ordinal": 13,
Wire in automatic CET publication - Handles the Oracle's attestation in the cfd actor, transition according to the knowledge we have about the timelock expiry already. - Tries to publish the CET if we are in `CetStatus::Ready`, i.e. both the attestation and timelock expiry happened. We try publishing if either event happened, and just print a log in case it's not ready yet. - Tries to re-publish CET if we are in `PendingCet` upon restart. - Re-triggers CET monitoring upon startup. - Extends any state after `ContractSetup` to be able to store the attestation. (see below for ideas to change that) Things that could be done different: Currently we are carrying on the attestation through a lot of states - because we cannot just transition the user to `OpenCommitted` because it is a user decision to go for commit, but we have to keep the attestation around once it happened. To reduce the state complexity, we could store the attestation independent of the state, but associated with the cfd. This would make things a lot simpler, but we would then always have to go to the database to check if the attestation is already around (which might make other parts more complex).
3 years ago
"type_info": "Text"
},
{
"name": "quantity_usd",
DB code rebasing for #88 The primary goal was to remove all of the calls to `serde_json::to_string()` for the data-handling, thus enabling us to do (more or less): ```rust Order { row.column, ... } ``` as well as clean up the SQL for easier reading. This has mostly been accomplished, with further refinements easily accomplished once the upstream issues in `sqlx` are addressed. See #314 for issues we are tracking.
3 years ago
"ordinal": 14,
Wire in automatic CET publication - Handles the Oracle's attestation in the cfd actor, transition according to the knowledge we have about the timelock expiry already. - Tries to publish the CET if we are in `CetStatus::Ready`, i.e. both the attestation and timelock expiry happened. We try publishing if either event happened, and just print a log in case it's not ready yet. - Tries to re-publish CET if we are in `PendingCet` upon restart. - Re-triggers CET monitoring upon startup. - Extends any state after `ContractSetup` to be able to store the attestation. (see below for ideas to change that) Things that could be done different: Currently we are carrying on the attestation through a lot of states - because we cannot just transition the user to `OpenCommitted` because it is a user decision to go for commit, but we have to keep the attestation around once it happened. To reduce the state complexity, we could store the attestation independent of the state, but associated with the cfd. This would make things a lot simpler, but we would then always have to go to the database to check if the attestation is already around (which might make other parts more complex).
3 years ago
"type_info": "Text"
},
{
"name": "state",
DB code rebasing for #88 The primary goal was to remove all of the calls to `serde_json::to_string()` for the data-handling, thus enabling us to do (more or less): ```rust Order { row.column, ... } ``` as well as clean up the SQL for easier reading. This has mostly been accomplished, with further refinements easily accomplished once the upstream issues in `sqlx` are addressed. See #314 for issues we are tracking.
3 years ago
"ordinal": 15,
Wire in automatic CET publication - Handles the Oracle's attestation in the cfd actor, transition according to the knowledge we have about the timelock expiry already. - Tries to publish the CET if we are in `CetStatus::Ready`, i.e. both the attestation and timelock expiry happened. We try publishing if either event happened, and just print a log in case it's not ready yet. - Tries to re-publish CET if we are in `PendingCet` upon restart. - Re-triggers CET monitoring upon startup. - Extends any state after `ContractSetup` to be able to store the attestation. (see below for ideas to change that) Things that could be done different: Currently we are carrying on the attestation through a lot of states - because we cannot just transition the user to `OpenCommitted` because it is a user decision to go for commit, but we have to keep the attestation around once it happened. To reduce the state complexity, we could store the attestation independent of the state, but associated with the cfd. This would make things a lot simpler, but we would then always have to go to the database to check if the attestation is already around (which might make other parts more complex).
3 years ago
"type_info": "Text"
}
],
"parameters": {
"Right": 1
},
"nullable": [
false,
false,
false,
false,
false,
false,
false,
false,
false,
false,
false,
false,
false,
DB code rebasing for #88 The primary goal was to remove all of the calls to `serde_json::to_string()` for the data-handling, thus enabling us to do (more or less): ```rust Order { row.column, ... } ``` as well as clean up the SQL for easier reading. This has mostly been accomplished, with further refinements easily accomplished once the upstream issues in `sqlx` are addressed. See #314 for issues we are tracking.
3 years ago
false,
false,
Wire in automatic CET publication - Handles the Oracle's attestation in the cfd actor, transition according to the knowledge we have about the timelock expiry already. - Tries to publish the CET if we are in `CetStatus::Ready`, i.e. both the attestation and timelock expiry happened. We try publishing if either event happened, and just print a log in case it's not ready yet. - Tries to re-publish CET if we are in `PendingCet` upon restart. - Re-triggers CET monitoring upon startup. - Extends any state after `ContractSetup` to be able to store the attestation. (see below for ideas to change that) Things that could be done different: Currently we are carrying on the attestation through a lot of states - because we cannot just transition the user to `OpenCommitted` because it is a user decision to go for commit, but we have to keep the attestation around once it happened. To reduce the state complexity, we could store the attestation independent of the state, but associated with the cfd. This would make things a lot simpler, but we would then always have to go to the database to check if the attestation is already around (which might make other parts more complex).
3 years ago
false
]
}
},
DB code rebasing for #88 The primary goal was to remove all of the calls to `serde_json::to_string()` for the data-handling, thus enabling us to do (more or less): ```rust Order { row.column, ... } ``` as well as clean up the SQL for easier reading. This has mostly been accomplished, with further refinements easily accomplished once the upstream issues in `sqlx` are addressed. See #314 for issues we are tracking.
3 years ago
"8cbe349911b35d8e79763d64b4f5813b4bd98f12e0bba5ada84d2cae8b08ef4f": {
"query": "\n select\n id\n from cfds\n where order_uuid = $1;\n ",
Wire in automatic CET publication - Handles the Oracle's attestation in the cfd actor, transition according to the knowledge we have about the timelock expiry already. - Tries to publish the CET if we are in `CetStatus::Ready`, i.e. both the attestation and timelock expiry happened. We try publishing if either event happened, and just print a log in case it's not ready yet. - Tries to re-publish CET if we are in `PendingCet` upon restart. - Re-triggers CET monitoring upon startup. - Extends any state after `ContractSetup` to be able to store the attestation. (see below for ideas to change that) Things that could be done different: Currently we are carrying on the attestation through a lot of states - because we cannot just transition the user to `OpenCommitted` because it is a user decision to go for commit, but we have to keep the attestation around once it happened. To reduce the state complexity, we could store the attestation independent of the state, but associated with the cfd. This would make things a lot simpler, but we would then always have to go to the database to check if the attestation is already around (which might make other parts more complex).
3 years ago
"describe": {
"columns": [
Use actual margin value for contract setup Includes validating that the amount the other party commits to is the expected amount based on calculating the counterparty margin out of the CFD values. Note: We could also remove the lock amount from the messages and use the calculation on both sides - that would simplify things.
3 years ago
{
DB code rebasing for #88 The primary goal was to remove all of the calls to `serde_json::to_string()` for the data-handling, thus enabling us to do (more or less): ```rust Order { row.column, ... } ``` as well as clean up the SQL for easier reading. This has mostly been accomplished, with further refinements easily accomplished once the upstream issues in `sqlx` are addressed. See #314 for issues we are tracking.
3 years ago
"name": "id",
"ordinal": 0,
"type_info": "Int64"
}
],
"parameters": {
"Right": 1
},
"nullable": [
true
]
}
},
"b708b7116aa14093e0e21ab8f87e52928a70649a62250902054ef6526f1d6f66": {
"query": "\n select\n uuid as \"uuid: crate::model::cfd::OrderId\",\n trading_pair as \"trading_pair: crate::model::TradingPair\",\n position as \"position: crate::model::Position\",\n initial_price,\n min_quantity,\n max_quantity,\n leverage as \"leverage: crate::model::Leverage\",\n liquidation_price,\n creation_timestamp_seconds as \"ts_secs: i64\",\n creation_timestamp_nanoseconds as \"ts_nanos: i32\",\n term_seconds as \"term_secs: i64\",\n term_nanoseconds as \"term_nanos: i32\",\n origin as \"origin: crate::model::cfd::Origin\",\n oracle_event_id\n\n from orders\n where uuid = $1\n ",
"describe": {
"columns": [
{
"name": "uuid: crate::model::cfd::OrderId",
Wire in automatic CET publication - Handles the Oracle's attestation in the cfd actor, transition according to the knowledge we have about the timelock expiry already. - Tries to publish the CET if we are in `CetStatus::Ready`, i.e. both the attestation and timelock expiry happened. We try publishing if either event happened, and just print a log in case it's not ready yet. - Tries to re-publish CET if we are in `PendingCet` upon restart. - Re-triggers CET monitoring upon startup. - Extends any state after `ContractSetup` to be able to store the attestation. (see below for ideas to change that) Things that could be done different: Currently we are carrying on the attestation through a lot of states - because we cannot just transition the user to `OpenCommitted` because it is a user decision to go for commit, but we have to keep the attestation around once it happened. To reduce the state complexity, we could store the attestation independent of the state, but associated with the cfd. This would make things a lot simpler, but we would then always have to go to the database to check if the attestation is already around (which might make other parts more complex).
3 years ago
"ordinal": 0,
Use actual margin value for contract setup Includes validating that the amount the other party commits to is the expected amount based on calculating the counterparty margin out of the CFD values. Note: We could also remove the lock amount from the messages and use the calculation on both sides - that would simplify things.
3 years ago
"type_info": "Text"
},
{
DB code rebasing for #88 The primary goal was to remove all of the calls to `serde_json::to_string()` for the data-handling, thus enabling us to do (more or less): ```rust Order { row.column, ... } ``` as well as clean up the SQL for easier reading. This has mostly been accomplished, with further refinements easily accomplished once the upstream issues in `sqlx` are addressed. See #314 for issues we are tracking.
3 years ago
"name": "trading_pair: crate::model::TradingPair",
Wire in automatic CET publication - Handles the Oracle's attestation in the cfd actor, transition according to the knowledge we have about the timelock expiry already. - Tries to publish the CET if we are in `CetStatus::Ready`, i.e. both the attestation and timelock expiry happened. We try publishing if either event happened, and just print a log in case it's not ready yet. - Tries to re-publish CET if we are in `PendingCet` upon restart. - Re-triggers CET monitoring upon startup. - Extends any state after `ContractSetup` to be able to store the attestation. (see below for ideas to change that) Things that could be done different: Currently we are carrying on the attestation through a lot of states - because we cannot just transition the user to `OpenCommitted` because it is a user decision to go for commit, but we have to keep the attestation around once it happened. To reduce the state complexity, we could store the attestation independent of the state, but associated with the cfd. This would make things a lot simpler, but we would then always have to go to the database to check if the attestation is already around (which might make other parts more complex).
3 years ago
"ordinal": 1,
Use actual margin value for contract setup Includes validating that the amount the other party commits to is the expected amount based on calculating the counterparty margin out of the CFD values. Note: We could also remove the lock amount from the messages and use the calculation on both sides - that would simplify things.
3 years ago
"type_info": "Text"
},
{
DB code rebasing for #88 The primary goal was to remove all of the calls to `serde_json::to_string()` for the data-handling, thus enabling us to do (more or less): ```rust Order { row.column, ... } ``` as well as clean up the SQL for easier reading. This has mostly been accomplished, with further refinements easily accomplished once the upstream issues in `sqlx` are addressed. See #314 for issues we are tracking.
3 years ago
"name": "position: crate::model::Position",
Wire in automatic CET publication - Handles the Oracle's attestation in the cfd actor, transition according to the knowledge we have about the timelock expiry already. - Tries to publish the CET if we are in `CetStatus::Ready`, i.e. both the attestation and timelock expiry happened. We try publishing if either event happened, and just print a log in case it's not ready yet. - Tries to re-publish CET if we are in `PendingCet` upon restart. - Re-triggers CET monitoring upon startup. - Extends any state after `ContractSetup` to be able to store the attestation. (see below for ideas to change that) Things that could be done different: Currently we are carrying on the attestation through a lot of states - because we cannot just transition the user to `OpenCommitted` because it is a user decision to go for commit, but we have to keep the attestation around once it happened. To reduce the state complexity, we could store the attestation independent of the state, but associated with the cfd. This would make things a lot simpler, but we would then always have to go to the database to check if the attestation is already around (which might make other parts more complex).
3 years ago
"ordinal": 2,
Use actual margin value for contract setup Includes validating that the amount the other party commits to is the expected amount based on calculating the counterparty margin out of the CFD values. Note: We could also remove the lock amount from the messages and use the calculation on both sides - that would simplify things.
3 years ago
"type_info": "Text"
},
{
DB code rebasing for #88 The primary goal was to remove all of the calls to `serde_json::to_string()` for the data-handling, thus enabling us to do (more or less): ```rust Order { row.column, ... } ``` as well as clean up the SQL for easier reading. This has mostly been accomplished, with further refinements easily accomplished once the upstream issues in `sqlx` are addressed. See #314 for issues we are tracking.
3 years ago
"name": "initial_price",
Wire in automatic CET publication - Handles the Oracle's attestation in the cfd actor, transition according to the knowledge we have about the timelock expiry already. - Tries to publish the CET if we are in `CetStatus::Ready`, i.e. both the attestation and timelock expiry happened. We try publishing if either event happened, and just print a log in case it's not ready yet. - Tries to re-publish CET if we are in `PendingCet` upon restart. - Re-triggers CET monitoring upon startup. - Extends any state after `ContractSetup` to be able to store the attestation. (see below for ideas to change that) Things that could be done different: Currently we are carrying on the attestation through a lot of states - because we cannot just transition the user to `OpenCommitted` because it is a user decision to go for commit, but we have to keep the attestation around once it happened. To reduce the state complexity, we could store the attestation independent of the state, but associated with the cfd. This would make things a lot simpler, but we would then always have to go to the database to check if the attestation is already around (which might make other parts more complex).
3 years ago
"ordinal": 3,
Use actual margin value for contract setup Includes validating that the amount the other party commits to is the expected amount based on calculating the counterparty margin out of the CFD values. Note: We could also remove the lock amount from the messages and use the calculation on both sides - that would simplify things.
3 years ago
"type_info": "Text"
},
{
DB code rebasing for #88 The primary goal was to remove all of the calls to `serde_json::to_string()` for the data-handling, thus enabling us to do (more or less): ```rust Order { row.column, ... } ``` as well as clean up the SQL for easier reading. This has mostly been accomplished, with further refinements easily accomplished once the upstream issues in `sqlx` are addressed. See #314 for issues we are tracking.
3 years ago
"name": "min_quantity",
Wire in automatic CET publication - Handles the Oracle's attestation in the cfd actor, transition according to the knowledge we have about the timelock expiry already. - Tries to publish the CET if we are in `CetStatus::Ready`, i.e. both the attestation and timelock expiry happened. We try publishing if either event happened, and just print a log in case it's not ready yet. - Tries to re-publish CET if we are in `PendingCet` upon restart. - Re-triggers CET monitoring upon startup. - Extends any state after `ContractSetup` to be able to store the attestation. (see below for ideas to change that) Things that could be done different: Currently we are carrying on the attestation through a lot of states - because we cannot just transition the user to `OpenCommitted` because it is a user decision to go for commit, but we have to keep the attestation around once it happened. To reduce the state complexity, we could store the attestation independent of the state, but associated with the cfd. This would make things a lot simpler, but we would then always have to go to the database to check if the attestation is already around (which might make other parts more complex).
3 years ago
"ordinal": 4,
DB code rebasing for #88 The primary goal was to remove all of the calls to `serde_json::to_string()` for the data-handling, thus enabling us to do (more or less): ```rust Order { row.column, ... } ``` as well as clean up the SQL for easier reading. This has mostly been accomplished, with further refinements easily accomplished once the upstream issues in `sqlx` are addressed. See #314 for issues we are tracking.
3 years ago
"type_info": "Text"
Use actual margin value for contract setup Includes validating that the amount the other party commits to is the expected amount based on calculating the counterparty margin out of the CFD values. Note: We could also remove the lock amount from the messages and use the calculation on both sides - that would simplify things.
3 years ago
},
{
DB code rebasing for #88 The primary goal was to remove all of the calls to `serde_json::to_string()` for the data-handling, thus enabling us to do (more or less): ```rust Order { row.column, ... } ``` as well as clean up the SQL for easier reading. This has mostly been accomplished, with further refinements easily accomplished once the upstream issues in `sqlx` are addressed. See #314 for issues we are tracking.
3 years ago
"name": "max_quantity",
Wire in automatic CET publication - Handles the Oracle's attestation in the cfd actor, transition according to the knowledge we have about the timelock expiry already. - Tries to publish the CET if we are in `CetStatus::Ready`, i.e. both the attestation and timelock expiry happened. We try publishing if either event happened, and just print a log in case it's not ready yet. - Tries to re-publish CET if we are in `PendingCet` upon restart. - Re-triggers CET monitoring upon startup. - Extends any state after `ContractSetup` to be able to store the attestation. (see below for ideas to change that) Things that could be done different: Currently we are carrying on the attestation through a lot of states - because we cannot just transition the user to `OpenCommitted` because it is a user decision to go for commit, but we have to keep the attestation around once it happened. To reduce the state complexity, we could store the attestation independent of the state, but associated with the cfd. This would make things a lot simpler, but we would then always have to go to the database to check if the attestation is already around (which might make other parts more complex).
3 years ago
"ordinal": 5,
Use actual margin value for contract setup Includes validating that the amount the other party commits to is the expected amount based on calculating the counterparty margin out of the CFD values. Note: We could also remove the lock amount from the messages and use the calculation on both sides - that would simplify things.
3 years ago
"type_info": "Text"
},
{
DB code rebasing for #88 The primary goal was to remove all of the calls to `serde_json::to_string()` for the data-handling, thus enabling us to do (more or less): ```rust Order { row.column, ... } ``` as well as clean up the SQL for easier reading. This has mostly been accomplished, with further refinements easily accomplished once the upstream issues in `sqlx` are addressed. See #314 for issues we are tracking.
3 years ago
"name": "leverage: crate::model::Leverage",
Wire in automatic CET publication - Handles the Oracle's attestation in the cfd actor, transition according to the knowledge we have about the timelock expiry already. - Tries to publish the CET if we are in `CetStatus::Ready`, i.e. both the attestation and timelock expiry happened. We try publishing if either event happened, and just print a log in case it's not ready yet. - Tries to re-publish CET if we are in `PendingCet` upon restart. - Re-triggers CET monitoring upon startup. - Extends any state after `ContractSetup` to be able to store the attestation. (see below for ideas to change that) Things that could be done different: Currently we are carrying on the attestation through a lot of states - because we cannot just transition the user to `OpenCommitted` because it is a user decision to go for commit, but we have to keep the attestation around once it happened. To reduce the state complexity, we could store the attestation independent of the state, but associated with the cfd. This would make things a lot simpler, but we would then always have to go to the database to check if the attestation is already around (which might make other parts more complex).
3 years ago
"ordinal": 6,
DB code rebasing for #88 The primary goal was to remove all of the calls to `serde_json::to_string()` for the data-handling, thus enabling us to do (more or less): ```rust Order { row.column, ... } ``` as well as clean up the SQL for easier reading. This has mostly been accomplished, with further refinements easily accomplished once the upstream issues in `sqlx` are addressed. See #314 for issues we are tracking.
3 years ago
"type_info": "Int64"
Use actual margin value for contract setup Includes validating that the amount the other party commits to is the expected amount based on calculating the counterparty margin out of the CFD values. Note: We could also remove the lock amount from the messages and use the calculation on both sides - that would simplify things.
3 years ago
},
{
DB code rebasing for #88 The primary goal was to remove all of the calls to `serde_json::to_string()` for the data-handling, thus enabling us to do (more or less): ```rust Order { row.column, ... } ``` as well as clean up the SQL for easier reading. This has mostly been accomplished, with further refinements easily accomplished once the upstream issues in `sqlx` are addressed. See #314 for issues we are tracking.
3 years ago
"name": "liquidation_price",
Wire in automatic CET publication - Handles the Oracle's attestation in the cfd actor, transition according to the knowledge we have about the timelock expiry already. - Tries to publish the CET if we are in `CetStatus::Ready`, i.e. both the attestation and timelock expiry happened. We try publishing if either event happened, and just print a log in case it's not ready yet. - Tries to re-publish CET if we are in `PendingCet` upon restart. - Re-triggers CET monitoring upon startup. - Extends any state after `ContractSetup` to be able to store the attestation. (see below for ideas to change that) Things that could be done different: Currently we are carrying on the attestation through a lot of states - because we cannot just transition the user to `OpenCommitted` because it is a user decision to go for commit, but we have to keep the attestation around once it happened. To reduce the state complexity, we could store the attestation independent of the state, but associated with the cfd. This would make things a lot simpler, but we would then always have to go to the database to check if the attestation is already around (which might make other parts more complex).
3 years ago
"ordinal": 7,
Use actual margin value for contract setup Includes validating that the amount the other party commits to is the expected amount based on calculating the counterparty margin out of the CFD values. Note: We could also remove the lock amount from the messages and use the calculation on both sides - that would simplify things.
3 years ago
"type_info": "Text"
},
{
DB code rebasing for #88 The primary goal was to remove all of the calls to `serde_json::to_string()` for the data-handling, thus enabling us to do (more or less): ```rust Order { row.column, ... } ``` as well as clean up the SQL for easier reading. This has mostly been accomplished, with further refinements easily accomplished once the upstream issues in `sqlx` are addressed. See #314 for issues we are tracking.
3 years ago
"name": "ts_secs: i64",
Wire in automatic CET publication - Handles the Oracle's attestation in the cfd actor, transition according to the knowledge we have about the timelock expiry already. - Tries to publish the CET if we are in `CetStatus::Ready`, i.e. both the attestation and timelock expiry happened. We try publishing if either event happened, and just print a log in case it's not ready yet. - Tries to re-publish CET if we are in `PendingCet` upon restart. - Re-triggers CET monitoring upon startup. - Extends any state after `ContractSetup` to be able to store the attestation. (see below for ideas to change that) Things that could be done different: Currently we are carrying on the attestation through a lot of states - because we cannot just transition the user to `OpenCommitted` because it is a user decision to go for commit, but we have to keep the attestation around once it happened. To reduce the state complexity, we could store the attestation independent of the state, but associated with the cfd. This would make things a lot simpler, but we would then always have to go to the database to check if the attestation is already around (which might make other parts more complex).
3 years ago
"ordinal": 8,
DB code rebasing for #88 The primary goal was to remove all of the calls to `serde_json::to_string()` for the data-handling, thus enabling us to do (more or less): ```rust Order { row.column, ... } ``` as well as clean up the SQL for easier reading. This has mostly been accomplished, with further refinements easily accomplished once the upstream issues in `sqlx` are addressed. See #314 for issues we are tracking.
3 years ago
"type_info": "Int64"
Use actual margin value for contract setup Includes validating that the amount the other party commits to is the expected amount based on calculating the counterparty margin out of the CFD values. Note: We could also remove the lock amount from the messages and use the calculation on both sides - that would simplify things.
3 years ago
},
{
DB code rebasing for #88 The primary goal was to remove all of the calls to `serde_json::to_string()` for the data-handling, thus enabling us to do (more or less): ```rust Order { row.column, ... } ``` as well as clean up the SQL for easier reading. This has mostly been accomplished, with further refinements easily accomplished once the upstream issues in `sqlx` are addressed. See #314 for issues we are tracking.
3 years ago
"name": "ts_nanos: i32",
Wire in automatic CET publication - Handles the Oracle's attestation in the cfd actor, transition according to the knowledge we have about the timelock expiry already. - Tries to publish the CET if we are in `CetStatus::Ready`, i.e. both the attestation and timelock expiry happened. We try publishing if either event happened, and just print a log in case it's not ready yet. - Tries to re-publish CET if we are in `PendingCet` upon restart. - Re-triggers CET monitoring upon startup. - Extends any state after `ContractSetup` to be able to store the attestation. (see below for ideas to change that) Things that could be done different: Currently we are carrying on the attestation through a lot of states - because we cannot just transition the user to `OpenCommitted` because it is a user decision to go for commit, but we have to keep the attestation around once it happened. To reduce the state complexity, we could store the attestation independent of the state, but associated with the cfd. This would make things a lot simpler, but we would then always have to go to the database to check if the attestation is already around (which might make other parts more complex).
3 years ago
"ordinal": 9,
DB code rebasing for #88 The primary goal was to remove all of the calls to `serde_json::to_string()` for the data-handling, thus enabling us to do (more or less): ```rust Order { row.column, ... } ``` as well as clean up the SQL for easier reading. This has mostly been accomplished, with further refinements easily accomplished once the upstream issues in `sqlx` are addressed. See #314 for issues we are tracking.
3 years ago
"type_info": "Int64"
Use actual margin value for contract setup Includes validating that the amount the other party commits to is the expected amount based on calculating the counterparty margin out of the CFD values. Note: We could also remove the lock amount from the messages and use the calculation on both sides - that would simplify things.
3 years ago
},
{
DB code rebasing for #88 The primary goal was to remove all of the calls to `serde_json::to_string()` for the data-handling, thus enabling us to do (more or less): ```rust Order { row.column, ... } ``` as well as clean up the SQL for easier reading. This has mostly been accomplished, with further refinements easily accomplished once the upstream issues in `sqlx` are addressed. See #314 for issues we are tracking.
3 years ago
"name": "term_secs: i64",
Wire in automatic CET publication - Handles the Oracle's attestation in the cfd actor, transition according to the knowledge we have about the timelock expiry already. - Tries to publish the CET if we are in `CetStatus::Ready`, i.e. both the attestation and timelock expiry happened. We try publishing if either event happened, and just print a log in case it's not ready yet. - Tries to re-publish CET if we are in `PendingCet` upon restart. - Re-triggers CET monitoring upon startup. - Extends any state after `ContractSetup` to be able to store the attestation. (see below for ideas to change that) Things that could be done different: Currently we are carrying on the attestation through a lot of states - because we cannot just transition the user to `OpenCommitted` because it is a user decision to go for commit, but we have to keep the attestation around once it happened. To reduce the state complexity, we could store the attestation independent of the state, but associated with the cfd. This would make things a lot simpler, but we would then always have to go to the database to check if the attestation is already around (which might make other parts more complex).
3 years ago
"ordinal": 10,
DB code rebasing for #88 The primary goal was to remove all of the calls to `serde_json::to_string()` for the data-handling, thus enabling us to do (more or less): ```rust Order { row.column, ... } ``` as well as clean up the SQL for easier reading. This has mostly been accomplished, with further refinements easily accomplished once the upstream issues in `sqlx` are addressed. See #314 for issues we are tracking.
3 years ago
"type_info": "Int64"
Use actual margin value for contract setup Includes validating that the amount the other party commits to is the expected amount based on calculating the counterparty margin out of the CFD values. Note: We could also remove the lock amount from the messages and use the calculation on both sides - that would simplify things.
3 years ago
},
{
DB code rebasing for #88 The primary goal was to remove all of the calls to `serde_json::to_string()` for the data-handling, thus enabling us to do (more or less): ```rust Order { row.column, ... } ``` as well as clean up the SQL for easier reading. This has mostly been accomplished, with further refinements easily accomplished once the upstream issues in `sqlx` are addressed. See #314 for issues we are tracking.
3 years ago
"name": "term_nanos: i32",
Wire in automatic CET publication - Handles the Oracle's attestation in the cfd actor, transition according to the knowledge we have about the timelock expiry already. - Tries to publish the CET if we are in `CetStatus::Ready`, i.e. both the attestation and timelock expiry happened. We try publishing if either event happened, and just print a log in case it's not ready yet. - Tries to re-publish CET if we are in `PendingCet` upon restart. - Re-triggers CET monitoring upon startup. - Extends any state after `ContractSetup` to be able to store the attestation. (see below for ideas to change that) Things that could be done different: Currently we are carrying on the attestation through a lot of states - because we cannot just transition the user to `OpenCommitted` because it is a user decision to go for commit, but we have to keep the attestation around once it happened. To reduce the state complexity, we could store the attestation independent of the state, but associated with the cfd. This would make things a lot simpler, but we would then always have to go to the database to check if the attestation is already around (which might make other parts more complex).
3 years ago
"ordinal": 11,
DB code rebasing for #88 The primary goal was to remove all of the calls to `serde_json::to_string()` for the data-handling, thus enabling us to do (more or less): ```rust Order { row.column, ... } ``` as well as clean up the SQL for easier reading. This has mostly been accomplished, with further refinements easily accomplished once the upstream issues in `sqlx` are addressed. See #314 for issues we are tracking.
3 years ago
"type_info": "Int64"
Use actual margin value for contract setup Includes validating that the amount the other party commits to is the expected amount based on calculating the counterparty margin out of the CFD values. Note: We could also remove the lock amount from the messages and use the calculation on both sides - that would simplify things.
3 years ago
},
{
DB code rebasing for #88 The primary goal was to remove all of the calls to `serde_json::to_string()` for the data-handling, thus enabling us to do (more or less): ```rust Order { row.column, ... } ``` as well as clean up the SQL for easier reading. This has mostly been accomplished, with further refinements easily accomplished once the upstream issues in `sqlx` are addressed. See #314 for issues we are tracking.
3 years ago
"name": "origin: crate::model::cfd::Origin",
Wire in automatic CET publication - Handles the Oracle's attestation in the cfd actor, transition according to the knowledge we have about the timelock expiry already. - Tries to publish the CET if we are in `CetStatus::Ready`, i.e. both the attestation and timelock expiry happened. We try publishing if either event happened, and just print a log in case it's not ready yet. - Tries to re-publish CET if we are in `PendingCet` upon restart. - Re-triggers CET monitoring upon startup. - Extends any state after `ContractSetup` to be able to store the attestation. (see below for ideas to change that) Things that could be done different: Currently we are carrying on the attestation through a lot of states - because we cannot just transition the user to `OpenCommitted` because it is a user decision to go for commit, but we have to keep the attestation around once it happened. To reduce the state complexity, we could store the attestation independent of the state, but associated with the cfd. This would make things a lot simpler, but we would then always have to go to the database to check if the attestation is already around (which might make other parts more complex).
3 years ago
"ordinal": 12,
Use actual margin value for contract setup Includes validating that the amount the other party commits to is the expected amount based on calculating the counterparty margin out of the CFD values. Note: We could also remove the lock amount from the messages and use the calculation on both sides - that would simplify things.
3 years ago
"type_info": "Text"
Maker publishes `OracleEventId` as part of offer The latest announcement known to the maker's cfd actor is used for extracting the event id.
3 years ago
},
{
DB code rebasing for #88 The primary goal was to remove all of the calls to `serde_json::to_string()` for the data-handling, thus enabling us to do (more or less): ```rust Order { row.column, ... } ``` as well as clean up the SQL for easier reading. This has mostly been accomplished, with further refinements easily accomplished once the upstream issues in `sqlx` are addressed. See #314 for issues we are tracking.
3 years ago
"name": "oracle_event_id",
Wire in automatic CET publication - Handles the Oracle's attestation in the cfd actor, transition according to the knowledge we have about the timelock expiry already. - Tries to publish the CET if we are in `CetStatus::Ready`, i.e. both the attestation and timelock expiry happened. We try publishing if either event happened, and just print a log in case it's not ready yet. - Tries to re-publish CET if we are in `PendingCet` upon restart. - Re-triggers CET monitoring upon startup. - Extends any state after `ContractSetup` to be able to store the attestation. (see below for ideas to change that) Things that could be done different: Currently we are carrying on the attestation through a lot of states - because we cannot just transition the user to `OpenCommitted` because it is a user decision to go for commit, but we have to keep the attestation around once it happened. To reduce the state complexity, we could store the attestation independent of the state, but associated with the cfd. This would make things a lot simpler, but we would then always have to go to the database to check if the attestation is already around (which might make other parts more complex).
3 years ago
"ordinal": 13,
Maker publishes `OracleEventId` as part of offer The latest announcement known to the maker's cfd actor is used for extracting the event id.
3 years ago
"type_info": "Text"
Use actual margin value for contract setup Includes validating that the amount the other party commits to is the expected amount based on calculating the counterparty margin out of the CFD values. Note: We could also remove the lock amount from the messages and use the calculation on both sides - that would simplify things.
3 years ago
}
],
"parameters": {
"Right": 1
},
"nullable": [
false,
false,
false,
false,
false,
false,
false,
false,
false,
false,
false,
false,
Maker publishes `OracleEventId` as part of offer The latest announcement known to the maker's cfd actor is used for extracting the event id.
3 years ago
false,
Use actual margin value for contract setup Includes validating that the amount the other party commits to is the expected amount based on calculating the counterparty margin out of the CFD values. Note: We could also remove the lock amount from the messages and use the calculation on both sides - that would simplify things.
3 years ago
false
]
}
},
DB code rebasing for #88 The primary goal was to remove all of the calls to `serde_json::to_string()` for the data-handling, thus enabling us to do (more or less): ```rust Order { row.column, ... } ``` as well as clean up the SQL for easier reading. This has mostly been accomplished, with further refinements easily accomplished once the upstream issues in `sqlx` are addressed. See #314 for issues we are tracking.
3 years ago
"d8323d50427833c983088011597081023ac564d65bc459d26aa27549a49b1df8": {
"query": "\n with ord as (\n select\n id as order_id,\n uuid,\n trading_pair,\n position,\n initial_price,\n min_quantity,\n max_quantity,\n leverage,\n liquidation_price,\n creation_timestamp_seconds as ts_secs,\n creation_timestamp_nanoseconds as ts_nanos,\n term_seconds as term_secs,\n term_nanoseconds as term_nanos,\n origin,\n oracle_event_id\n from orders\n ),\n\n cfd as (\n select\n id as cfd_id,\n order_id,\n quantity_usd as quantity_usd\n from cfds\n ),\n\n tmp as (\n select\n id as state_id,\n cfd_id,\n state\n from cfd_states\n ),\n\n state as (\n select\n tmp.state,\n cfd.order_id,\n cfd.quantity_usd\n from tmp\n inner join cfd on tmp.cfd_id = cfd.cfd_id\n where tmp.state_id in (\n select max(state_id)\n from tmp\n group by state_id\n )\n )\n\n select\n ord.uuid as \"uuid: crate::model::cfd::OrderId\",\n ord.trading_pair as \"trading_pair: crate::model::TradingPair\",\n ord.position as \"position: crate::model::Position\",\n ord.initial_price,\n ord.min_quantity,\n ord.max_quantity,\n ord.leverage as \"leverage: crate::model::Leverage\",\n ord.liquidation_price,\n ord.ts_secs as \"ts_secs: i64\",\n ord.ts_nanos as \"ts_nanos: i32\",\n ord.term_secs as \"term_secs: i64\",\n ord.term_nanos as \"term_nanos: i32\",\n ord.origin as \"origin: crate::model::cfd::Origin\",\n ord.oracle_event_id,\n state.quantity_usd,\n state.state\n\n from ord\n inner join state on state.order_id = ord.order_id\n ",
Initial daemon and frontend for taker and maker Co-authored-by: Mariusz Klochowicz <mariusz@klochowicz.com>
3 years ago
"describe": {
"columns": [
{
DB code rebasing for #88 The primary goal was to remove all of the calls to `serde_json::to_string()` for the data-handling, thus enabling us to do (more or less): ```rust Order { row.column, ... } ``` as well as clean up the SQL for easier reading. This has mostly been accomplished, with further refinements easily accomplished once the upstream issues in `sqlx` are addressed. See #314 for issues we are tracking.
3 years ago
"name": "uuid: crate::model::cfd::OrderId",
Initial daemon and frontend for taker and maker Co-authored-by: Mariusz Klochowicz <mariusz@klochowicz.com>
3 years ago
"ordinal": 0,
DB code rebasing for #88 The primary goal was to remove all of the calls to `serde_json::to_string()` for the data-handling, thus enabling us to do (more or less): ```rust Order { row.column, ... } ``` as well as clean up the SQL for easier reading. This has mostly been accomplished, with further refinements easily accomplished once the upstream issues in `sqlx` are addressed. See #314 for issues we are tracking.
3 years ago
"type_info": "Text"
Initial daemon and frontend for taker and maker Co-authored-by: Mariusz Klochowicz <mariusz@klochowicz.com>
3 years ago
},
{
DB code rebasing for #88 The primary goal was to remove all of the calls to `serde_json::to_string()` for the data-handling, thus enabling us to do (more or less): ```rust Order { row.column, ... } ``` as well as clean up the SQL for easier reading. This has mostly been accomplished, with further refinements easily accomplished once the upstream issues in `sqlx` are addressed. See #314 for issues we are tracking.
3 years ago
"name": "trading_pair: crate::model::TradingPair",
Initial daemon and frontend for taker and maker Co-authored-by: Mariusz Klochowicz <mariusz@klochowicz.com>
3 years ago
"ordinal": 1,
"type_info": "Text"
},
{
DB code rebasing for #88 The primary goal was to remove all of the calls to `serde_json::to_string()` for the data-handling, thus enabling us to do (more or less): ```rust Order { row.column, ... } ``` as well as clean up the SQL for easier reading. This has mostly been accomplished, with further refinements easily accomplished once the upstream issues in `sqlx` are addressed. See #314 for issues we are tracking.
3 years ago
"name": "position: crate::model::Position",
Initial daemon and frontend for taker and maker Co-authored-by: Mariusz Klochowicz <mariusz@klochowicz.com>
3 years ago
"ordinal": 2,
"type_info": "Text"
},
{
DB code rebasing for #88 The primary goal was to remove all of the calls to `serde_json::to_string()` for the data-handling, thus enabling us to do (more or less): ```rust Order { row.column, ... } ``` as well as clean up the SQL for easier reading. This has mostly been accomplished, with further refinements easily accomplished once the upstream issues in `sqlx` are addressed. See #314 for issues we are tracking.
3 years ago
"name": "initial_price",
Initial daemon and frontend for taker and maker Co-authored-by: Mariusz Klochowicz <mariusz@klochowicz.com>
3 years ago
"ordinal": 3,
"type_info": "Text"
},
{
DB code rebasing for #88 The primary goal was to remove all of the calls to `serde_json::to_string()` for the data-handling, thus enabling us to do (more or less): ```rust Order { row.column, ... } ``` as well as clean up the SQL for easier reading. This has mostly been accomplished, with further refinements easily accomplished once the upstream issues in `sqlx` are addressed. See #314 for issues we are tracking.
3 years ago
"name": "min_quantity",
Initial daemon and frontend for taker and maker Co-authored-by: Mariusz Klochowicz <mariusz@klochowicz.com>
3 years ago
"ordinal": 4,
"type_info": "Text"
},
{
DB code rebasing for #88 The primary goal was to remove all of the calls to `serde_json::to_string()` for the data-handling, thus enabling us to do (more or less): ```rust Order { row.column, ... } ``` as well as clean up the SQL for easier reading. This has mostly been accomplished, with further refinements easily accomplished once the upstream issues in `sqlx` are addressed. See #314 for issues we are tracking.
3 years ago
"name": "max_quantity",
Initial daemon and frontend for taker and maker Co-authored-by: Mariusz Klochowicz <mariusz@klochowicz.com>
3 years ago
"ordinal": 5,
"type_info": "Text"
},
{
DB code rebasing for #88 The primary goal was to remove all of the calls to `serde_json::to_string()` for the data-handling, thus enabling us to do (more or less): ```rust Order { row.column, ... } ``` as well as clean up the SQL for easier reading. This has mostly been accomplished, with further refinements easily accomplished once the upstream issues in `sqlx` are addressed. See #314 for issues we are tracking.
3 years ago
"name": "leverage: crate::model::Leverage",
Initial daemon and frontend for taker and maker Co-authored-by: Mariusz Klochowicz <mariusz@klochowicz.com>
3 years ago
"ordinal": 6,
DB code rebasing for #88 The primary goal was to remove all of the calls to `serde_json::to_string()` for the data-handling, thus enabling us to do (more or less): ```rust Order { row.column, ... } ``` as well as clean up the SQL for easier reading. This has mostly been accomplished, with further refinements easily accomplished once the upstream issues in `sqlx` are addressed. See #314 for issues we are tracking.
3 years ago
"type_info": "Int64"
Initial daemon and frontend for taker and maker Co-authored-by: Mariusz Klochowicz <mariusz@klochowicz.com>
3 years ago
},
{
DB code rebasing for #88 The primary goal was to remove all of the calls to `serde_json::to_string()` for the data-handling, thus enabling us to do (more or less): ```rust Order { row.column, ... } ``` as well as clean up the SQL for easier reading. This has mostly been accomplished, with further refinements easily accomplished once the upstream issues in `sqlx` are addressed. See #314 for issues we are tracking.
3 years ago
"name": "liquidation_price",
Initial daemon and frontend for taker and maker Co-authored-by: Mariusz Klochowicz <mariusz@klochowicz.com>
3 years ago
"ordinal": 7,
DB code rebasing for #88 The primary goal was to remove all of the calls to `serde_json::to_string()` for the data-handling, thus enabling us to do (more or less): ```rust Order { row.column, ... } ``` as well as clean up the SQL for easier reading. This has mostly been accomplished, with further refinements easily accomplished once the upstream issues in `sqlx` are addressed. See #314 for issues we are tracking.
3 years ago
"type_info": "Text"
Initial daemon and frontend for taker and maker Co-authored-by: Mariusz Klochowicz <mariusz@klochowicz.com>
3 years ago
},
{
DB code rebasing for #88 The primary goal was to remove all of the calls to `serde_json::to_string()` for the data-handling, thus enabling us to do (more or less): ```rust Order { row.column, ... } ``` as well as clean up the SQL for easier reading. This has mostly been accomplished, with further refinements easily accomplished once the upstream issues in `sqlx` are addressed. See #314 for issues we are tracking.
3 years ago
"name": "ts_secs: i64",
Initial daemon and frontend for taker and maker Co-authored-by: Mariusz Klochowicz <mariusz@klochowicz.com>
3 years ago
"ordinal": 8,
DB code rebasing for #88 The primary goal was to remove all of the calls to `serde_json::to_string()` for the data-handling, thus enabling us to do (more or less): ```rust Order { row.column, ... } ``` as well as clean up the SQL for easier reading. This has mostly been accomplished, with further refinements easily accomplished once the upstream issues in `sqlx` are addressed. See #314 for issues we are tracking.
3 years ago
"type_info": "Int64"
Initial daemon and frontend for taker and maker Co-authored-by: Mariusz Klochowicz <mariusz@klochowicz.com>
3 years ago
},
{
DB code rebasing for #88 The primary goal was to remove all of the calls to `serde_json::to_string()` for the data-handling, thus enabling us to do (more or less): ```rust Order { row.column, ... } ``` as well as clean up the SQL for easier reading. This has mostly been accomplished, with further refinements easily accomplished once the upstream issues in `sqlx` are addressed. See #314 for issues we are tracking.
3 years ago
"name": "ts_nanos: i32",
Initial daemon and frontend for taker and maker Co-authored-by: Mariusz Klochowicz <mariusz@klochowicz.com>
3 years ago
"ordinal": 9,
DB code rebasing for #88 The primary goal was to remove all of the calls to `serde_json::to_string()` for the data-handling, thus enabling us to do (more or less): ```rust Order { row.column, ... } ``` as well as clean up the SQL for easier reading. This has mostly been accomplished, with further refinements easily accomplished once the upstream issues in `sqlx` are addressed. See #314 for issues we are tracking.
3 years ago
"type_info": "Int64"
Initial daemon and frontend for taker and maker Co-authored-by: Mariusz Klochowicz <mariusz@klochowicz.com>
3 years ago
},
{
DB code rebasing for #88 The primary goal was to remove all of the calls to `serde_json::to_string()` for the data-handling, thus enabling us to do (more or less): ```rust Order { row.column, ... } ``` as well as clean up the SQL for easier reading. This has mostly been accomplished, with further refinements easily accomplished once the upstream issues in `sqlx` are addressed. See #314 for issues we are tracking.
3 years ago
"name": "term_secs: i64",
Initial daemon and frontend for taker and maker Co-authored-by: Mariusz Klochowicz <mariusz@klochowicz.com>
3 years ago
"ordinal": 10,
DB code rebasing for #88 The primary goal was to remove all of the calls to `serde_json::to_string()` for the data-handling, thus enabling us to do (more or less): ```rust Order { row.column, ... } ``` as well as clean up the SQL for easier reading. This has mostly been accomplished, with further refinements easily accomplished once the upstream issues in `sqlx` are addressed. See #314 for issues we are tracking.
3 years ago
"type_info": "Int64"
Margin calculation The buy margin is calculated from `initial_price`, `quantity` and `leverage`. The sell margin is calculated from `initial_price` and `quantity` (no leverage trading for the seller at the moment). Includes several refactors: - Separate API interface for `Cfd` and `CfdOffer` when mapping `toSseEvent`. This allows internal modelling to be different than the exposed API. - Remove the profit calculation internally, it is only relevant on the UI feed API level. - Move code that is specific to taker/maker http API from `model` to the respective `routes` module. - Some simplification of the calculation model of `Usd` (could be further improved by deriving calculation traits) - Introduces `OfferOrigin` used to save the offer's origin as `mine` and `others` in the database. This is used to properly derive the CFD position from the offer.
3 years ago
},
{
DB code rebasing for #88 The primary goal was to remove all of the calls to `serde_json::to_string()` for the data-handling, thus enabling us to do (more or less): ```rust Order { row.column, ... } ``` as well as clean up the SQL for easier reading. This has mostly been accomplished, with further refinements easily accomplished once the upstream issues in `sqlx` are addressed. See #314 for issues we are tracking.
3 years ago
"name": "term_nanos: i32",
Margin calculation The buy margin is calculated from `initial_price`, `quantity` and `leverage`. The sell margin is calculated from `initial_price` and `quantity` (no leverage trading for the seller at the moment). Includes several refactors: - Separate API interface for `Cfd` and `CfdOffer` when mapping `toSseEvent`. This allows internal modelling to be different than the exposed API. - Remove the profit calculation internally, it is only relevant on the UI feed API level. - Move code that is specific to taker/maker http API from `model` to the respective `routes` module. - Some simplification of the calculation model of `Usd` (could be further improved by deriving calculation traits) - Introduces `OfferOrigin` used to save the offer's origin as `mine` and `others` in the database. This is used to properly derive the CFD position from the offer.
3 years ago
"ordinal": 11,
DB code rebasing for #88 The primary goal was to remove all of the calls to `serde_json::to_string()` for the data-handling, thus enabling us to do (more or less): ```rust Order { row.column, ... } ``` as well as clean up the SQL for easier reading. This has mostly been accomplished, with further refinements easily accomplished once the upstream issues in `sqlx` are addressed. See #314 for issues we are tracking.
3 years ago
"type_info": "Int64"
},
{
"name": "origin: crate::model::cfd::Origin",
"ordinal": 12,
Margin calculation The buy margin is calculated from `initial_price`, `quantity` and `leverage`. The sell margin is calculated from `initial_price` and `quantity` (no leverage trading for the seller at the moment). Includes several refactors: - Separate API interface for `Cfd` and `CfdOffer` when mapping `toSseEvent`. This allows internal modelling to be different than the exposed API. - Remove the profit calculation internally, it is only relevant on the UI feed API level. - Move code that is specific to taker/maker http API from `model` to the respective `routes` module. - Some simplification of the calculation model of `Usd` (could be further improved by deriving calculation traits) - Introduces `OfferOrigin` used to save the offer's origin as `mine` and `others` in the database. This is used to properly derive the CFD position from the offer.
3 years ago
"type_info": "Text"
Maker publishes `OracleEventId` as part of offer The latest announcement known to the maker's cfd actor is used for extracting the event id.
3 years ago
},
{
"name": "oracle_event_id",
DB code rebasing for #88 The primary goal was to remove all of the calls to `serde_json::to_string()` for the data-handling, thus enabling us to do (more or less): ```rust Order { row.column, ... } ``` as well as clean up the SQL for easier reading. This has mostly been accomplished, with further refinements easily accomplished once the upstream issues in `sqlx` are addressed. See #314 for issues we are tracking.
3 years ago
"ordinal": 13,
"type_info": "Text"
},
{
"name": "quantity_usd",
"ordinal": 14,
"type_info": "Text"
},
{
"name": "state",
"ordinal": 15,
Maker publishes `OracleEventId` as part of offer The latest announcement known to the maker's cfd actor is used for extracting the event id.
3 years ago
"type_info": "Text"
Initial daemon and frontend for taker and maker Co-authored-by: Mariusz Klochowicz <mariusz@klochowicz.com>
3 years ago
}
],
"parameters": {
DB code rebasing for #88 The primary goal was to remove all of the calls to `serde_json::to_string()` for the data-handling, thus enabling us to do (more or less): ```rust Order { row.column, ... } ``` as well as clean up the SQL for easier reading. This has mostly been accomplished, with further refinements easily accomplished once the upstream issues in `sqlx` are addressed. See #314 for issues we are tracking.
3 years ago
"Right": 0
Initial daemon and frontend for taker and maker Co-authored-by: Mariusz Klochowicz <mariusz@klochowicz.com>
3 years ago
},
"nullable": [
DB code rebasing for #88 The primary goal was to remove all of the calls to `serde_json::to_string()` for the data-handling, thus enabling us to do (more or less): ```rust Order { row.column, ... } ``` as well as clean up the SQL for easier reading. This has mostly been accomplished, with further refinements easily accomplished once the upstream issues in `sqlx` are addressed. See #314 for issues we are tracking.
3 years ago
false,
false,
false,
false,
Initial daemon and frontend for taker and maker Co-authored-by: Mariusz Klochowicz <mariusz@klochowicz.com>
3 years ago
false,
false,
false,
false,
false,
false,
false,
false,
false,
Margin calculation The buy margin is calculated from `initial_price`, `quantity` and `leverage`. The sell margin is calculated from `initial_price` and `quantity` (no leverage trading for the seller at the moment). Includes several refactors: - Separate API interface for `Cfd` and `CfdOffer` when mapping `toSseEvent`. This allows internal modelling to be different than the exposed API. - Remove the profit calculation internally, it is only relevant on the UI feed API level. - Move code that is specific to taker/maker http API from `model` to the respective `routes` module. - Some simplification of the calculation model of `Usd` (could be further improved by deriving calculation traits) - Introduces `OfferOrigin` used to save the offer's origin as `mine` and `others` in the database. This is used to properly derive the CFD position from the offer.
3 years ago
false,
Maker publishes `OracleEventId` as part of offer The latest announcement known to the maker's cfd actor is used for extracting the event id.
3 years ago
false,
Initial daemon and frontend for taker and maker Co-authored-by: Mariusz Klochowicz <mariusz@klochowicz.com>
3 years ago
false
]
}
},
DB code rebasing for #88 The primary goal was to remove all of the calls to `serde_json::to_string()` for the data-handling, thus enabling us to do (more or less): ```rust Order { row.column, ... } ``` as well as clean up the SQL for easier reading. This has mostly been accomplished, with further refinements easily accomplished once the upstream issues in `sqlx` are addressed. See #314 for issues we are tracking.
3 years ago
"dde58d2118537f05941a79896639efb2e64f2bb6cf76f14c6c2eec20ec253160": {
"query": "\n insert into cfds (\n order_id,\n order_uuid,\n quantity_usd\n )\n select\n id as order_id,\n uuid as order_uuid,\n $2 as quantity_usd\n from orders\n where uuid = $1;\n\n insert into cfd_states (\n cfd_id,\n state\n )\n select\n id as cfd_id,\n $3 as state\n from cfds\n order by id desc limit 1;\n ",
Initial daemon and frontend for taker and maker Co-authored-by: Mariusz Klochowicz <mariusz@klochowicz.com>
3 years ago
"describe": {
"columns": [],
"parameters": {
DB code rebasing for #88 The primary goal was to remove all of the calls to `serde_json::to_string()` for the data-handling, thus enabling us to do (more or less): ```rust Order { row.column, ... } ``` as well as clean up the SQL for easier reading. This has mostly been accomplished, with further refinements easily accomplished once the upstream issues in `sqlx` are addressed. See #314 for issues we are tracking.
3 years ago
"Right": 3
Initial daemon and frontend for taker and maker Co-authored-by: Mariusz Klochowicz <mariusz@klochowicz.com>
3 years ago
},
"nullable": []
}
Rename offer to order. Everywhere!!!
3 years ago
},
DB code rebasing for #88 The primary goal was to remove all of the calls to `serde_json::to_string()` for the data-handling, thus enabling us to do (more or less): ```rust Order { row.column, ... } ``` as well as clean up the SQL for easier reading. This has mostly been accomplished, with further refinements easily accomplished once the upstream issues in `sqlx` are addressed. See #314 for issues we are tracking.
3 years ago
"faaf391b5dca70a87c5f8ac9346fd6d9dd1ae6b83d99a0311df463ecaaf8c301": {
"query": "\n insert into cfd_states (\n cfd_id,\n state\n ) values ($1, $2);\n ",
Rename offer to order. Everywhere!!!
3 years ago
"describe": {
"columns": [],
"parameters": {
DB code rebasing for #88 The primary goal was to remove all of the calls to `serde_json::to_string()` for the data-handling, thus enabling us to do (more or less): ```rust Order { row.column, ... } ``` as well as clean up the SQL for easier reading. This has mostly been accomplished, with further refinements easily accomplished once the upstream issues in `sqlx` are addressed. See #314 for issues we are tracking.
3 years ago
"Right": 2
Rename offer to order. Everywhere!!!
3 years ago
},
"nullable": []
}
Initial daemon and frontend for taker and maker Co-authored-by: Mariusz Klochowicz <mariusz@klochowicz.com>
3 years ago
}
}