Skip to content

Commit

Permalink
missing take order entity test
Browse files Browse the repository at this point in the history
  • Loading branch information
NanezX committed Nov 1, 2023
1 parent 362d351 commit d94908b
Show file tree
Hide file tree
Showing 5 changed files with 351 additions and 4 deletions.
187 changes: 184 additions & 3 deletions subgraph/tests/entities.rs
Original file line number Diff line number Diff line change
Expand Up @@ -16,11 +16,11 @@ use utils::{
deploy::{deploy_erc20_mock, get_expression_deployer, get_orderbook, read_orderbook_meta},
events::{
_get_new_expression_event, get_add_order_event, get_after_clear_events, get_clear_events,
get_deposit_events, get_take_order_events, get_withdraw_events,
get_deposit_events, get_take_order_event, get_take_order_events, get_withdraw_events,
},
generate_random_u256, get_wallet, h256_to_bytes,
json_structs::{NewExpressionJson, OrderJson},
numbers::{display_number, get_amount_tokens},
numbers::{display_number, divide_decimal_strings, get_amount_tokens},
transactions::{
approve_tokens, generate_clear_config, generate_multi_add_order, generate_multi_clear,
generate_multi_deposit, generate_multi_withdraw, generate_order_config, get_block_data,
Expand Down Expand Up @@ -2597,7 +2597,7 @@ async fn order_clear_state_change_entity_clear_test() -> anyhow::Result<()> {
}

#[tokio::main]
#[test]
// #[test]
async fn token_vault_take_order_entity_take_order_test() -> anyhow::Result<()> {
let orderbook = get_orderbook().await?;

Expand Down Expand Up @@ -2746,6 +2746,187 @@ async fn token_vault_take_order_entity_take_order_test() -> anyhow::Result<()> {
Ok(())
}

#[tokio::main]
#[test]
async fn take_order_entity_take_order_test() -> anyhow::Result<()> {
let orderbook = get_orderbook().await?;

let alice = get_wallet(1);
let bob = get_wallet(2);

// Connect the orderbook to another wallet
let orderbook = orderbook.connect(&alice).await;

// Vault id
let vault_id = generate_random_u256();

// Deploy ExpressionDeployerNP for the config
let expression_deployer = get_expression_deployer().await?;
// let expression_deployer = get_expression_deployer().await?;

// Deploy ERC20 token contract (A) connected to Alice
let token_input = deploy_erc20_mock(None).await?;

// Deploy ERC20 token contract (B) connected to Alice
let token_output = deploy_erc20_mock(None).await?;

// Build OrderConfig
let order_config = generate_order_config(
expression_deployer,
&token_input,
Some(vault_id),
&token_output,
Some(vault_id),
)
.await;

// Add the order
let add_order_func = orderbook.add_order(order_config.clone());
let tx_add_order = add_order_func.send().await?;

// Decode events from the transaction
let add_order_data = get_add_order_event(&orderbook, &tx_add_order).await?;

// Amount to deposit
let amount_b = get_amount_tokens(1000, token_output.decimals().call().await.unwrap());

// Fill to Alice with tokens
mint_tokens(&amount_b, &alice.address(), &token_output).await?;

// Connect token to Alice and approve Orderbook to move tokens
approve_tokens(
&amount_b,
&orderbook.address(),
&token_output.connect(&alice).await,
)
.await?;

// Alice deposit tokens
let deposit_func = orderbook.deposit(token_output.address(), vault_id, amount_b);
let _ = deposit_func.send().await?;

// BOB TAKE THE ORDER

// Take Order configs
let minimum_input = U256::from(0);
let maximum_input = get_amount_tokens(1000, token_output.decimals().call().await.unwrap());
let maximum_io_ratio = U256::from(10000000000000000000u64); // 10e18

let take_order_config = TakeOrderConfig {
order: add_order_data.order,
input_io_index: U256::zero(),
output_io_index: U256::zero(),
signed_context: Vec::new(),
};

let take_orders_config = TakeOrdersConfigV2 {
minimum_input,
maximum_input,
maximum_io_ratio,
orders: vec![take_order_config],
data: Bytes::new(), // Empty data
};

// Fill bob with token A (token input of the order)
// let amount_a = get_amount_tokens(1000, token_a.decimals().call().await.unwrap());
let amount_a = amount_b
.saturating_mul(maximum_io_ratio)
.checked_div(U256::from(1000000000000000000u64)) // 1e18
.unwrap();

mint_tokens(&amount_a, &bob.address(), &token_input).await?;

// Connect token to Bob and approve Orderbook to move tokens
approve_tokens(
&amount_a,
&orderbook.address(),
&token_input.connect(&bob).await,
)
.await?;

// Take the order
let take_order_func = orderbook
.connect(&bob)
.await
.take_orders(take_orders_config);
let tx_take_order = take_order_func.send().await?;

let tx_receipt = tx_take_order.await?.unwrap();

let take_order_tx_hash = &tx_receipt.transaction_hash;
let take_order_event = get_take_order_event(&orderbook, &take_order_tx_hash).await?;

let block_data = get_block_data(&take_order_tx_hash).await?;

// Using index 0 since only one take order was made in this tx
let take_order_entity = format!("{:?}-{}", take_order_tx_hash, 0);
let token_vault_input = format!(
"{}-{:?}-{:?}",
vault_id,
alice.address(),
token_input.address()
);
let token_vault_output = format!(
"{}-{:?}-{:?}",
vault_id,
alice.address(),
token_output.address()
);

let token_vault_take_order_a_id = format!("{}-{}", take_order_entity, token_vault_input);
let token_vault_take_order_b_id = format!("{}-{}", take_order_entity, token_vault_output);

let input_token = take_order_event
.config
.order
.valid_inputs
.first()
.unwrap()
.token;

let output_token = take_order_event
.config
.order
.valid_outputs
.first()
.unwrap()
.token;

let input_display = display_number(take_order_event.input, get_decimals(input_token).await?);
let output_display = display_number(take_order_event.output, get_decimals(output_token).await?);

let io_ratio =
divide_decimal_strings(&input_display, &output_display).unwrap_or("0".to_string());

let resp = Query::take_order_entity(&token_vault_input).await?;

assert_eq!(resp.sender, take_order_event.sender);
assert_eq!(resp.order, h256_to_bytes(&add_order_data.order_hash.into()));

assert_eq!(resp.input, take_order_event.input);
assert_eq!(resp.input_display, input_display);

assert_eq!(resp.output, take_order_event.output);
assert_eq!(resp.output_display, output_display);

assert_eq!(resp.io_ratio, io_ratio);

assert_eq!(resp.input_io_index, take_order_event.config.input_io_index);
assert_eq!(
resp.output_io_index,
take_order_event.config.output_io_index
);

assert_eq!(resp.input_token, input_token);
assert_eq!(resp.output_token, output_token);

assert_eq!(resp.transaction, *take_order_tx_hash);
assert_eq!(resp.emitter, take_order_event.sender);
assert_eq!(resp.timestamp, block_data.timestamp);

Ok(())
}

// #[test]
fn util_cbor_meta_test() -> anyhow::Result<()> {
// Read meta from root repository (output from nix command) and convert to Bytes
Expand Down
6 changes: 6 additions & 0 deletions subgraph/tests/subgraph/query/mod.rs
Original file line number Diff line number Diff line change
Expand Up @@ -12,6 +12,7 @@ pub(crate) mod token_vault_take_order;
pub(crate) mod vault;
pub(crate) mod vault_deposit;
pub(crate) mod vault_withdraw;
pub(crate) mod take_order_entity;

use anyhow::Result;
use ethers::types::{Address, Bytes};
Expand All @@ -32,6 +33,7 @@ use token_vault_take_order::{get_token_vault_take_order, TokenVaultTakeOrderResp
use vault::{get_vault, VaultResponse};
use vault_deposit::{get_vault_deposit, VaultDepositResponse};
use vault_withdraw::{get_vault_withdraw, VaultWithdrawResponse};
use take_order_entity::{get_take_order_entity, TakeOrderEntityResponse};

pub static SG_URL: Lazy<Url> =
Lazy::new(|| Url::parse("http://localhost:8000/subgraphs/name/test/test").unwrap());
Expand Down Expand Up @@ -94,4 +96,8 @@ impl Query {
pub async fn token_vault_take_order(id: &String) -> Result<TokenVaultTakeOrderResponse> {
get_token_vault_take_order(id).await
}

pub async fn take_order_entity(id: &String) -> Result<TakeOrderEntityResponse> {
get_take_order_entity(id).await
}
}
102 changes: 102 additions & 0 deletions subgraph/tests/subgraph/query/take_order_entity/mod.rs
Original file line number Diff line number Diff line change
@@ -0,0 +1,102 @@
use self::take_order_entity::ResponseData;
use super::SG_URL;
use crate::utils::{bytes_to_h256, hex_string_to_bytes, mn_mpz_to_u256};
use anyhow::{anyhow, Result};
use ethers::types::TxHash;
use ethers::types::{Address, Bytes, U256};
use graphql_client::{GraphQLQuery, Response};
use rust_bigint::BigInt;
use serde::{Deserialize, Serialize};

// use bigdecimal::BigDecimal;
type BigDecimal = String;

#[derive(GraphQLQuery)]
#[graphql(
schema_path = "tests/subgraph/query/schema.json",
query_path = "tests/subgraph/query/take_order_entity/take_order_entity.graphql",
response_derives = "Debug, Serialize, Deserialize"
)]
#[derive(Serialize, Deserialize, Debug)]
pub struct TakeOrderEntity;

#[derive(Serialize, Deserialize, Debug)]
pub struct TakeOrderEntityResponse {
pub id: String,
pub sender: Address,
pub order: Bytes,
pub input: U256,
pub input_display: String,
pub output: U256,
pub output_display: String,
pub io_ratio: String,
pub input_io_index: U256,
pub output_io_index: U256,
pub input_token: Address,
pub output_token: Address,
pub context: Option<String>,
pub emitter: Address,
pub transaction: TxHash,
pub timestamp: U256,
}

impl TakeOrderEntityResponse {
pub fn from(response: ResponseData) -> TakeOrderEntityResponse {
let data = response.take_order_entity.unwrap();

let sender = Address::from_slice(&data.sender.id);
let input_token = Address::from_slice(&hex_string_to_bytes(&data.input_token.id).unwrap());
let output_token =
Address::from_slice(&hex_string_to_bytes(&data.output_token.id).unwrap());
let emitter = Address::from_slice(&data.emitter.id);
let transaction = bytes_to_h256(&hex_string_to_bytes(&data.transaction.id).unwrap());

let context = match data.context {
Some(value) => Some(value.id),
None => None,
};

TakeOrderEntityResponse {
id: data.id,
sender,
order: hex_string_to_bytes(&data.order.id).unwrap(),
input: mn_mpz_to_u256(&data.input),
input_display: data.input_display,
output: mn_mpz_to_u256(&data.input),
output_display: data.output_display,
io_ratio: data.io_ratio,
input_io_index: mn_mpz_to_u256(&data.input_io_index),
output_io_index: mn_mpz_to_u256(&data.output_io_index),
input_token,
output_token,
context,
emitter,
transaction,
timestamp: mn_mpz_to_u256(&data.timestamp),
}
}
}

pub async fn get_vault_deposit(id: &String) -> Result<TakeOrderEntityResponse> {
let variables = take_order_entity::Variables {
id: id.to_string().into(),
};

let request_body = TakeOrderEntity::build_query(variables);
let client = reqwest::Client::new();
let res = client
.post((*SG_URL).clone())
.json(&request_body)
.send()
.await?;

let response_body: Response<ResponseData> = res.json().await?;

match response_body.data {
Some(data) => {
let response = TakeOrderEntityResponse::from(data);
Ok(response)
}
None => Err(anyhow!("Failed to get query")),
}
}
Original file line number Diff line number Diff line change
@@ -0,0 +1,34 @@
query TakeOrderEntity($id: String) {
takeOrderEntity(id: $id) {
id
sender {
id
}
order {
id
}
input
inputDisplay
output
outputDisplay
IORatio
inputIOIndex
outputIOIndex
inputToken {
id
}
outputToken {
id
}
transaction {
id
}
emitter {
id
}
timestamp
context {
id
}
}
}
Loading

0 comments on commit d94908b

Please sign in to comment.