@mainnet-cash/postgresql-storage 3.1.7 → 4.0.0-next.10

package/src/webhook/WebhookBch.ts

@@ -1,192 +0,0 @@
-import SqlProvider from "../SqlProvider.js";
-import { CancelFn, TxI } from "mainnet-js";
-import { ElectrumRawTransaction } from "mainnet-js";
-import { WatchWallet } from "mainnet-js";
-import { Webhook, WebhookRecurrence, WebhookType } from "./Webhook.js";
-import WebhookWorker from "./WebhookWorker.js";
-
-export class WebhookBch extends Webhook {
-  cancel!: CancelFn;
-  wallet!: WatchWallet;
-
-  db!: SqlProvider;
-  seenStatuses: string[] = [];
-
-  constructor(hook: Webhook | Object) {
-    super(hook);
-    Object.assign(this, hook);
-  }
-
-  async stop(): Promise<void> {
-    await this.cancel?.();
-  }
-
-  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 || status === null) {
-          // 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.wallet = await WatchWallet.fromCashaddr(this.cashaddr);
-    this.cancel = await this.wallet.provider!.subscribeToAddress(
-      this.cashaddr,
-      webhookCallback
-    );
-  }
-
-  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
-        );
-        result = await this.post({ sat: balanceSat.toString() });
-      }
-
-      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

@@ -1,94 +0,0 @@
-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

@@ -1,119 +0,0 @@
-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

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

package/src/webhook/interface.ts

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

package/tsconfig.browser.json

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

package/tsconfig.json

@@ -1,32 +0,0 @@
-{
-  "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",
-      "../../node_modules/@types",
-      "./src/types"
-    ]
-  },
-  "include": ["src/**/*.ts"],
-  "exclude": ["node_modules/**", "src/**/*test.ts"],
-  "references": [
-    {
-      "path": "../mainnet-js/"
-    }
-  ],
-  "compileOnSave": false
-}