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

package/src/createWallet.test.ts

@@ -0,0 +1,158 @@
+import { BaseWallet, createWallet, walletFromId } from "mainnet-js";
+import { WalletRequestI } from "mainnet-js";
+import { initProviders, disconnectProviders } from "mainnet-js";
+import { delay } from "mainnet-js";
+import { WalletTypeEnum } from "mainnet-js";
+import { default as SqlProvider } from "./SqlProvider.js";
+
+BaseWallet.StorageProvider = SqlProvider;
+
+beforeAll(async () => {
+  await initProviders();
+});
+afterAll(async () => {
+  await disconnectProviders();
+});
+
+describe(`Named Wallets`, () => {
+  test("Retrieve a named regtest wallet", async () => {
+    const req = {
+      network: "regtest",
+      name: "test",
+    };
+    let w = await createWallet(req);
+    expect(w.cashaddr).toMatch(/bchreg:/);
+    expect(w.name).toBe("test");
+    expect(w.toString()).toBe("named:regtest:test");
+
+    // recover it from the id
+    let w2 = await walletFromId(w.toString());
+    expect(w2.getInfo()).toMatchObject(w.getInfo());
+    expect(w2.name).toBe(w.name);
+
+    let w3 = await createWallet(req);
+    expect(w3.getInfo()).toMatchObject(w.getInfo());
+    expect(w3.name).toBe(w.name);
+  });
+
+  test("Retrieve a named regtest wif wallet", async () => {
+    const req = {
+      network: "regtest",
+      name: "test.wif",
+      type: WalletTypeEnum.Wif,
+    };
+    let w = await createWallet(req);
+    expect(w.cashaddr).toMatch(/bchreg:/);
+    expect(w.name).toBe("test.wif");
+    expect(w.toString()).toBe("named:regtest:test.wif");
+
+    // recover it from id
+    let w2 = await walletFromId(w.toString());
+    expect(w2.getInfo()).toMatchObject(w.getInfo());
+    expect(w2.name).toBe(w.name);
+  });
+
+  test("Get create an unnamed regtest seed wallet", async () => {
+    const req = { network: "regtest" } as WalletRequestI;
+    let w = await createWallet(req);
+    expect(w.cashaddr).toMatch(/bchreg:/);
+    expect(w.walletType).toBe("seed");
+  });
+
+  test("Watch wallet from Id", async () => {
+    const w = await walletFromId(
+      "watch:testnet:qppr9h7whx9pzucgqukhtlj8lvgvjlgr3g9ggtkq22"
+    );
+    expect(w.getInfo()).toStrictEqual({
+      cashaddr: "bchtest:qppr9h7whx9pzucgqukhtlj8lvgvjlgr3g9ggtkq22",
+      tokenaddr: "bchtest:zppr9h7whx9pzucgqukhtlj8lvgvjlgr3gzzm4cx4e",
+      derivationPath: undefined,
+      isTestnet: true,
+      name: "",
+      network: "testnet",
+      parentDerivationPath: undefined,
+      parentXPubKey: undefined,
+      privateKey: undefined,
+      privateKeyWif: undefined,
+      publicKey: undefined,
+      publicKeyHash: "4232dfceb98a117308072d75fe47fb10c97d038a",
+      seed: undefined,
+      walletDbEntry:
+        "watch:testnet:bchtest:qppr9h7whx9pzucgqukhtlj8lvgvjlgr3g9ggtkq22",
+      walletId:
+        "watch:testnet:bchtest:qppr9h7whx9pzucgqukhtlj8lvgvjlgr3g9ggtkq22",
+    });
+  });
+
+  test("Get create a regtest wif wallet", async () => {
+    const req = {
+      network: "regtest",
+      type: "wif",
+      name: "wif2",
+    } as WalletRequestI;
+    let w = await createWallet(req);
+    expect(w.cashaddr).toMatch(/bchreg:/);
+    expect(w.walletType).toBe("wif");
+
+    // recover it from the id
+    let w2 = await walletFromId(w.toString());
+    expect(w2.getInfo()).toMatchObject(w.getInfo());
+    expect(w2.name).toBe(w.name);
+
+    // recover it from the database
+    const req2 = {
+      network: "regtest",
+      type: "wif",
+      name: "wif2",
+    } as WalletRequestI;
+    let w3 = await createWallet(req2);
+    expect(w3.getInfo()).toMatchObject(w.getInfo());
+    expect(w3.name).toBe(w.name);
+  });
+
+  test("Get create a named regtest seed wallet", async () => {
+    const req = {
+      name: "Bob's Regtest Wallet",
+      type: "seed",
+      network: "regtest",
+    } as WalletRequestI;
+    let w = await createWallet(req);
+    expect(w.cashaddr).toMatch(/bchreg:/);
+    expect(w.name).toBe("Bob's Regtest Wallet");
+  });
+
+  test("Get create a unnamed mainnet wallet", async () => {
+    const req = {
+      type: "seed",
+      network: "mainnet",
+    } as WalletRequestI;
+    let w = await createWallet(req);
+    expect(w.cashaddr).toMatch(/bitcoincash:q/);
+    expect(w.walletType).toBe("seed");
+  });
+
+  test("Get create a mainnet wif wallet", async () => {
+    const req = {
+      type: "wif",
+      network: "mainnet",
+    } as WalletRequestI;
+    let w = await createWallet(req);
+    expect(w.cashaddr).toMatch(/bitcoincash:q/);
+    expect(w.walletType).toBe("wif");
+  });
+
+  test("Retrieve a mainnet wif wallet", async () => {
+    const req = {
+      name: "Bob's Testnet Wallet, Again",
+      type: "wif",
+      network: "testnet",
+    } as WalletRequestI;
+    let w = await createWallet(req);
+    expect(w.cashaddr).toMatch(/bchtest:q/);
+    expect(w.walletType).toBe("wif");
+    delay(1000);
+    let w2 = await walletFromId(w.toString());
+    expect(w2.cashaddr).toBe(w.cashaddr);
+    expect(w2.name).toBe(w.name);
+  });
+});

package/src/index.test.ts

@@ -0,0 +1,67 @@
+import { RegTestWallet, TestNetWallet, Wallet, BaseWallet } from "mainnet-js";
+import { default as SqlProvider } from "./SqlProvider";
+
+BaseWallet.StorageProvider = SqlProvider;
+
+/**
+ * @jest-environment jsdom
+ */
+test("Store and retrieve a Regtest wallet", async () => {
+  let w1 = await RegTestWallet.named("Basic Regtest");
+  expect(w1.name).toBe("Basic Regtest");
+  expect(w1.network).toBe("regtest");
+  expect(w1.walletType).toBe("seed");
+  expect(w1.toString()).toBe("named:regtest:Basic Regtest");
+  expect(w1.toDbString()).toMatch(/seed:regtest:(\w+\s){11}\w+/);
+  let w1Again = await RegTestWallet.named("Basic Regtest");
+
+  expect(w1.name).toBe(w1Again.name);
+  expect(w1.network).toBe(w1Again.network);
+  expect(w1.cashaddr).toBe(w1Again.cashaddr);
+  expect(w1.privateKeyWif).toBe(w1Again.privateKeyWif);
+  expect(w1.toString()).toBe(w1Again.toString());
+});
+
+test("Store and retrieve a TestNet wallet", async () => {
+  let w1 = await TestNetWallet.named("Basic Testnet Wallet", "db-test");
+  expect(w1.name).toBe("Basic Testnet Wallet");
+  expect(w1.network).toBe("testnet");
+  expect(w1.walletType).toBe("seed");
+  expect(w1.toDbString()).toMatch(/seed:testnet:(\w+\s){11}\w+/);
+  expect(w1.toString()).toBe("named:testnet:Basic Testnet Wallet");
+  let w1Again = await TestNetWallet.named("Basic Testnet Wallet", "db-test");
+
+  expect(w1.name).toBe(w1Again.name);
+  expect(w1.network).toBe(w1Again.network);
+  expect(w1.cashaddr).toBe(w1Again.cashaddr);
+  expect(w1.privateKeyWif).toBe(w1Again.privateKeyWif);
+  expect(w1.toString()).toBe(w1Again.toString());
+});
+
+test("Store and retrieve a seed wallet", async () => {
+  let w1 = await Wallet.named("Seed Wallet", "db-test");
+  expect(w1.name).toBe("Seed Wallet");
+  expect(w1.network).toBe("mainnet");
+  expect(w1.walletType).toBe("seed");
+  expect(w1.toDbString()).toMatch(/seed:mainnet:(\w+\s){11}\w+/);
+  expect(w1.toString()).toBe("named:mainnet:Seed Wallet");
+  let w1Again = await Wallet.named("Seed Wallet", "db-test");
+
+  expect(w1.name).toBe(w1Again.name);
+  expect(w1.network).toBe(w1Again.network);
+  expect(w1.cashaddr).toBe(w1Again.cashaddr);
+  expect(w1.privateKeyWif).toBe(w1Again.privateKeyWif);
+  expect(w1.toString()).toBe(w1Again.toString());
+});
+
+test("Expect Error passing mainnet wallet to error", async () => {
+  expect.assertions(1);
+  try {
+    process.env.ALLOW_MAINNET_USER_WALLETS = "false";
+    await Wallet.named("Seed Wallet", "db-test");
+  } catch (e: any) {
+    expect(e.message).toBe(
+      'Refusing to save wallet in an open public database, remove ALLOW_MAINNET_USER_WALLETS="false", if this service is secure and private'
+    );
+  }
+});

package/src/index.ts

@@ -0,0 +1,2 @@
+export { default as SqlProvider } from "./SqlProvider.js";
+export * from "./webhook/index.js";

package/src/util.ts

@@ -0,0 +1,30 @@
+export interface sslConfigI {
+  rejectUnauthorized: boolean;
+  ca?: string;
+  key?: string;
+  cert?: string;
+}
+
+export function getSslConfig(): sslConfigI | undefined {
+  const ca = process.env.DATABASE_SSL_CA
+    ? Buffer.from(process.env.DATABASE_SSL_CA, "base64").toString("ascii")
+    : undefined;
+  const key = process.env.DATABASE_SSL_KEY
+    ? Buffer.from(process.env.DATABASE_SSL_KEY, "base64").toString("ascii")
+    : undefined;
+  const cert = process.env.DATABASE_SSL_CERT
+    ? Buffer.from(process.env.DATABASE_SSL_CERT, "base64").toString("ascii")
+    : undefined;
+  let ssl: sslConfigI = {
+    rejectUnauthorized:
+      process.env.DATABASE_SSL_REJECT_UNAUTHORIZED == "false" ? false : true,
+    ca: ca,
+    key: key,
+    cert: cert,
+  };
+  if (ssl.ca || ssl.cert || ssl.key) {
+    return ssl;
+  } else {
+    return;
+  }
+}

package/src/webhook/Webhook.test.ts

@@ -0,0 +1,9 @@
+import { Webhook } from "./Webhook";
+
+describe("Webhook worker tests", () => {
+  test("Test creating hook", async () => {
+    const hook = new Webhook({ cashaddr: "asdf" });
+    expect(hook.cashaddr).toBe("asdf");
+    expect(hook.type).toBe(undefined);
+  });
+});

package/src/webhook/Webhook.ts

@@ -0,0 +1,99 @@
+import SqlProvider from "../SqlProvider.js";
+import { TxI } from "mainnet-js";
+
+import axios from "axios";
+
+export enum WebhookType {
+  transactionIn = "transaction:in",
+  transactionOut = "transaction:out",
+  transactionInOut = "transaction:in,out",
+  balance = "balance",
+}
+
+export enum WebhookRecurrence {
+  once = "once",
+  recurrent = "recurrent",
+}
+
+export class Webhook {
+  id?: number;
+  cashaddr!: string;
+  type!: string;
+  recurrence!: string;
+  url!: string;
+  status!: string;
+  last_height!: number;
+  tx_seen!: TxI[];
+  expires_at!: Date;
+
+  db!: SqlProvider;
+
+  constructor(hook: Webhook | Object) {
+    Object.assign(this, hook);
+  }
+
+  // abstract, empty implementation
+  async start(): Promise<void> {}
+
+  // abstract, empty implementation
+  async stop(): Promise<void> {}
+
+  async destroy(): Promise<void> {
+    if (this.id) {
+      await this.db.deleteWebhook(this.id);
+    }
+  }
+
+  async post(data: any): Promise<boolean> {
+    try {
+      await axios.post(this.url, data);
+      // console.debug("Posted webhook", this.url, data);
+      return true;
+    } catch (e: any) {
+      if (e.message && e.message.status === 200) {
+        return true;
+      }
+
+      // console.debug("Failed to post webhook", this.url, e);
+      return false;
+    }
+  }
+
+  //#region debug
+  public static debug = class {
+    static setupAxiosMocks() {
+      axios.interceptors.request.use((config) => {
+        const url = config.url!;
+        if (!url.startsWith("http://example.com")) {
+          return config;
+        }
+
+        let response;
+        if (url === "http://example.com/fail") {
+          response = { status: 503 };
+        } else {
+          response = { status: 200 };
+        }
+
+        if (url in this.responses) {
+          this.responses[url].push(response);
+        } else {
+          this.responses[url] = [response];
+        }
+
+        // cancel actual http request
+        return {
+          ...config,
+          cancelToken: new axios.CancelToken((cancel) => cancel(response)),
+        };
+      });
+    }
+
+    static reset() {
+      this.responses = {};
+    }
+
+    static responses: any = {};
+  };
+  //#endregion
+}

package/src/webhook/WebhookBch.test.ts

@@ -0,0 +1,323 @@
+import WebhookWorker from "../webhook/WebhookWorker";
+import { RegTestWallet } from "mainnet-js";
+import { mine } from "mainnet-js";
+import { Webhook, WebhookRecurrence, WebhookType } 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 non-recurrent hook to be deleted after successful call", async () => {
+    try {
+      const aliceWallet = await RegTestWallet.fromId(aliceWif);
+      const bobWallet = await RegTestWallet.newRandom();
+      await worker.registerWebhook({
+        cashaddr: bobWallet.cashaddr!,
+        url: "http://example.com/success",
+        type: WebhookType.transactionIn,
+        recurrence: WebhookRecurrence.once,
+      });
+
+      await Promise.all([
+        aliceWallet.send([
+          {
+            cashaddr: bobWallet.cashaddr!,
+            value: 1000,
+            unit: "satoshis",
+          },
+        ]),
+        bobWallet.waitForTransaction(),
+      ]);
+
+      // return funds
+      // let sendResponse2 = await bobWallet.sendMax(aliceWallet.cashaddr!);
+
+      await new Promise((resolve) =>
+        setTimeout(async () => {
+          expect(
+            Webhook.debug.responses["http://example.com/success"].length
+          ).toBe(1);
+          expect(worker.activeHooks.size).toBe(0);
+
+          resolve(true);
+        }, 3000)
+      );
+    } catch (e: any) {
+      console.log(e, e.stack, e.message);
+      throw e;
+    }
+  });
+
+  test("Test non-recurrent hook to be not deleted after failed call", async () => {
+    try {
+      const aliceWallet = await RegTestWallet.fromId(aliceWif);
+      const bobWallet = await RegTestWallet.newRandom();
+      await worker.registerWebhook({
+        cashaddr: bobWallet.cashaddr!,
+        url: "http://example.com/fail",
+        type: WebhookType.transactionIn,
+        recurrence: WebhookRecurrence.once,
+      });
+
+      await Promise.all([
+        aliceWallet.send([
+          {
+            cashaddr: bobWallet.cashaddr!,
+            value: 1000,
+            unit: "satoshis",
+          },
+        ]),
+        bobWallet.waitForTransaction(),
+      ]);
+
+      await new Promise((resolve) =>
+        setTimeout(async () => {
+          expect(
+            Webhook.debug.responses["http://example.com/fail"].length
+          ).toBe(1);
+          expect(worker.activeHooks.size).toBe(1);
+
+          // return funds
+          // let sendResponse2 = await bobWallet.sendMax(aliceWallet.cashaddr!);
+          resolve(true);
+        }, 3000)
+      );
+    } catch (e: any) {
+      console.log(e, e.stack, e.message);
+      throw e;
+    }
+  });
+
+  test("Test recurrent hook for incoming transaction", async () => {
+    try {
+      const aliceWallet = await RegTestWallet.fromId(aliceWif);
+      const bobWallet = await RegTestWallet.newRandom();
+      await worker.registerWebhook({
+        cashaddr: bobWallet.cashaddr!,
+        url: "http://example.com/bob",
+        type: WebhookType.transactionIn,
+        recurrence: WebhookRecurrence.recurrent,
+      });
+
+      await Promise.all([
+        aliceWallet.send([
+          {
+            cashaddr: bobWallet.cashaddr!,
+            value: 1000,
+            unit: "satoshis",
+          },
+        ]),
+        bobWallet.waitForTransaction(),
+      ]);
+
+      // return funds
+      // let sendResponse2 = await bobWallet.sendMax(aliceWallet.cashaddr!);
+
+      await new Promise((resolve) =>
+        setTimeout(async () => {
+          expect(Webhook.debug.responses["http://example.com/bob"].length).toBe(
+            1
+          );
+          expect(worker.activeHooks.size).toBe(1);
+
+          resolve(true);
+        }, 3000)
+      );
+    } catch (e: any) {
+      console.log(e, e.stack, e.message);
+      throw e;
+    }
+  });
+
+  test("Test recurrent hook for outgoing transactions", async () => {
+    try {
+      const aliceWallet = await RegTestWallet.fromId(aliceWif);
+      const bobWallet = await RegTestWallet.newRandom();
+      await worker.registerWebhook({
+        cashaddr: bobWallet.cashaddr!,
+        url: "http://example.com/bob",
+        type: WebhookType.transactionOut,
+        recurrence: WebhookRecurrence.recurrent,
+      });
+
+      await Promise.all([
+        aliceWallet.send([
+          {
+            cashaddr: bobWallet.cashaddr!,
+            value: 1000,
+            unit: "satoshis",
+          },
+        ]),
+        bobWallet.waitForTransaction(),
+      ]);
+
+      // return funds
+      await Promise.all([
+        bobWallet.sendMax(aliceWallet.cashaddr!),
+        aliceWallet.waitForTransaction(),
+      ]);
+
+      await new Promise((resolve) =>
+        setTimeout(async () => {
+          expect(Webhook.debug.responses["http://example.com/bob"].length).toBe(
+            1
+          );
+          expect(worker.activeHooks.size).toBe(1);
+
+          resolve(true);
+        }, 3000)
+      );
+    } catch (e: any) {
+      console.log(e, e.stack, e.message);
+      throw e;
+    }
+  });
+
+  test("Test should pickup transactions happened while offline", async () => {
+    try {
+      const aliceWallet = await RegTestWallet.fromId(aliceWif);
+      const bobWallet = await RegTestWallet.newRandom();
+      const minerWallet = await RegTestWallet.newRandom();
+      const hookId = await worker.registerWebhook({
+        cashaddr: bobWallet.cashaddr!,
+        url: "http://example.com/bob",
+        type: WebhookType.transactionIn,
+        recurrence: WebhookRecurrence.recurrent,
+      });
+
+      // initial transaction
+      await aliceWallet.send([
+        {
+          cashaddr: bobWallet.cashaddr!,
+          value: 1000,
+          unit: "satoshis",
+        },
+      ]);
+
+      // wait worker to process, updating the status of the hook
+      await new Promise((resolve) => setTimeout(resolve, 5000));
+
+      let hook = await worker.getWebhook(hookId);
+      expect(hook!.status).not.toBe("");
+      expect(hook!.tx_seen).not.toBe([]);
+      hook!.tx_seen[0];
+      expect(Webhook.debug.responses["http://example.com/bob"].length).toBe(1);
+
+      // shutdown
+      await worker.destroy();
+      expect(worker.activeHooks.size).toBe(0);
+
+      // also mine a block while offline)
+      await mine({ cashaddr: minerWallet.cashaddr!, blocks: 1 });
+
+      // make two more transactions "offline"
+      await aliceWallet.send([
+        {
+          cashaddr: bobWallet.cashaddr!,
+          value: 1000,
+          unit: "satoshis",
+        },
+      ]);
+      await aliceWallet.send([
+        {
+          cashaddr: bobWallet.cashaddr!,
+          value: 2000,
+          unit: "satoshis",
+        },
+      ]);
+      await mine({ cashaddr: minerWallet.cashaddr!, blocks: 1 });
+      await new Promise((resolve) => setTimeout(resolve, 5000));
+
+      // wait worker to process the transactions occured while offline
+      await worker.init();
+
+      await new Promise((resolve) =>
+        setTimeout(async () => {
+          expect(worker.activeHooks.size).toBe(1);
+          expect(Webhook.debug.responses["http://example.com/bob"].length).toBe(
+            3
+          );
+
+          resolve(true);
+        }, 10000)
+      );
+    } catch (e: any) {
+      console.log(e, e.stack, e.message);
+      throw e;
+    }
+  });
+
+  test("Test non-recurrent watch balance hook", async () => {
+    try {
+      const aliceWallet = await RegTestWallet.fromId(aliceWif);
+      const bobWallet = await RegTestWallet.newRandom();
+      await worker.registerWebhook({
+        cashaddr: bobWallet.cashaddr!,
+        url: "http://example.com/watchBalance",
+        type: WebhookType.balance,
+        recurrence: WebhookRecurrence.once,
+      });
+
+      await Promise.all([
+        aliceWallet.send([
+          {
+            cashaddr: bobWallet.cashaddr!,
+            value: 1000,
+            unit: "satoshis",
+          },
+        ]),
+        bobWallet.waitForTransaction(),
+      ]);
+
+      // return funds
+      // let sendResponse2 = await bobWallet.sendMax(aliceWallet.cashaddr!);
+
+      await new Promise((resolve) =>
+        setTimeout(async () => {
+          expect(
+            Webhook.debug.responses["http://example.com/watchBalance"].length
+          ).toBe(1);
+          expect(worker.activeHooks.size).toBe(0);
+
+          resolve(true);
+        }, 3000)
+      );
+    } catch (e: any) {
+      console.log(e, e.stack, e.message);
+      throw e;
+    }
+  });
+});