@mainnet-cash/postgresql-storage 4.0.0-next.0 → 4.0.0-next.11

package/src/index.test.ts

@@ -1,93 +0,0 @@
-import {
-  BaseWallet,
-  binToHex,
-  RegTestWallet,
-  TestNetWallet,
-  Wallet,
-  WalletTypeEnum,
-} 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 private key wallet", async () => {
-  const privkey = "00".repeat(31) + "01";
-
-  let w1 = await Wallet.fromPrivateKey(privkey);
-  expect(w1.network).toBe("mainnet");
-  expect(w1.walletType).toBe(WalletTypeEnum.PrivateKey);
-  expect(w1.toDbString()).toBe(`privkey:mainnet:${privkey}`);
-  expect(w1.toString()).toBe(`privkey:mainnet:${privkey}`);
-
-  let w1Again = await Wallet.fromId(w1.toDbString());
-
-  expect(w1.name).toBe(w1Again.name);
-  expect(w1.network).toBe(w1Again.network);
-  expect(w1.cashaddr).toBe(w1Again.cashaddr);
-  expect(binToHex(w1.privateKey)).toBe(binToHex(w1Again.privateKey));
-  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

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

package/src/util.ts

@@ -1,32 +0,0 @@
-import { base64ToBin, binToUtf8 } from "@bitauth/libauth";
-
-export interface sslConfigI {
-  rejectUnauthorized: boolean;
-  ca?: string;
-  key?: string;
-  cert?: string;
-}
-
-export function getSslConfig(): sslConfigI | undefined {
-  const ca = process.env.DATABASE_SSL_CA
-    ? binToUtf8(base64ToBin(process.env.DATABASE_SSL_CA))
-    : undefined;
-  const key = process.env.DATABASE_SSL_KEY
-    ? binToUtf8(base64ToBin(process.env.DATABASE_SSL_KEY))
-    : undefined;
-  const cert = process.env.DATABASE_SSL_CERT
-    ? binToUtf8(base64ToBin(process.env.DATABASE_SSL_CERT))
-    : 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

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

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

@@ -1,315 +0,0 @@
-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 () => {
-    await 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: 1000n,
-          },
-        ]),
-        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;
-    }
-  }, 20000);
-
-  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: 1000n,
-          },
-        ]),
-        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;
-    }
-  }, 20000);
-
-  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: 1000n,
-          },
-        ]),
-        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;
-    }
-  }, 20000);
-
-  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: 1000n,
-          },
-        ]),
-        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;
-    }
-  }, 20000);
-
-  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: 1000n,
-        },
-      ]);
-
-      // 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: 1000n,
-        },
-      ]);
-      await aliceWallet.send([
-        {
-          cashaddr: bobWallet.cashaddr!,
-          value: 2000n,
-        },
-      ]);
-      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;
-    }
-  }, 30000);
-
-  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: 1000n,
-          },
-        ]),
-        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;
-    }
-  }, 20000);
-});