@across-protocol/sdk 4.3.56 → 4.3.57

package/src/pool/uma/oracle/utils.ts

@@ -0,0 +1,38 @@
+import { BigNumberish } from "../../../utils";
+import sortedLastIndexBy from "lodash/sortedLastIndexBy";
+
+/**
+ * eventKey. Make a unique and sortable identifier string for an event
+ * Used by poolClient.ts lines 166, 246
+ *
+ * @param {Event} event
+ * @returns {string} - the unique id
+ */
+export function eventKey(event: {
+  blockNumber: BigNumberish;
+  transactionIndex: BigNumberish;
+  logIndex: BigNumberish;
+}): string {
+  return [
+    // we pad these because numbers of varying lengths will not sort correctly, ie "10" will incorrectly sort before "9", but "09" will be correct.
+    event.blockNumber.toString().padStart(16, "0"),
+    event.transactionIndex.toString().padStart(16, "0"),
+    event.logIndex?.toString().padStart(16, "0"),
+    // ~ is the last printable ascii char, so it does not interfere with sorting
+  ].join("~");
+}
+
+/**
+ * insertOrdered. Inserts items in an array maintaining sorted order, in this case lowest to highest. Does not check duplicates.
+ * Mainly used for caching all known events, in order of oldest to newest.
+ * Used by poolClient.ts line 181
+ *
+ * @param {T[]} array
+ * @param {T} element
+ * @param {Function} orderBy
+ */
+export function insertOrderedAscending<T>(array: T[], element: T, orderBy: (element: T) => string | number): T[] {
+  const index = sortedLastIndexBy(array, element, orderBy);
+  array.splice(index, 0, element);
+  return array;
+}

package/src/pool/uma/utils.test.ts

@@ -0,0 +1,24 @@
+import * as utils from "./utils";
+import assert from "assert";
+test("Balances", function () {
+  const balances = utils.Balances();
+  assert.ok(balances);
+  balances.create("a", "100");
+  balances.create("b", "99");
+  let result = balances.get("a");
+  assert.equal(result, "100");
+  result = balances.get("b");
+  assert.equal(result, "99");
+
+  result = balances.sub("a", 1);
+  assert.equal(result, "99");
+
+  result = balances.sub("b", 1);
+  assert.equal(result, "98");
+
+  result = balances.add("b", 2);
+  assert.equal(result, "100");
+
+  const bals = balances.balances;
+  assert.equal(Object.keys(bals).length, 2);
+});

package/src/pool/uma/utils.ts

@@ -0,0 +1,53 @@
+import assert from "assert";
+import { BigNumber, BigNumberish, delay as sleep } from "../../utils";
+
+export { delay as sleep } from "../../utils";
+
+// check if a value is not null or undefined, useful for numbers which could be 0.
+// "is" syntax: https://stackoverflow.com/questions/40081332/what-does-the-is-keyword-do-in-typescript
+/* eslint-disable-next-line @typescript-eslint/ban-types */
+export function exists<T>(value: T | null | undefined): value is NonNullable<T> {
+  return value !== null && value !== undefined;
+}
+
+// useful for maintaining balances from events
+export type Balances = { [key: string]: string };
+export function Balances(balances: Balances = {}) {
+  function create(id: string, amount = "0") {
+    assert(!has(id), "balance already exists");
+    return set(id, amount);
+  }
+  function has(id: string) {
+    return exists(balances[id]);
+  }
+  function set(id: string, amount: string) {
+    balances[id] = amount;
+    return amount;
+  }
+  function add(id: string, amount: BigNumberish) {
+    return set(id, BigNumber.from(amount).add(getOrCreate(id)).toString());
+  }
+  function sub(id: string, amount: BigNumberish) {
+    return set(id, BigNumber.from(getOrCreate(id)).sub(amount).toString());
+  }
+  function get(id: string) {
+    assert(has(id), "balance does not exist");
+    return balances[id];
+  }
+  function getOrCreate(id: string) {
+    if (has(id)) return get(id);
+    return create(id);
+  }
+  return { create, add, sub, get, balances, set, has, getOrCreate };
+}
+
+// Loop forever but wait until execution is finished before starting next timer. Throw an error to break this
+// or add another utlity function if you need it to end on condition.
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+export async function loop(fn: (...args: any[]) => any, delay: number, ...args: any[]) {
+  do {
+    await fn(...args);
+    await sleep(delay);
+    /* eslint-disable-next-line no-constant-condition */
+  } while (true);
+}