@ocap/tx-util 1.28.9 → 1.29.1

package/README.md

@@ -1,6 +1,5 @@
 ![tx-util](https://www.arcblock.io/.netlify/functions/badge/?text=tx-util)
 
-[![styled with prettier](https://img.shields.io/badge/styled_with-prettier-ff69b4.svg)](https://github.com/prettier/prettier)
 [![docs](https://img.shields.io/badge/powered%20by-arcblock-green.svg)](https://docs.arcblock.io)
 [![Gitter](https://badges.gitter.im/ArcBlock/community.svg)](https://gitter.im/ArcBlock/community?utm_source=badge&utm_medium=badge&utm_campaign=pr-badge)
 

package/esm/index.d.mts

@@ -0,0 +1,11 @@
+import { CreateVerifierOptions, VerifierDoneEvent, VerifierEventEmitter, VerifyResponse } from "./verifier.mjs";
+
+//#region src/index.d.ts
+declare const verifyTx: (params: CreateVerifierOptions) => VerifierEventEmitter;
+declare const verifyTxAsync: (params: CreateVerifierOptions) => Promise<VerifierDoneEvent>;
+declare const verifyAccount: (params: CreateVerifierOptions) => VerifierEventEmitter;
+declare const verifyAccountAsync: (params: CreateVerifierOptions) => Promise<VerifierDoneEvent>;
+declare const verifyAsset: (params: CreateVerifierOptions) => VerifierEventEmitter;
+declare const verifyAssetAsync: (params: CreateVerifierOptions) => Promise<VerifierDoneEvent>;
+//#endregion
+export { type CreateVerifierOptions, type VerifierDoneEvent, type VerifierEventEmitter, type VerifyResponse, verifyTx as createVerifier, verifyTx, verifyAccount, verifyAccountAsync, verifyAsset, verifyAssetAsync, verifyTxAsync };

package/esm/index.mjs

@@ -0,0 +1,81 @@
+import { create, createAsync } from "./verifier.mjs";
+
+//#region src/index.ts
+/**
+* Generate a transaction verifier by tx hash
+* Emit events on transaction included in a block
+*
+*  - `error`: when there is something wrong when verify the transaction
+*  - `done`: when the transaction is successfully verified
+*
+* @param params
+* @param params.hash - tx hash to check
+* @param params.chainHost - on which chain to check the tx
+* @param params.checkInterval - tx query interval to see the tx
+* @param params.autoStart - should the verifier start on create
+* @param params.maxRetry - max number of checks before mark the tx as expired
+* @returns verifier object
+*/
+const txVerifierParams = {
+	key: "hash",
+	label: "tx",
+	fn: "getTx",
+	validate: (res) => {
+		if (res.info) {
+			if (res.info.code === "OK") return true;
+			throw new Error(res.info.code);
+		}
+		return false;
+	}
+};
+const verifyTx = create(txVerifierParams);
+const verifyTxAsync = createAsync(txVerifierParams);
+/**
+* Generate a account verifier by address
+* Emit events on account declared in a block
+*
+*  - `error`: when there is something wrong when verify the transaction
+*  - `done`: when the transaction is successfully verified
+*
+* @param params
+* @param params.address - account address to check
+* @param params.chainHost - on which chain to check the account
+* @param params.checkInterval - query interval to see the account
+* @param params.autoStart - should the verifier start on create
+* @param params.maxRetry - max number of checks before mark the check as expired
+* @returns verifier object
+*/
+const accountVerifierParams = {
+	key: "address",
+	label: "account",
+	fn: "getAccountState",
+	validate: (res) => res.state
+};
+const verifyAccount = create(accountVerifierParams);
+const verifyAccountAsync = createAsync(accountVerifierParams);
+/**
+* Generate a asset verifier by address
+* Emit events on asset can be found on chain
+*
+*  - `error`: when there is something wrong when verify the asset
+*  - `done`: when the asset is found
+*
+* @param params
+* @param params.address - asset address to check
+* @param params.chainHost - on which chain to check the asset
+* @param params.checkInterval - query interval to see the asset
+* @param params.autoStart - should the verifier start on create
+* @param params.maxRetry - max number of checks before mark the check as expired
+* @returns verifier object
+*/
+const assetVerifierParams = {
+	key: "address",
+	label: "asset",
+	fn: "getAssetState",
+	validate: (res) => res.state
+};
+const verifyAsset = create(assetVerifierParams);
+const verifyAssetAsync = createAsync(assetVerifierParams);
+
+//#endregion
+export { verifyTx as createVerifier, verifyTx, verifyAccount, verifyAccountAsync, verifyAsset, verifyAssetAsync, verifyTxAsync };

package/esm/package.mjs

@@ -0,0 +1,5 @@
+//#region package.json
+var name = "@ocap/tx-util";
+
+//#endregion
+export { name };

package/esm/verifier.d.mts

@@ -0,0 +1,52 @@
+import { EventEmitter } from "node:events";
+
+//#region src/verifier.d.ts
+interface VerifierParams {
+  key: string;
+  label: string;
+  fn: string;
+  validate: (res: VerifyResponse) => unknown;
+}
+interface VerifyResponse {
+  code?: string;
+  info?: {
+    code: string;
+    hash?: string;
+  };
+  state?: {
+    address: string;
+  };
+}
+interface CreateVerifierOptions {
+  chainHost: string;
+  checkInterval?: number;
+  autoStart?: boolean;
+  maxRetry?: number;
+  [key: string]: unknown;
+}
+interface VerifierEventEmitter extends EventEmitter {
+  start: () => Promise<boolean>;
+}
+interface VerifierDoneEvent {
+  data: VerifyResponse;
+  [key: string]: unknown;
+}
+interface VerifierErrorEvent {
+  type: 'expired' | 'invalid' | 'exception';
+  retryCount: number;
+  error?: Error;
+  data?: VerifyResponse;
+  [key: string]: unknown;
+}
+declare const create: ({
+  key,
+  label,
+  fn,
+  validate
+}: VerifierParams) => (params: CreateVerifierOptions) => VerifierEventEmitter;
+/**
+ * Create an async verifier
+ */
+declare const createAsync: (verifierParams: VerifierParams) => (params: CreateVerifierOptions) => Promise<VerifierDoneEvent>;
+//#endregion
+export { CreateVerifierOptions, VerifierDoneEvent, VerifierErrorEvent, VerifierEventEmitter, VerifierParams, VerifyResponse, create, createAsync };

package/esm/verifier.mjs

@@ -0,0 +1,91 @@
+import { name } from "./package.mjs";
+import { EventEmitter } from "node:events";
+import Client from "@ocap/client";
+import Debug from "debug";
+
+//#region src/verifier.ts
+const debug = Debug(name);
+const create = ({ key, label, fn, validate }) => (params) => {
+	const { chainHost, checkInterval = 1e3, autoStart = true, maxRetry = 20 } = params;
+	debug(`${label}.verify.params`, params);
+	if (!params[key]) throw new Error(`${key} must be provided to create ${label} verifier`);
+	if (!chainHost) throw new Error(`chainHost must be provided to create ${label} verifier`);
+	const client = new Client(chainHost);
+	if (typeof client[fn] !== "function") throw new Error(`Verify method ${fn} does not exist on client.`);
+	const param = params[key];
+	const events = new EventEmitter();
+	let retryCount = 0;
+	const doCheck = async () => {
+		if (retryCount > maxRetry) {
+			events.emit("error", {
+				[key]: params[key],
+				type: "expired",
+				retryCount,
+				error: /* @__PURE__ */ new Error("Transaction verifier exceeded max retry count")
+			});
+			return false;
+		}
+		retryCount += 1;
+		try {
+			const res = await client[fn]({ [key]: param });
+			if (res && res.code === "OK") try {
+				if (validate(res)) {
+					debug(`${label}.verify.done`, {
+						[key]: param,
+						retryCount
+					});
+					events.emit("done", {
+						[key]: param,
+						data: res
+					});
+					return true;
+				}
+				debug(`${label}.verify.pending`, {
+					[key]: param,
+					code: res.code,
+					retryCount
+				});
+				setTimeout(doCheck, checkInterval);
+			} catch (_err) {
+				events.emit("error", {
+					[key]: param,
+					type: "invalid",
+					retryCount,
+					data: res
+				});
+			}
+			else {
+				debug(`${label}.verify.pending`, {
+					[key]: param,
+					code: res.code,
+					retryCount
+				});
+				setTimeout(doCheck, checkInterval);
+			}
+		} catch (err) {
+			console.error(`${label}.verify.error`, err);
+			setTimeout(doCheck, checkInterval);
+			events.emit("error", {
+				[key]: param,
+				type: "exception",
+				error: err,
+				retryCount
+			});
+		}
+		return false;
+	};
+	events.start = doCheck;
+	if (autoStart) doCheck();
+	return events;
+};
+/**
+* Create an async verifier
+*/
+const createAsync = (verifierParams) => (params) => new Promise((resolve, reject) => {
+	const verifier = create(verifierParams)(params);
+	verifier.on("done", resolve);
+	verifier.on("error", reject);
+});
+
+//#endregion
+export { create, createAsync };

package/lib/_virtual/rolldown_runtime.cjs

@@ -0,0 +1,29 @@
+//#region rolldown:runtime
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+	if (from && typeof from === "object" || typeof from === "function") {
+		for (var keys = __getOwnPropNames(from), i = 0, n = keys.length, key; i < n; i++) {
+			key = keys[i];
+			if (!__hasOwnProp.call(to, key) && key !== except) {
+				__defProp(to, key, {
+					get: ((k) => from[k]).bind(null, key),
+					enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+				});
+			}
+		}
+	}
+	return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", {
+	value: mod,
+	enumerable: true
+}) : target, mod));
+
+//#endregion
+
+exports.__toESM = __toESM;

package/lib/index.cjs

@@ -0,0 +1,87 @@
+const require_verifier = require('./verifier.cjs');
+
+//#region src/index.ts
+/**
+* Generate a transaction verifier by tx hash
+* Emit events on transaction included in a block
+*
+*  - `error`: when there is something wrong when verify the transaction
+*  - `done`: when the transaction is successfully verified
+*
+* @param params
+* @param params.hash - tx hash to check
+* @param params.chainHost - on which chain to check the tx
+* @param params.checkInterval - tx query interval to see the tx
+* @param params.autoStart - should the verifier start on create
+* @param params.maxRetry - max number of checks before mark the tx as expired
+* @returns verifier object
+*/
+const txVerifierParams = {
+	key: "hash",
+	label: "tx",
+	fn: "getTx",
+	validate: (res) => {
+		if (res.info) {
+			if (res.info.code === "OK") return true;
+			throw new Error(res.info.code);
+		}
+		return false;
+	}
+};
+const verifyTx = require_verifier.create(txVerifierParams);
+const verifyTxAsync = require_verifier.createAsync(txVerifierParams);
+/**
+* Generate a account verifier by address
+* Emit events on account declared in a block
+*
+*  - `error`: when there is something wrong when verify the transaction
+*  - `done`: when the transaction is successfully verified
+*
+* @param params
+* @param params.address - account address to check
+* @param params.chainHost - on which chain to check the account
+* @param params.checkInterval - query interval to see the account
+* @param params.autoStart - should the verifier start on create
+* @param params.maxRetry - max number of checks before mark the check as expired
+* @returns verifier object
+*/
+const accountVerifierParams = {
+	key: "address",
+	label: "account",
+	fn: "getAccountState",
+	validate: (res) => res.state
+};
+const verifyAccount = require_verifier.create(accountVerifierParams);
+const verifyAccountAsync = require_verifier.createAsync(accountVerifierParams);
+/**
+* Generate a asset verifier by address
+* Emit events on asset can be found on chain
+*
+*  - `error`: when there is something wrong when verify the asset
+*  - `done`: when the asset is found
+*
+* @param params
+* @param params.address - asset address to check
+* @param params.chainHost - on which chain to check the asset
+* @param params.checkInterval - query interval to see the asset
+* @param params.autoStart - should the verifier start on create
+* @param params.maxRetry - max number of checks before mark the check as expired
+* @returns verifier object
+*/
+const assetVerifierParams = {
+	key: "address",
+	label: "asset",
+	fn: "getAssetState",
+	validate: (res) => res.state
+};
+const verifyAsset = require_verifier.create(assetVerifierParams);
+const verifyAssetAsync = require_verifier.createAsync(assetVerifierParams);
+
+//#endregion
+exports.createVerifier = verifyTx;
+exports.verifyTx = verifyTx;
+exports.verifyAccount = verifyAccount;
+exports.verifyAccountAsync = verifyAccountAsync;
+exports.verifyAsset = verifyAsset;
+exports.verifyAssetAsync = verifyAssetAsync;
+exports.verifyTxAsync = verifyTxAsync;

package/lib/index.d.cts

@@ -0,0 +1,11 @@
+import { CreateVerifierOptions, VerifierDoneEvent, VerifierEventEmitter, VerifyResponse } from "./verifier.cjs";
+
+//#region src/index.d.ts
+declare const verifyTx: (params: CreateVerifierOptions) => VerifierEventEmitter;
+declare const verifyTxAsync: (params: CreateVerifierOptions) => Promise<VerifierDoneEvent>;
+declare const verifyAccount: (params: CreateVerifierOptions) => VerifierEventEmitter;
+declare const verifyAccountAsync: (params: CreateVerifierOptions) => Promise<VerifierDoneEvent>;
+declare const verifyAsset: (params: CreateVerifierOptions) => VerifierEventEmitter;
+declare const verifyAssetAsync: (params: CreateVerifierOptions) => Promise<VerifierDoneEvent>;
+//#endregion
+export { type CreateVerifierOptions, type VerifierDoneEvent, type VerifierEventEmitter, type VerifyResponse, verifyTx as createVerifier, verifyTx, verifyAccount, verifyAccountAsync, verifyAsset, verifyAssetAsync, verifyTxAsync };

package/lib/package.cjs

@@ -0,0 +1,11 @@
+
+//#region package.json
+var name = "@ocap/tx-util";
+
+//#endregion
+Object.defineProperty(exports, 'name', {
+  enumerable: true,
+  get: function () {
+    return name;
+  }
+});

package/lib/verifier.cjs

@@ -0,0 +1,95 @@
+const require_rolldown_runtime = require('./_virtual/rolldown_runtime.cjs');
+const require_package = require('./package.cjs');
+let node_events = require("node:events");
+let _ocap_client = require("@ocap/client");
+_ocap_client = require_rolldown_runtime.__toESM(_ocap_client);
+let debug = require("debug");
+debug = require_rolldown_runtime.__toESM(debug);
+
+//#region src/verifier.ts
+const debug$1 = (0, debug.default)(require_package.name);
+const create = ({ key, label, fn, validate }) => (params) => {
+	const { chainHost, checkInterval = 1e3, autoStart = true, maxRetry = 20 } = params;
+	debug$1(`${label}.verify.params`, params);
+	if (!params[key]) throw new Error(`${key} must be provided to create ${label} verifier`);
+	if (!chainHost) throw new Error(`chainHost must be provided to create ${label} verifier`);
+	const client = new _ocap_client.default(chainHost);
+	if (typeof client[fn] !== "function") throw new Error(`Verify method ${fn} does not exist on client.`);
+	const param = params[key];
+	const events = new node_events.EventEmitter();
+	let retryCount = 0;
+	const doCheck = async () => {
+		if (retryCount > maxRetry) {
+			events.emit("error", {
+				[key]: params[key],
+				type: "expired",
+				retryCount,
+				error: /* @__PURE__ */ new Error("Transaction verifier exceeded max retry count")
+			});
+			return false;
+		}
+		retryCount += 1;
+		try {
+			const res = await client[fn]({ [key]: param });
+			if (res && res.code === "OK") try {
+				if (validate(res)) {
+					debug$1(`${label}.verify.done`, {
+						[key]: param,
+						retryCount
+					});
+					events.emit("done", {
+						[key]: param,
+						data: res
+					});
+					return true;
+				}
+				debug$1(`${label}.verify.pending`, {
+					[key]: param,
+					code: res.code,
+					retryCount
+				});
+				setTimeout(doCheck, checkInterval);
+			} catch (_err) {
+				events.emit("error", {
+					[key]: param,
+					type: "invalid",
+					retryCount,
+					data: res
+				});
+			}
+			else {
+				debug$1(`${label}.verify.pending`, {
+					[key]: param,
+					code: res.code,
+					retryCount
+				});
+				setTimeout(doCheck, checkInterval);
+			}
+		} catch (err) {
+			console.error(`${label}.verify.error`, err);
+			setTimeout(doCheck, checkInterval);
+			events.emit("error", {
+				[key]: param,
+				type: "exception",
+				error: err,
+				retryCount
+			});
+		}
+		return false;
+	};
+	events.start = doCheck;
+	if (autoStart) doCheck();
+	return events;
+};
+/**
+* Create an async verifier
+*/
+const createAsync = (verifierParams) => (params) => new Promise((resolve, reject) => {
+	const verifier = create(verifierParams)(params);
+	verifier.on("done", resolve);
+	verifier.on("error", reject);
+});
+
+//#endregion
+exports.create = create;
+exports.createAsync = createAsync;

package/lib/verifier.d.cts

@@ -0,0 +1,52 @@
+import { EventEmitter } from "node:events";
+
+//#region src/verifier.d.ts
+interface VerifierParams {
+  key: string;
+  label: string;
+  fn: string;
+  validate: (res: VerifyResponse) => unknown;
+}
+interface VerifyResponse {
+  code?: string;
+  info?: {
+    code: string;
+    hash?: string;
+  };
+  state?: {
+    address: string;
+  };
+}
+interface CreateVerifierOptions {
+  chainHost: string;
+  checkInterval?: number;
+  autoStart?: boolean;
+  maxRetry?: number;
+  [key: string]: unknown;
+}
+interface VerifierEventEmitter extends EventEmitter {
+  start: () => Promise<boolean>;
+}
+interface VerifierDoneEvent {
+  data: VerifyResponse;
+  [key: string]: unknown;
+}
+interface VerifierErrorEvent {
+  type: 'expired' | 'invalid' | 'exception';
+  retryCount: number;
+  error?: Error;
+  data?: VerifyResponse;
+  [key: string]: unknown;
+}
+declare const create: ({
+  key,
+  label,
+  fn,
+  validate
+}: VerifierParams) => (params: CreateVerifierOptions) => VerifierEventEmitter;
+/**
+ * Create an async verifier
+ */
+declare const createAsync: (verifierParams: VerifierParams) => (params: CreateVerifierOptions) => Promise<VerifierDoneEvent>;
+//#endregion
+export { CreateVerifierOptions, VerifierDoneEvent, VerifierErrorEvent, VerifierEventEmitter, VerifierParams, VerifyResponse, create, createAsync };

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@ocap/tx-util",
   "description": "Utility to work with forge transactions",
-  "version": "1.28.9",
+  "version": "1.29.1",
   "author": {
     "name": "wangshijun",
     "email": "shijun@arcblock.io",
@@ -17,13 +17,38 @@
   "publishConfig": {
     "access": "public"
   },
+  "type": "module",
+  "main": "./lib/index.cjs",
+  "module": "./esm/index.mjs",
+  "types": "./esm/index.d.mts",
+  "exports": {
+    ".": {
+      "types": "./esm/index.d.mts",
+      "import": "./esm/index.mjs",
+      "default": "./lib/index.cjs"
+    },
+    "./lib/*.js": {
+      "types": "./esm/*.d.mts",
+      "import": "./esm/*.mjs",
+      "default": "./lib/*.cjs"
+    },
+    "./lib/*": {
+      "types": "./esm/*.d.mts",
+      "import": "./esm/*.mjs",
+      "default": "./lib/*.cjs"
+    }
+  },
+  "files": [
+    "lib",
+    "esm"
+  ],
   "dependencies": {
-    "@ocap/client": "1.28.9",
-    "@ocap/tx-protocols": "1.28.9",
-    "debug": "^4.3.6"
+    "@ocap/client": "1.29.1",
+    "@ocap/tx-protocols": "1.29.1",
+    "debug": "^4.4.3"
   },
   "devDependencies": {
-    "@ocap/e2e-test": "1.28.9",
+    "@ocap/e2e-test": "1.29.1",
     "remark-cli": "^10.0.1",
     "remark-preset-github": "^4.0.4"
   },
@@ -45,10 +70,6 @@
     "nodejs"
   ],
   "license": "Apache-2.0",
-  "main": "./lib/index.js",
-  "files": [
-    "lib"
-  ],
   "repository": {
     "type": "git",
     "url": "https://github.com/ArcBlock/blockchain/tree/master/core/tx-util"
@@ -56,10 +77,12 @@
   "scripts": {
     "lint": "biome check",
     "lint:fix": "biome check --write",
+    "build": "tsdown",
+    "prebuild": "rm -rf lib esm",
     "docs": "bun run gen-dts && bun run gen-docs && bun run cleanup-docs && bun run format-docs",
     "cleanup-docs": "node ../../scripts/cleanup-docs.js docs/README.md $npm_package_name",
-    "gen-dts": "j2d lib/index.js",
-    "gen-docs": "jsdoc2md lib/index.js > docs/README.md",
+    "gen-dts": "j2d lib/index.cjs",
+    "gen-docs": "jsdoc2md lib/index.cjs > docs/README.md",
     "format-docs": "remark . -o",
     "test": "bun test",
     "coverage": "npm run test -- --coverage"

package/lib/index.d.ts

@@ -1,16 +0,0 @@
-// Generate by [js2dts@0.3.3](https://github.com/whxaxes/js2dts#readme)
-
-import * as events from 'events';
-declare const _Lib: _Lib.T100;
-declare namespace _Lib {
-  export interface T100 {
-    createVerifier: (params: any) => events;
-    verifyTx: (params: any) => events;
-    verifyTxAsync: (params: any) => Promise<any>;
-    verifyAccount: (params: any) => events;
-    verifyAccountAsync: (params: any) => Promise<any>;
-    verifyAsset: (params: any) => events;
-    verifyAssetAsync: (params: any) => Promise<any>;
-  }
-}
-export = _Lib;

package/lib/index.js

@@ -1,94 +0,0 @@
-const { create, createAsync } = require('./verifier');
-
-/**
- * Generate a transaction verifier by tx hash
- * Emit events on transaction included in a block
- *
- *  - `error`: when there is something wrong when verify the transaction
- *  - `done`: when the transaction is successfully verified
- *
- * @param {object} params
- * @param {string} params.hash - tx hash to check
- * @param {string} params.chainHost - on which chain to check the tx
- * @param {number} params.checkInterval - tx query interval to see the tx
- * @param {boolean} params.autoStart - should the verifier start on create
- * @param {number} params.maxRetry - max number of checks before mark the tx as expired
- * @returns {EventEmitter} verifier object
- */
-const txVerifierParams = {
-  key: 'hash',
-  label: 'tx',
-  fn: 'getTx',
-  validate: (res) => {
-    if (res.info) {
-      if (res.info.code === 'OK') {
-        return true;
-      }
-
-      // If the tx failed, we throw an error
-      throw new Error(res.info.code);
-    }
-
-    return false;
-  },
-};
-const verifyTx = create(txVerifierParams);
-const verifyTxAsync = createAsync(txVerifierParams);
-
-/**
- * Generate a account verifier by address
- * Emit events on account declared in a block
- *
- *  - `error`: when there is something wrong when verify the transaction
- *  - `done`: when the transaction is successfully verified
- *
- * @param {object} params
- * @param {string} params.address - account address to check
- * @param {string} params.chainHost - on which chain to check the account
- * @param {number} params.checkInterval - query interval to see the account
- * @param {boolean} params.autoStart - should the verifier start on create
- * @param {number} params.maxRetry - max number of checks before mark the check as expired
- * @returns {EventEmitter} verifier object
- */
-const accountVerifierParams = {
-  key: 'address',
-  label: 'account',
-  fn: 'getAccountState',
-  validate: (res) => res.state,
-};
-const verifyAccount = create(accountVerifierParams);
-const verifyAccountAsync = createAsync(accountVerifierParams);
-
-/**
- * Generate a asset verifier by address
- * Emit events on asset can be found on chain
- *
- *  - `error`: when there is something wrong when verify the asset
- *  - `done`: when the asset is found
- *
- * @param {object} params
- * @param {string} params.address - asset address to check
- * @param {string} params.chainHost - on which chain to check the asset
- * @param {number} params.checkInterval - query interval to see the asset
- * @param {boolean} params.autoStart - should the verifier start on create
- * @param {number} params.maxRetry - max number of checks before mark the check as expired
- * @returns {EventEmitter} verifier object
- */
-const assetVerifierParams = {
-  key: 'address',
-  label: 'asset',
-  fn: 'getAssetState',
-  validate: (res) => res.state,
-};
-const verifyAsset = create(assetVerifierParams);
-const verifyAssetAsync = createAsync(assetVerifierParams);
-
-module.exports = {
-  createVerifier: verifyTx,
-  verifyTx,
-  verifyTxAsync,
-  verifyAccount,
-  verifyAccountAsync,
-  verifyAsset,
-  verifyAssetAsync,
-};

package/lib/verifier.js

@@ -1,101 +0,0 @@
-const Client = require('@ocap/client');
-const { EventEmitter } = require('node:events');
-
-const debug = require('debug')(require('../package.json').name);
-
-const create =
-  ({ key, label, fn, validate }) =>
-  (params) => {
-    const { chainHost, checkInterval = 1000, autoStart = true, maxRetry = 20 } = params;
-    debug(`${label}.verify.params`, params);
-
-    if (!params[key]) {
-      throw new Error(`${key} must be provided to create ${label} verifier`);
-    }
-    if (!chainHost) {
-      throw new Error(`chainHost must be provided to create ${label} verifier`);
-    }
-
-    const client = new Client(chainHost);
-    if (typeof client[fn] !== 'function') {
-      throw new Error(`Verify method ${fn} does not exist on client.`);
-    }
-
-    const param = params[key];
-    const events = new EventEmitter();
-    let retryCount = 0;
-
-    const doCheck = async () => {
-      if (retryCount > maxRetry) {
-        events.emit('error', {
-          [key]: params[key],
-          type: 'expired',
-          retryCount,
-          error: new Error('Transaction verifier exceeded max retry count'),
-        });
-        return false;
-      }
-
-      retryCount += 1;
-
-      try {
-        const res = await client[fn]({ [key]: param });
-        if (res && res.code === 'OK') {
-          try {
-            const result = validate(res);
-            if (result) {
-              debug(`${label}.verify.done`, { [key]: param, retryCount });
-              events.emit('done', { [key]: param, data: res });
-              return true;
-            }
-            debug(`${label}.verify.pending`, { [key]: param, code: res.code, retryCount });
-            setTimeout(doCheck, checkInterval);
-          } catch (_err) {
-            events.emit('error', {
-              [key]: param,
-              type: 'invalid',
-              retryCount,
-              data: res,
-            });
-          }
-        } else {
-          debug(`${label}.verify.pending`, { [key]: param, code: res.code, retryCount });
-          setTimeout(doCheck, checkInterval);
-        }
-      } catch (err) {
-        console.error(`${label}.verify.error`, err);
-        setTimeout(doCheck, checkInterval);
-        events.emit('error', {
-          [key]: param,
-          type: 'exception',
-          error: err,
-          retryCount,
-        });
-      }
-
-      return false;
-    };
-
-    events.start = doCheck;
-
-    if (autoStart) {
-      doCheck();
-    }
-
-    return events;
-  };
-
-/**
- * Create an async verifier
- */
-const createAsync = (verifierParams) => (params) =>
-  new Promise((resolve, reject) => {
-    const verifier = create(verifierParams)(params);
-    verifier.on('done', resolve);
-    verifier.on('error', reject);
-  });
-
-module.exports = {
-  create,
-  createAsync,
-};