Merge pull request #102 from Koku-Stacks/order_book

Order book [WIP]

contracts/futures-market.clar

@@ -22,7 +22,7 @@ u20
 )
 
 ;; FIXME adjust to final update cooldown value
-(define-constant POSITION_UPDATE_COOLDOWN u86400) ;; seconds in a day
+(define-constant POSITION_UPDATE_COOLDOWN u60) ;; seconds
 
 ;; FIXME adjust to proper final value
 (define-constant POSITION_MAX_DURATION u10) ;; number of days a position can be held

contracts/max-heap.clar

@@ -166,4 +166,7 @@
 (define-public (initialize)
   (begin
     (populate-heap)
-    (ok true)))
+    (ok true)))
+
+(define-public (get-orders)
+  (ok (map get-position HEAP_INDICES)))

contracts/min-heap.clar

@@ -166,4 +166,7 @@
 (define-public (initialize)
   (begin
     (populate-heap)
-    (ok true)))
+    (ok true)))
+
+(define-public (get-orders)
+  (ok (map get-position HEAP_INDICES)))

integration_tests/test_pool/futures_position.test.ts

@@ -5,6 +5,7 @@ import * as fs from "fs";
 import * as path from "path";
 import { CONTRACT_FOLDER, TRAITS_FOLDER, STACKS_API_URL } from "../config";
 import { StacksChain } from "dy-finance.lib";
+const POSITION_UPDATE_COOLDOWN = 60000; // ms
 
 describe("futures position", () => {
   const chain = new StacksChain(STACKS_API_URL, {
@@ -155,6 +156,8 @@ describe("futures position", () => {
       expect(insertPosition).to.be.ok;
     }
 
+    await new Promise(r => setTimeout(r, POSITION_UPDATE_COOLDOWN));
+
     const batchPositionMaintenance = await chain.callContract(
       deployer.address,
       futuresMarketContractName,

integration_tests/test_pool/order_book.test.ts

@@ -0,0 +1,144 @@
+import { uintCV } from "@stacks/transactions";
+import { expect } from "chai";
+import * as fs from "fs";
+import * as path from "path";
+import { CONTRACT_FOLDER, STACKS_API_URL } from "../config";
+import { StacksChain } from "dy-finance.lib";
+
+describe("order book", () => {
+  const chain = new StacksChain(STACKS_API_URL, {
+    defaultFee: 100000,
+  });
+
+  let contractAddress: string;
+  const maxHeapContractName = "max-heap";
+  const minHeapContractName = "min-heap";
+
+  before(async () => {
+    await chain.loadAccounts();
+
+    const deployer = chain.accounts.get("deployer")!;
+
+    const maxHeapContractCode = fs.readFileSync(
+      path.join(CONTRACT_FOLDER, `${maxHeapContractName}.clar`),
+      { encoding: "utf8" }
+    );
+
+    await chain.deployContract(maxHeapContractName, maxHeapContractCode, deployer.secretKey);
+
+    const minHeapContractCode = fs.readFileSync(
+      path.join(CONTRACT_FOLDER, `${minHeapContractName}.clar`),
+      { encoding: "utf8" }
+    );
+    const contractId = await chain.deployContract(minHeapContractName, minHeapContractCode, deployer.secretKey);
+
+    contractAddress = contractId.split(".")[0];
+  });
+
+  it("max heap testing", async () => {
+    const deployer = chain.accounts.get("deployer")!;
+    const INDEX_CHUNK_SIZE = 20;
+    const positions_to_open = INDEX_CHUNK_SIZE;
+
+    // initialize contract
+    await chain.callContract(
+      contractAddress,
+      maxHeapContractName,
+      "initialize",
+      [],
+      deployer.secretKey
+    );
+
+    for (let i = 1; i <= positions_to_open; i++) {
+      const position_size = 1;
+      const insertPosition = await chain.callContract(
+        contractAddress,
+        maxHeapContractName,
+        "max-heap-insert",
+        [
+          uintCV(i),
+          uintCV(position_size + i),
+        ],
+        deployer.secretKey
+      );
+
+      expect(insertPosition).to.be.ok;
+    }
+
+    const all_orders_tx = await chain.callContract(
+      contractAddress,
+      maxHeapContractName,
+      "get-orders",
+      [],
+      deployer.secretKey
+    );
+
+    const all_orders = await chain.getTransactionResponse(all_orders_tx.txid);
+
+    all_orders.value.value.forEach(element => {
+      const price = +element.value.price.value;
+      const volume = +element.value.value.value;
+
+      if(price !== 0 && volume !== 0){
+        expect(price + 1).to.be.equal(volume);
+      }
+      else {
+        expect(price).to.be.equal(volume);
+      }
+    });
+  }).timeout(10000000);
+
+
+  it("min heap testing", async () => {
+    const deployer = chain.accounts.get("deployer")!;
+    const INDEX_CHUNK_SIZE = 20;
+    const positions_to_open = INDEX_CHUNK_SIZE;
+
+    // initialize contract
+    await chain.callContract(
+      contractAddress,
+      minHeapContractName,
+      "initialize",
+      [],
+      deployer.secretKey
+    );
+
+    for (let i = 1; i <= positions_to_open; i++) {
+      const position_size = 1;
+      const insertPosition = await chain.callContract(
+        contractAddress,
+        minHeapContractName,
+        "min-heap-insert",
+        [
+          uintCV(i),
+          uintCV(position_size + i),
+        ],
+        deployer.secretKey
+      );
+
+      expect(insertPosition).to.be.ok;
+    }
+
+    const all_orders_tx = await chain.callContract(
+      contractAddress,
+      minHeapContractName,
+      "get-orders",
+      [],
+      deployer.secretKey
+    );
+
+    const all_orders = await chain.getTransactionResponse(all_orders_tx.txid);
+
+    all_orders.value.value.forEach(element => {
+      const price = +element.value.price.value;
+      const volume = +element.value.value.value;
+
+      if(price !== 0 && volume !== 0){
+        expect(price + 1).to.be.equal(volume);
+      }
+      else {
+        expect(price).to.be.equal(volume);
+      }
+    });
+  }).timeout(10000000);
+});

tests/max-heap_test.ts

@@ -58,6 +58,17 @@ function verify_priority_position(
     const position: {[key: string]: string} = read_only_call.result.expectTuple() as any;
 
     position['price'].expectUint(price);
+
+    const get_orders_call = chain.callReadOnlyFn(
+        'max-heap',
+        'get-orders',
+        [],
+        deployer.address
+    );
+
+    const order_list = get_orders_call.result.expectOk().expectList();
+    const order: {[key: string]: string} = order_list[position_index - 1].expectTuple() as any;
+    order['price'].expectUint(price);
 }
 
 function extract_max(chain: Chain, accounts: Map<string, Account>) {

tests/min-heap_test.ts

@@ -58,6 +58,17 @@ function verify_priority_position(
     const position: {[key: string]: string} = read_only_call.result.expectTuple() as any;
 
     position['price'].expectUint(price);
+
+    const get_orders_call = chain.callReadOnlyFn(
+        'min-heap',
+        'get-orders',
+        [],
+        deployer.address
+    );
+
+    const order_list = get_orders_call.result.expectOk().expectList();
+    const order: {[key: string]: string} = order_list[position_index - 1].expectTuple() as any;
+    order['price'].expectUint(price);
 }
 
 function extract_min(chain: Chain, accounts: Map<string, Account>) {