@mainnet-cash/postgresql-storage 2.1.0-alpha.5

package/src/webhook/WebhookBch.ts

@@ -0,0 +1,198 @@
+import SqlProvider from "../SqlProvider.js";
+import { TxI } from "mainnet-js";
+import { ElectrumRawTransaction } from "mainnet-js";
+import { balanceResponseFromSatoshi } from "mainnet-js";
+import { Wallet } from "mainnet-js";
+import { Webhook, WebhookRecurrence, WebhookType } from "./Webhook.js";
+import WebhookWorker from "./WebhookWorker.js";
+
+export class WebhookBch extends Webhook {
+  callback!: (data: any | string | Array<string>) => void;
+  wallet!: Wallet;
+
+  db!: SqlProvider;
+  seenStatuses: string[] = [];
+
+  constructor(hook: Webhook | Object) {
+    super(hook);
+    Object.assign(this, hook);
+  }
+
+  async stop(): Promise<void> {
+    await this.wallet.provider!.unsubscribeFromAddress(
+      this.cashaddr,
+      this.callback
+    );
+  }
+
+  async start(): Promise<void> {
+    const webhookCallback = async (data: string | Array<string>) => {
+      let status: string = "";
+      if (typeof data === "string") {
+        // subscription acknowledgement notification with current status
+        status = data;
+
+        // we should skip fetching transactions for freshly registered hooks upon acknowledements
+        if (this.status === "") {
+          return;
+        }
+      } else if (data instanceof Array) {
+        status = data[1];
+        if (data[0] !== this.cashaddr) {
+          // console.warn("Address missmatch, skipping", data[0], this.cashaddr);
+          return;
+        }
+      } else {
+        return;
+      }
+
+      if (status != this.status && this.seenStatuses.indexOf(status) === -1) {
+        this.seenStatuses.push(status);
+        await this.handler(status);
+      }
+    };
+
+    this.callback = webhookCallback;
+    this.wallet = await Wallet.fromCashaddr(this.cashaddr);
+    await this.wallet.provider!.subscribeToAddress(
+      this.cashaddr,
+      this.callback
+    );
+  }
+
+  async handler(status: string): Promise<void> {
+    // console.debug("Dispatching action for a webhook", this);
+    // get transactions
+    const history: TxI[] = await this.wallet.provider!.getHistory(
+      this.cashaddr
+    );
+
+    // figure out which transactions to send to the hook
+    let txs: TxI[] = [];
+
+    if (status === "") {
+      // send the last transaction only if no tracking was done
+      txs = history.slice(-1);
+    } else {
+      // reverse history for faster search
+      const revHistory = history.reverse();
+      // update height of transactions, which are now confirmed
+      this.tx_seen = this.tx_seen.map((seenTx) => {
+        if (seenTx.height <= 0) {
+          const histTx = revHistory.find(
+            (val) => val.tx_hash === seenTx.tx_hash
+          );
+          if (histTx) {
+            seenTx.height = histTx.height;
+          }
+        }
+        return seenTx;
+      });
+
+      const seenHashes = this.tx_seen.map((val) => val.tx_hash);
+      txs = history.filter(
+        (val) =>
+          (val.height >= this.last_height || val.height <= 0) &&
+          !seenHashes.includes(val.tx_hash)
+      );
+    }
+
+    let shouldUpdateStatus: boolean = true;
+
+    for (const tx of txs) {
+      // watching transactions
+      let result: boolean = false;
+
+      if (this.type.indexOf("transaction:") >= 0) {
+        // console.debug("Getting raw tx", tx.tx_hash);
+        const rawTx: ElectrumRawTransaction =
+          await this.wallet.provider!.getRawTransactionObject(tx.tx_hash);
+        const parentTxs: ElectrumRawTransaction[] = await Promise.all(
+          rawTx.vin.map((t) =>
+            this.wallet.provider!.getRawTransactionObject(t.txid)
+          )
+        );
+        // console.debug("Got raw tx", JSON.stringify(rawTx, null, 2));
+        const haveAddressInOutputs: boolean = rawTx.vout.some((val) =>
+          val.scriptPubKey.addresses.includes(this.cashaddr)
+        );
+        const haveAddressInParentOutputs: boolean = parentTxs.some((parent) =>
+          parent.vout.some((val) =>
+            val.scriptPubKey.addresses.includes(this.cashaddr)
+          )
+        );
+
+        const wantsIn: boolean = this.type.indexOf("in") >= 0;
+        const wantsOut: boolean = this.type.indexOf("out") >= 0;
+
+        const txDirection: string =
+          haveAddressInParentOutputs && haveAddressInOutputs
+            ? WebhookType.transactionInOut
+            : haveAddressInParentOutputs
+            ? WebhookType.transactionOut
+            : WebhookType.transactionIn;
+
+        if (wantsIn && haveAddressInOutputs) {
+          result = await this.post({
+            direction: txDirection,
+            data: rawTx,
+          });
+        } else if (wantsOut && haveAddressInParentOutputs) {
+          result = await this.post({
+            direction: txDirection,
+            data: rawTx,
+          });
+        } else {
+          // not interested in this transaction
+          continue;
+        }
+      } else if (this.type === WebhookType.balance) {
+        // watching address balance
+        const balanceSat = await this.wallet.provider!.getBalance(
+          this.cashaddr
+        );
+        const balanceObject = await balanceResponseFromSatoshi(balanceSat);
+        result = await this.post(balanceObject);
+      }
+
+      if (result) {
+        this.tx_seen.push(tx);
+        await this.db.setWebhookSeenTxLastHeight(
+          this.id!,
+          this.tx_seen,
+          this.last_height
+        );
+      } else {
+        // console.debug("Failed to execute webhook", hook);
+        shouldUpdateStatus = false;
+      }
+    }
+
+    // successful run
+    if (shouldUpdateStatus) {
+      if (this.recurrence === WebhookRecurrence.once) {
+        // we have to notify the worker about end of life
+        await (await WebhookWorker.instance()).stopHook(this);
+        await this.destroy();
+        return;
+      }
+
+      this.status = status;
+      await this.db.setWebhookStatus(this.id!, status);
+
+      // update last_height and truncate tx_seen
+      const maxHeight = Math.max(...this.tx_seen.map((val) => val.height));
+      if (maxHeight >= this.last_height) {
+        this.last_height = maxHeight;
+        this.tx_seen = this.tx_seen.filter(
+          (val) => val.height === maxHeight || val.height <= 0
+        );
+        await this.db.setWebhookSeenTxLastHeight(
+          this.id!,
+          this.tx_seen,
+          this.last_height
+        );
+      }
+    }
+  }
+}

package/src/webhook/WebhookWorker.test.ts

@@ -0,0 +1,94 @@
+import WebhookWorker from "../webhook/WebhookWorker";
+import { Webhook } from "./Webhook";
+
+let worker: WebhookWorker;
+let alice = "";
+let aliceWif = "";
+
+/**
+ * @jest-environment jsdom
+ */
+
+describe("Webhook worker tests", () => {
+  beforeAll(async () => {
+    try {
+      if (process.env.PRIVATE_WIF) {
+        alice = process.env.ADDRESS!;
+        aliceWif = `wif:regtest:${process.env.PRIVATE_WIF!}`;
+      } else {
+        console.error("regtest env vars not set");
+      }
+
+      Webhook.debug.setupAxiosMocks();
+      worker = await WebhookWorker.instance();
+    } catch (e: any) {
+      throw e;
+    }
+  });
+
+  beforeEach(async () => {
+    worker.deleteAllWebhooks();
+  });
+
+  afterEach(async () => {
+    Webhook.debug.reset();
+  });
+
+  afterAll(async () => {
+    await worker.destroy();
+    await worker.db.close();
+  });
+
+  test("Test posting hook", async () => {
+    const hook1 = new Webhook({ url: "http://example.com/pass" });
+    let success = await hook1.post({});
+    expect(success).toBe(true);
+
+    const hook2 = new Webhook({ url: "http://example.com/fail" });
+    let fail = await hook2.post({});
+    expect(fail).toBe(false);
+
+    expect(Webhook.debug.responses["http://example.com/pass"].length).toBe(1);
+
+    expect(Webhook.debug.responses["http://example.com/fail"].length).toBe(1);
+  });
+
+  test("Test empty hook db", async () => {
+    try {
+      await new Promise((resolve) =>
+        setTimeout(async () => {
+          expect(worker.activeHooks.size).toBe(0);
+          expect(Webhook.debug.responses).toStrictEqual({});
+          resolve(true);
+        }, 0)
+      );
+    } catch (e: any) {
+      console.log(e, e.stack, e.message);
+      throw e;
+    }
+  });
+
+  test("Test starting with expired hook", async () => {
+    await worker.registerWebhook(
+      {
+        cashaddr: alice,
+        url: "http://example.com/pass",
+        type: "transaction:in",
+        recurrence: "once",
+        duration_sec: -1000,
+      },
+      false
+    );
+
+    await worker.init();
+
+    try {
+      expect(worker.activeHooks.size).toBe(0);
+      expect((await worker.db.getWebhooks()).length).toBe(0);
+      expect(Webhook.debug.responses).toStrictEqual({});
+    } catch (e: any) {
+      console.log(e, e.stack, e.message);
+      throw e;
+    }
+  });
+});

package/src/webhook/WebhookWorker.ts

@@ -0,0 +1,119 @@
+import SqlProvider from "../SqlProvider.js";
+import { RegisterWebhookParams } from "./interface.js";
+
+import { Webhook } from "./Webhook";
+
+export default class WebhookWorker {
+  activeHooks: Map<number, Webhook> = new Map();
+  callbacks: Map<number, (data: any | string | Array<string>) => void> =
+    new Map();
+  db: SqlProvider;
+  checkInterval: any = undefined;
+
+  private static _instance: WebhookWorker;
+
+  static async instance() {
+    if (!WebhookWorker._instance) {
+      WebhookWorker._instance = new WebhookWorker();
+      await WebhookWorker._instance.init();
+    }
+
+    return WebhookWorker._instance;
+  }
+
+  constructor() {
+    this.db = new SqlProvider();
+  }
+
+  async init(): Promise<void> {
+    await this.db.init();
+
+    await this.evictOldHooks();
+    await this.pickupHooks(true);
+    if (!this.checkInterval) {
+      this.checkInterval = setInterval(async () => {
+        await this.evictOldHooks();
+        await this.pickupHooks(true);
+      }, 5 * 60 * 1000);
+    }
+  }
+
+  async destroy(): Promise<void> {
+    await this.stopAll();
+    if (this.checkInterval) {
+      clearInterval(this.checkInterval);
+      this.checkInterval = undefined;
+    }
+  }
+
+  async pickupHooks(start: boolean = false): Promise<void> {
+    const hooks: Webhook[] = await this.db.getWebhooks();
+    for (const hook of hooks) {
+      if (!this.activeHooks.has(hook.id!)) {
+        this.activeHooks.set(hook.id!, hook);
+        if (start) {
+          await hook.start();
+        }
+      }
+    }
+  }
+
+  async evictOldHooks(): Promise<void> {
+    const now = new Date();
+    const dbHooks = await this.db.getWebhooks();
+    for (const hook of dbHooks) {
+      if (now >= hook.expires_at) {
+        // console.debug("Evicting expired hook with id", hook.id, new Date(), hook.expires_at);
+        if (this.activeHooks.has(hook.id!)) {
+          await this.stopHook(hook);
+        }
+        await this.db.deleteWebhook(hook.id!);
+      }
+    }
+  }
+
+  async registerWebhook(
+    params: RegisterWebhookParams,
+    start: boolean = true
+  ): Promise<number> {
+    const webhook = await this.db.addWebhook(params);
+    if (start) {
+      this.activeHooks.set(webhook.id!, webhook);
+      await webhook.start();
+    }
+    return webhook.id!;
+  }
+
+  async getWebhook(id: number): Promise<Webhook | undefined> {
+    if (this.activeHooks.has(id)) {
+      return this.activeHooks.get(id)!;
+    }
+
+    return await this.db.getWebhook(id);
+  }
+
+  async deleteWebhook(id: number): Promise<void> {
+    if (this.activeHooks.has(id)) {
+      await this.stopHook(this.activeHooks.get(id)!);
+    }
+    await this.db.deleteWebhook(id);
+  }
+
+  async deleteAllWebhooks(): Promise<void> {
+    await this.stopAll();
+    await this.db.clearWebhooks();
+  }
+
+  async stopAll(): Promise<void> {
+    for (const [, hook] of this.activeHooks) {
+      await this.stopHook(hook);
+    }
+  }
+
+  async stopHook(hook: Webhook): Promise<void> {
+    if (this.activeHooks.has(hook.id!)) {
+      await hook.stop();
+      this.activeHooks.delete(hook.id!);
+    }
+  }
+}

package/src/webhook/index.ts

@@ -0,0 +1,4 @@
+export { default as WebhookWorker } from "./WebhookWorker.js";
+export * from "./Webhook.js";
+export * from "./WebhookBch.js";
+export * from "./interface.js";

package/src/webhook/interface.ts

@@ -0,0 +1,7 @@
+export interface RegisterWebhookParams {
+  cashaddr: string;
+  url: string;
+  type: string;
+  recurrence: string;
+  duration_sec?: number;
+}

package/tsconfig.browser.json

@@ -0,0 +1,6 @@
+{
+  "extends": "./tsconfig",
+  "compilerOptions": {},
+  "include": ["src/**/*.ts"],
+  "exclude": ["node_modules/**", "dist/**", "src/**/*test.ts"]
+}

package/tsconfig.json

@@ -0,0 +1,28 @@
+{
+  "extends": "../../tsconfig.json",
+  "compilerOptions": {
+    "rootDir": "src",
+    "skipLibCheck": true,
+    "esModuleInterop": true,
+    "allowSyntheticDefaultImports": true,
+    "strict": true,
+    "forceConsistentCasingInFileNames": true,
+    "downlevelIteration": true,
+    "composite": true,
+    "module": "esnext",
+    "target": "esnext",
+    "outDir": "./dist/module",
+    "moduleResolution": "node",
+    "resolveJsonModule": true,
+    "lib": ["es2020", "es2020.bigint", "dom"],
+    "typeRoots": ["node_modules/@types", "./src/types"]
+  },
+  "include": ["src/**/*.ts"],
+  "exclude": ["node_modules/**", "src/**/*test.ts"],
+  "references": [
+    {
+      "path": "../mainnet-js/"
+    }
+  ],
+  "compileOnSave": false
+}