mainnet-js 1.1.34 → 2.0.1

package/src/webhook/WebhookSlp.test.ts

@@ -1,288 +0,0 @@
-import WebhookWorker from "./WebhookWorker";
-import { RegTestWallet } from "../wallet/Wif";
-import { mine } from "../mine/mine";
-import { Webhook, WebhookRecurrence, WebhookType } from "./Webhook";
-import { GsppProvider, SlpDbProvider, SlpGenesisOptions } from "../slp";
-
-let worker: WebhookWorker;
-let alice;
-let aliceWif;
-let tokenId;
-
-const serversSlpDb = { ...{}, ...SlpDbProvider.defaultServers };
-const serversGspp = { ...{}, ...GsppProvider.defaultServers };
-
-/**
- * @jest-environment jsdom
- */
-describe.skip("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();
-
-      const genesisOptions: SlpGenesisOptions = {
-        name: "Webhook Token",
-        ticker: "WHT",
-        decimals: 2,
-        initialAmount: 10000,
-        documentUrl: "https://mainnet.cash",
-        documentHash:
-          "0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef",
-      };
-
-      const aliceWallet = await RegTestWallet.slp.fromId(aliceWif);
-      const genesisResult = await aliceWallet.slp.genesis(genesisOptions);
-      tokenId = genesisResult.tokenId;
-
-      SlpDbProvider.defaultServers.testnet =
-        SlpDbProvider.defaultServers.regtest;
-      GsppProvider.defaultServers.testnet = GsppProvider.defaultServers.regtest;
-    } catch (e: any) {
-      throw e;
-    }
-  });
-
-  beforeEach(async () => {
-    worker.deleteAllWebhooks();
-  });
-
-  afterEach(async () => {
-    Webhook.debug.reset();
-  });
-
-  afterAll(async () => {
-    await worker.destroy();
-    await worker.db.close();
-
-    SlpDbProvider.defaultServers = serversSlpDb;
-    GsppProvider.defaultServers = serversGspp;
-  });
-
-  test("Test non-recurrent hook to be deleted after successful call", async () => {
-    try {
-      const aliceWallet = await RegTestWallet.slp.fromId(aliceWif);
-      const bobWallet = await RegTestWallet.slp.newRandom();
-      await worker.registerWebhook({
-        cashaddr: bobWallet.slp.slpaddr,
-        url: "http://example.com/success",
-        type: WebhookType.slpTransactionIn,
-        recurrence: WebhookRecurrence.once,
-        tokenId: tokenId,
-      });
-
-      await Promise.all([
-        aliceWallet.slp.send([
-          {
-            slpaddr: bobWallet.slp.slpaddr,
-            value: 1000,
-            tokenId: tokenId,
-          },
-        ]),
-        bobWallet.slp.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.slp.fromId(aliceWif);
-      const bobWallet = await RegTestWallet.slp.newRandom();
-      await worker.registerWebhook({
-        cashaddr: bobWallet.slp.slpaddr,
-        url: "http://example.com/fail",
-        type: WebhookType.slpTransactionIn,
-        recurrence: WebhookRecurrence.once,
-        tokenId: tokenId,
-      });
-
-      await Promise.all([
-        aliceWallet.slp.send([
-          {
-            slpaddr: bobWallet.slp.slpaddr,
-            value: 1000,
-            tokenId: tokenId,
-          },
-        ]),
-        bobWallet.slp.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.slp.fromId(aliceWif);
-      const bobWallet = await RegTestWallet.slp.newRandom();
-      await worker.registerWebhook({
-        cashaddr: bobWallet.slp.slpaddr,
-        url: "http://example.com/bob",
-        type: WebhookType.slpTransactionIn,
-        recurrence: WebhookRecurrence.recurrent,
-        tokenId: tokenId,
-      });
-
-      await Promise.all([
-        aliceWallet.slp.send([
-          {
-            slpaddr: bobWallet.slp.slpaddr,
-            value: 1000,
-            tokenId: tokenId,
-          },
-        ]),
-        bobWallet.slp.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.slp.fromId(aliceWif);
-      const bobWallet = await RegTestWallet.slp.newRandom();
-      await worker.registerWebhook({
-        cashaddr: bobWallet.slp.slpaddr,
-        url: "http://example.com/bob",
-        type: WebhookType.slpTransactionOut,
-        recurrence: WebhookRecurrence.recurrent,
-        tokenId: tokenId,
-      });
-
-      await aliceWallet.send([
-        {
-          cashaddr: bobWallet.cashaddr!,
-          value: 1000,
-          unit: "satoshi",
-        },
-      ]);
-
-      await Promise.all([
-        aliceWallet.slp.send([
-          {
-            slpaddr: bobWallet.slp.slpaddr,
-            value: 1000,
-            tokenId: tokenId,
-          },
-        ]),
-        bobWallet.slp.waitForTransaction(),
-      ]);
-
-      // return funds
-      await Promise.all([
-        bobWallet.slp.sendMax(aliceWallet.cashaddr!, tokenId),
-        aliceWallet.slp.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 non-recurrent watch balance hook", async () => {
-    try {
-      const aliceWallet = await RegTestWallet.slp.fromId(aliceWif);
-      const bobWallet = await RegTestWallet.slp.newRandom();
-      await worker.registerWebhook({
-        cashaddr: bobWallet.slp.slpaddr,
-        url: "http://example.com/watchBalance",
-        type: WebhookType.slpBalance,
-        recurrence: WebhookRecurrence.once,
-        tokenId: tokenId,
-      });
-
-      await Promise.all([
-        aliceWallet.slp.send([
-          {
-            slpaddr: bobWallet.slp.slpaddr,
-            value: 1000,
-            tokenId: tokenId,
-          },
-        ]),
-        bobWallet.slp.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;
-    }
-  });
-});

package/src/webhook/WebhookSlp.ts

@@ -1,123 +0,0 @@
-import { GsppTx, SlpDbTx, SlpTxI } from "../slp/index.js";
-import {
-  SlpCancelWatchFn,
-  SlpWatchTransactionCallback,
-} from "../slp/SlpProvider.js";
-import { toSlpAddress } from "../util/bchaddr.js";
-import { Wallet } from "../wallet/Wif.js";
-import { Webhook, WebhookRecurrence, WebhookType } from "./Webhook.js";
-import WebhookWorker from "./WebhookWorker.js";
-
-export class WebhookSlp extends Webhook {
-  callback!: SlpWatchTransactionCallback;
-  cancelFn!: SlpCancelWatchFn;
-  wallet!: Wallet;
-
-  constructor(hook: Webhook | Object) {
-    super(hook);
-    Object.assign(this, hook);
-    this.cashaddr = toSlpAddress(this.cashaddr);
-  }
-
-  async start(): Promise<void> {
-    const webhookCallback: SlpWatchTransactionCallback = async (
-      rawTx: SlpTxI
-    ) => {
-      let result = false;
-      if ("_id" in rawTx.details) {
-        result = await this.slpDbHandler(rawTx);
-      } else {
-        result = await this.gsppHandler(rawTx);
-      }
-
-      if (result && this.recurrence === WebhookRecurrence.once) {
-        // we have to notify the worker about end of life
-        await (await WebhookWorker.instance()).stopHook(this);
-        await this.destroy();
-      }
-    };
-
-    this.callback = webhookCallback;
-    this.wallet = await Wallet.fromSlpaddr(this.cashaddr);
-    this.cancelFn = this.wallet.slp.watchTransactions(
-      webhookCallback,
-      this.tokenId
-    );
-  }
-
-  async slpDbHandler(rawTx: SlpTxI) {
-    let result: boolean = false;
-    const txDirection = this.type;
-    const details: SlpDbTx = rawTx.details as SlpDbTx;
-    if (this.type === WebhookType.slpTransactionInOut) {
-      result = await this.post({
-        direction: txDirection,
-        data: rawTx,
-      });
-    } else if (
-      this.type === WebhookType.slpTransactionIn &&
-      details.out.findIndex((val) => val.e.a === this.cashaddr) > -1
-    ) {
-      result = await this.post({
-        direction: txDirection,
-        data: rawTx,
-      });
-    } else if (
-      this.type === WebhookType.slpTransactionOut &&
-      details.in.findIndex((val) => val.e.a === this.cashaddr) > -1
-    ) {
-      result = await this.post({
-        direction: txDirection,
-        data: rawTx,
-      });
-    } else if (this.type === WebhookType.slpBalance) {
-      const balance = this.wallet.slp.getBalance(this.tokenId!);
-      result = await this.post({
-        direction: txDirection,
-        data: balance,
-      });
-    }
-
-    return result;
-  }
-
-  async gsppHandler(rawTx: SlpTxI) {
-    let result: boolean = false;
-    const txDirection = this.type;
-    const details: GsppTx = rawTx.details as GsppTx;
-    if (this.type === WebhookType.slpTransactionInOut) {
-      result = await this.post({
-        direction: txDirection,
-        data: rawTx,
-      });
-    } else if (
-      this.type === WebhookType.slpTransactionIn &&
-      details.outputs.findIndex((val) => val === this.cashaddr) > -1
-    ) {
-      result = await this.post({
-        direction: txDirection,
-        data: rawTx,
-      });
-    } else if (
-      this.type === WebhookType.slpTransactionOut &&
-      details.inputs.findIndex((val) => val === this.cashaddr) > -1
-    ) {
-      result = await this.post({
-        direction: txDirection,
-        data: rawTx,
-      });
-    } else if (this.type === WebhookType.slpBalance) {
-      const balance = this.wallet.slp.getBalance(this.tokenId!);
-      result = await this.post({
-        direction: txDirection,
-        data: balance,
-      });
-    }
-
-    return result;
-  }
-
-  async stop(): Promise<void> {
-    await this.cancelFn();
-  }
-}