tapass 0.0.0-stage → 0.2.0

package/src/tapd_methods/mint/fund_mint_batch.ts

@@ -0,0 +1,193 @@
+import {auto as asyncAuto} from 'async';
+import {returnResult} from 'asyncjs-util';
+
+import {isConnectionFailure} from '../../tapd_requests/index.js';
+import {isPermissionDenied} from '../../tapd_requests/index.js';
+import {isTapd} from '../../tapd_requests/index.js';
+import {mintFundingRequest} from '../../tapd_requests/index.js';
+import {mintRpcError} from '../../tapd_responses/index.js';
+import {rpcBatchAsBatch} from '../../tapd_responses/index.js';
+import type {Batch} from '../../tapd_responses/index.js';
+import type {AuthenticatedTapdArgs} from '../../typescript/index.js';
+import type {TapdCallback} from '../../typescript/index.js';
+import type {TapdError} from '../../typescript/index.js';
+import type {TapdMethod} from '../../typescript/index.js';
+
+const {isArray} = Array;
+const isFeeRate = (n: unknown) => typeof n === 'number' && n > 0 && n < 1e7;
+const isHash = (n: unknown) => /^[0-9A-F]{64}$/i.test(String(n));
+const isScript = (n: unknown) => /^([0-9A-F]{2})+$/i.test(String(n));
+const method = 'fundBatch';
+const type = 'mint';
+
+export type FundMintBatchArgs = AuthenticatedTapdArgs<{
+  /** Fee Tokens Per Virtual Byte Number */
+  fee_tokens_per_vbyte?: number;
+  tapscript_branch?: {
+    /** Left Tap Branch Hash Hex String */
+    left: string;
+    /** Right Tap Branch Hash Hex String */
+    right: string;
+  };
+  /** Tapscript Leaf Script Hex Strings */
+  tapscript_leaves?: string[];
+}>;
+
+export type FundMintBatchResult = Batch;
+
+type Tasks = {
+  fund: FundMintBatchResult;
+  validate: undefined;
+};
+
+/** Fund the pending mint batch with a genesis input
+
+  Requires `mint:write` permission
+
+  This is only necessary when the batch needs a custom witness before
+  `finalizeMintBatch`. tapd makes a new funded batch when there is no pending
+  batch.
+
+  A tapscript sibling is optional: give `tapscript_leaves` or a
+  `tapscript_branch`, not both.
+
+  {
+    [fee_tokens_per_vbyte]: <Fee Tokens Per Virtual Byte Number>
+    [tapscript_branch]: {
+      left: <Left Tap Branch Hash Hex String>
+      right: <Right Tap Branch Hash Hex String>
+    }
+    [tapscript_leaves]: [<Tapscript Leaf Script Hex String>]
+    tapd: <Authenticated tapd API Object>
+  }
+
+  @returns via cbk or Promise
+  {
+    assets: [{
+      amount: <Asset Units Numeric String>
+      [group_anchor]: <Name of the Asset That Anchors a New Group String>
+      [group_internal_key]: <Group Internal Public Key Hex String>
+      [group_key]: <Group Key Hex String>
+      [group_tapscript_root]: <Group Tapscript Root Hex String>
+      is_collectible: <Asset Is Collectible Bool>
+      is_new_group: <Asset Starts a New Group Bool>
+      [metadata]: <Metadata Hex String>
+      [metadata_hash]: <Metadata Hash Hex String>
+      [metadata_type]: <Metadata Type String> // json, opaque
+      name: <Asset Name String>
+      [script_key]: <Script Key Hex String>
+      version: <Asset Version Number>
+    }]
+    created_at: <Created At ISO 8601 Date String>
+    created_height: <Block Height When Created Number>
+    id: <Batch Key Hex String>
+    [psbt]: <Genesis Transaction PSBT Hex String>
+    state: <Batch State String>
+    [transaction_id]: <Genesis Transaction Id Hex String>
+    unsealed_assets: [{
+      amount: <Asset Units Numeric String>
+      [group_anchor]: <Name of the Asset That Anchors a New Group String>
+      [group_internal_key]: <Group Internal Public Key Hex String>
+      [group_key]: <Group Key Hex String>
+      [group_tapscript_root]: <Group Tapscript Root Hex String>
+      [group_virtual_psbt]: <Group Virtual Transaction PSBT Hex String>
+      [group_virtual_transaction]: <Group Virtual Transaction Hex String>
+      is_collectible: <Asset Is Collectible Bool>
+      is_new_group: <Asset Starts a New Group Bool>
+      [metadata]: <Metadata Hex String>
+      [metadata_hash]: <Metadata Hash Hex String>
+      [metadata_type]: <Metadata Type String> // json, opaque
+      name: <Asset Name String>
+      [script_key]: <Script Key Hex String>
+      version: <Asset Version Number>
+    }]
+  }
+*/
+const fundMintBatch: TapdMethod<FundMintBatchArgs, FundMintBatchResult> = (
+  args: FundMintBatchArgs,
+  cbk?: TapdCallback<FundMintBatchResult>,
+) => {
+  return new Promise((resolve, reject) => {
+    return asyncAuto<Tasks, TapdError>(
+      {
+        // Check arguments
+        validate: cbk => {
+          const branch = args.tapscript_branch;
+          const leaves = args.tapscript_leaves;
+
+          if (args.fee_tokens_per_vbyte !== undefined) {
+            if (!isFeeRate(args.fee_tokens_per_vbyte)) {
+              return cbk([400, 'ExpectedFeeRateToFundMintBatch']);
+            }
+          }
+
+          if (!!branch && !!leaves) {
+            return cbk([400, 'ExpectedTapscriptLeavesOrBranchNotBoth']);
+          }
+
+          if (!!branch && (!isHash(branch.left) || !isHash(branch.right))) {
+            return cbk([400, 'ExpectedTapscriptBranchHashesToFundMintBatch']);
+          }
+
+          if (!!leaves && (!isArray(leaves) || !leaves.length)) {
+            return cbk([400, 'ExpectedTapscriptLeavesToFundMintBatch']);
+          }
+
+          if (!!leaves && !leaves.every(isScript)) {
+            return cbk([400, 'ExpectedHexTapscriptLeavesToFundMintBatch']);
+          }
+
+          if (!isTapd({method, type, tapd: args.tapd})) {
+            return cbk([400, 'ExpectedAuthenticatedTapdToFundMintBatch']);
+          }
+
+          return cbk();
+        },
+
+        // Fund the batch
+        fund: [
+          'validate',
+          ({}, cbk) => {
+            const request = {
+              ...mintFundingRequest(args),
+              short_response: false,
+            };
+
+            return args.tapd[type][method](request, (err: any, res: any) => {
+              if (isConnectionFailure({err})) {
+                return cbk([503, 'FailedToConnectToTapdToFundMintBatch']);
+              }
+
+              if (isPermissionDenied({err})) {
+                return cbk([403, 'PermissionDeniedToFundMintBatch']);
+              }
+
+              const knownError = mintRpcError({err});
+
+              if (!!knownError) {
+                return cbk(knownError);
+              }
+
+              if (!!err) {
+                return cbk([503, 'UnexpectedErrorFundingMintBatch', {err}]);
+              }
+
+              if (!res || !res.batch) {
+                return cbk([503, 'ExpectedMintBatchInFundBatchResponse']);
+              }
+
+              try {
+                return cbk(null, rpcBatchAsBatch(res.batch));
+              } catch (err: any) {
+                return cbk([503, err.message]);
+              }
+            });
+          },
+        ],
+      },
+      returnResult({reject, resolve, of: 'fund'}, cbk),
+    );
+  });
+};
+
+export default fundMintBatch;

package/src/tapd_methods/mint/get_mint_batches.ts

@@ -0,0 +1,162 @@
+import {auto as asyncAuto} from 'async';
+import {returnResult} from 'asyncjs-util';
+
+import {isConnectionFailure} from '../../tapd_requests/index.js';
+import {isPermissionDenied} from '../../tapd_requests/index.js';
+import {isTapd} from '../../tapd_requests/index.js';
+import {mintRpcError} from '../../tapd_responses/index.js';
+import {rpcBatchAsBatch} from '../../tapd_responses/index.js';
+import type {Batch} from '../../tapd_responses/index.js';
+import type {AuthenticatedTapdArgs} from '../../typescript/index.js';
+import type {TapdCallback} from '../../typescript/index.js';
+import type {TapdError} from '../../typescript/index.js';
+import type {TapdMethod} from '../../typescript/index.js';
+
+const {isArray} = Array;
+const isBatchKey = (n: string) => /^0[23][0-9A-F]{64}$/i.test(n);
+const method = 'listBatches';
+const type = 'mint';
+
+export type GetMintBatchesArgs = AuthenticatedTapdArgs<{
+  /** Batch Key Hex String */
+  id?: string;
+  /** Include Group Details of Unsealed Assets */
+  is_verbose?: boolean;
+}>;
+
+export type GetMintBatchesResult = {
+  batches: Batch[];
+};
+
+type Tasks = {
+  getBatches: GetMintBatchesResult;
+  validate: undefined;
+};
+
+/** Get mint batches, including pending and cancelled batches
+
+  Requires `mint:read` permission
+
+  With `is_verbose`, a funded pending batch has the group details of its
+  unsealed assets, and tapd does not return unfunded or empty batches.
+
+  {
+    [id]: <Batch Key Hex String>
+    [is_verbose]: <Include Group Details of Unsealed Assets Bool>
+    tapd: <Authenticated tapd API Object>
+  }
+
+  @returns via cbk or Promise
+  {
+    batches: [{
+      assets: [{
+        amount: <Asset Units Numeric String>
+        [group_anchor]: <Name of the Asset That Anchors a New Group String>
+        [group_internal_key]: <Group Internal Public Key Hex String>
+        [group_key]: <Group Key Hex String>
+        [group_tapscript_root]: <Group Tapscript Root Hex String>
+        is_collectible: <Asset Is Collectible Bool>
+        is_new_group: <Asset Starts a New Group Bool>
+        [metadata]: <Metadata Hex String>
+        [metadata_hash]: <Metadata Hash Hex String>
+        [metadata_type]: <Metadata Type String> // json, opaque
+        name: <Asset Name String>
+        [script_key]: <Script Key Hex String>
+        version: <Asset Version Number>
+      }]
+      created_at: <Created At ISO 8601 Date String>
+      created_height: <Block Height When Created Number>
+      id: <Batch Key Hex String>
+      [psbt]: <Genesis Transaction PSBT Hex String>
+      state: <Batch State String>
+      [transaction_id]: <Genesis Transaction Id Hex String>
+      unsealed_assets: [{
+        amount: <Asset Units Numeric String>
+        [group_anchor]: <Name of the Asset That Anchors a New Group String>
+        [group_internal_key]: <Group Internal Public Key Hex String>
+        [group_key]: <Group Key Hex String>
+        [group_tapscript_root]: <Group Tapscript Root Hex String>
+        [group_virtual_psbt]: <Group Virtual Transaction PSBT Hex String>
+        [group_virtual_transaction]: <Group Virtual Transaction Hex String>
+        is_collectible: <Asset Is Collectible Bool>
+        is_new_group: <Asset Starts a New Group Bool>
+        [metadata]: <Metadata Hex String>
+        [metadata_hash]: <Metadata Hash Hex String>
+        [metadata_type]: <Metadata Type String> // json, opaque
+        name: <Asset Name String>
+        [script_key]: <Script Key Hex String>
+        version: <Asset Version Number>
+      }]
+    }]
+  }
+*/
+const getMintBatches: TapdMethod<GetMintBatchesArgs, GetMintBatchesResult> = (
+  args: GetMintBatchesArgs,
+  cbk?: TapdCallback<GetMintBatchesResult>,
+) => {
+  return new Promise((resolve, reject) => {
+    return asyncAuto<Tasks, TapdError>(
+      {
+        // Check arguments
+        validate: cbk => {
+          if (args.id !== undefined && !isBatchKey(args.id)) {
+            return cbk([400, 'ExpectedBatchKeyToGetMintBatches']);
+          }
+
+          if (!isTapd({method, type, tapd: args.tapd})) {
+            return cbk([400, 'ExpectedAuthenticatedTapdToGetMintBatches']);
+          }
+
+          return cbk();
+        },
+
+        // Get the batches
+        getBatches: [
+          'validate',
+          ({}, cbk) => {
+            const request = {
+              batch_key: !args.id ? undefined : Buffer.from(args.id, 'hex'),
+              verbose: !!args.is_verbose,
+            };
+
+            return args.tapd[type][method](request, (err: any, res: any) => {
+              if (isConnectionFailure({err})) {
+                return cbk([503, 'FailedToConnectToTapdToGetMintBatches']);
+              }
+
+              if (isPermissionDenied({err})) {
+                return cbk([403, 'PermissionDeniedToGetMintBatches']);
+              }
+
+              const knownError = mintRpcError({err});
+
+              if (!!knownError) {
+                return cbk(knownError);
+              }
+
+              if (!!err) {
+                return cbk([503, 'UnexpectedErrorGettingMintBatches', {err}]);
+              }
+
+              if (!res || !isArray(res.batches)) {
+                return cbk([
+                  503,
+                  'ExpectedArrayOfBatchesInListBatchesResponse',
+                ]);
+              }
+
+              try {
+                return cbk(null, {batches: res.batches.map(rpcBatchAsBatch)});
+              } catch (err: any) {
+                return cbk([503, err.message]);
+              }
+            });
+          },
+        ],
+      },
+      returnResult({reject, resolve, of: 'getBatches'}, cbk),
+    );
+  });
+};
+
+export default getMintBatches;

package/src/tapd_methods/mint/index.ts

@@ -0,0 +1,20 @@
+export {default as addAssetToMintBatch} from './add_asset_to_mint_batch.js';
+export type {AddAssetToMintBatchArgs} from './add_asset_to_mint_batch.js';
+export type {AddAssetToMintBatchResult} from './add_asset_to_mint_batch.js';
+export {default as cancelMintBatch} from './cancel_mint_batch.js';
+export type {CancelMintBatchArgs} from './cancel_mint_batch.js';
+export type {CancelMintBatchResult} from './cancel_mint_batch.js';
+export {default as finalizeMintBatch} from './finalize_mint_batch.js';
+export type {FinalizeMintBatchArgs} from './finalize_mint_batch.js';
+export type {FinalizeMintBatchResult} from './finalize_mint_batch.js';
+export {default as fundMintBatch} from './fund_mint_batch.js';
+export type {FundMintBatchArgs} from './fund_mint_batch.js';
+export type {FundMintBatchResult} from './fund_mint_batch.js';
+export {default as getMintBatches} from './get_mint_batches.js';
+export type {GetMintBatchesArgs} from './get_mint_batches.js';
+export type {GetMintBatchesResult} from './get_mint_batches.js';
+export {default as sealMintBatch} from './seal_mint_batch.js';
+export type {SealMintBatchArgs} from './seal_mint_batch.js';
+export type {SealMintBatchResult} from './seal_mint_batch.js';
+export {default as subscribeToMintEvents} from './subscribe_to_mint_events.js';
+export type {SubscribeToMintEventsArgs} from './subscribe_to_mint_events.js';

package/src/tapd_methods/mint/seal_mint_batch.ts

@@ -0,0 +1,184 @@
+import {auto as asyncAuto} from 'async';
+import {returnResult} from 'asyncjs-util';
+
+import {isConnectionFailure} from '../../tapd_requests/index.js';
+import {isPermissionDenied} from '../../tapd_requests/index.js';
+import {isTapd} from '../../tapd_requests/index.js';
+import {mintRpcError} from '../../tapd_responses/index.js';
+import {rpcBatchAsBatch} from '../../tapd_responses/index.js';
+import type {Batch} from '../../tapd_responses/index.js';
+import type {AuthenticatedTapdArgs} from '../../typescript/index.js';
+import type {TapdCallback} from '../../typescript/index.js';
+import type {TapdError} from '../../typescript/index.js';
+import type {TapdMethod} from '../../typescript/index.js';
+
+const hexAsBase64 = (n: string) => Buffer.from(n, 'hex').toString('base64');
+const {isArray} = Array;
+const isAssetId = (n: unknown) => /^[0-9A-F]{64}$/i.test(String(n));
+const isHex = (n: unknown) => /^([0-9A-F]{2})+$/i.test(String(n));
+const method = 'sealBatch';
+const type = 'mint';
+
+export type SealMintBatchArgs = AuthenticatedTapdArgs<{
+  group_witnesses?: {
+    /** Asset Id Hex String */
+    asset_id: string;
+    /** Witness Stack Element Hex Strings */
+    witness: string[];
+  }[];
+  /** Signed Group Virtual Transaction PSBT Hex Strings */
+  signed_group_psbts?: string[];
+}>;
+
+export type SealMintBatchResult = Batch;
+
+type Tasks = {
+  seal: SealMintBatchResult;
+  validate: undefined;
+};
+
+/** Seal the pending mint batch with asset group witnesses
+
+  Requires `mint:write` permission
+
+  This is only necessary when an asset in the batch has a group key that needs
+  an external signer. Fund the batch first with `fundMintBatch`, and sign the
+  `group_virtual_psbt` of each unsealed asset.
+
+  tapd signs the group witnesses that are not given
+
+  Give `group_witnesses` or `signed_group_psbts`, not both
+
+  {
+    [group_witnesses]: [{
+      asset_id: <Asset Id Hex String>
+      witness: [<Witness Stack Element Hex String>]
+    }]
+    [signed_group_psbts]: [<Signed Group Virtual Transaction PSBT Hex String>]
+    tapd: <Authenticated tapd API Object>
+  }
+
+  @returns via cbk or Promise
+  {
+    assets: [{
+      amount: <Asset Units Numeric String>
+      [group_anchor]: <Name of the Asset That Anchors a New Group String>
+      [group_internal_key]: <Group Internal Public Key Hex String>
+      [group_key]: <Group Key Hex String>
+      [group_tapscript_root]: <Group Tapscript Root Hex String>
+      is_collectible: <Asset Is Collectible Bool>
+      is_new_group: <Asset Starts a New Group Bool>
+      [metadata]: <Metadata Hex String>
+      [metadata_hash]: <Metadata Hash Hex String>
+      [metadata_type]: <Metadata Type String> // json, opaque
+      name: <Asset Name String>
+      [script_key]: <Script Key Hex String>
+      version: <Asset Version Number>
+    }]
+    created_at: <Created At ISO 8601 Date String>
+    created_height: <Block Height When Created Number>
+    id: <Batch Key Hex String>
+    [psbt]: <Genesis Transaction PSBT Hex String>
+    state: <Batch State String>
+    [transaction_id]: <Genesis Transaction Id Hex String>
+    unsealed_assets: []
+  }
+*/
+const sealMintBatch: TapdMethod<SealMintBatchArgs, SealMintBatchResult> = (
+  args: SealMintBatchArgs,
+  cbk?: TapdCallback<SealMintBatchResult>,
+) => {
+  return new Promise((resolve, reject) => {
+    return asyncAuto<Tasks, TapdError>(
+      {
+        // Check arguments
+        validate: cbk => {
+          const psbts = args.signed_group_psbts;
+          const witnesses = args.group_witnesses;
+
+          if (!!witnesses && !!psbts) {
+            return cbk([400, 'ExpectedGroupWitnessesOrSignedPsbtsNotBoth']);
+          }
+
+          if (!!witnesses && !isArray(witnesses)) {
+            return cbk([400, 'ExpectedArrayOfGroupWitnessesToSealMintBatch']);
+          }
+
+          if (!!witnesses && witnesses.some(n => !isAssetId(n?.asset_id))) {
+            return cbk([400, 'ExpectedAssetIdForGroupWitnessToSealMintBatch']);
+          }
+
+          if (!!witnesses) {
+            const isValid = (n: {witness: string[]}) => {
+              return isArray(n.witness) && n.witness.every(isHex);
+            };
+
+            if (!witnesses.every(isValid)) {
+              return cbk([400, 'ExpectedHexWitnessStackToSealMintBatch']);
+            }
+          }
+
+          if (!!psbts && (!isArray(psbts) || !psbts.every(isHex))) {
+            return cbk([400, 'ExpectedHexSignedGroupPsbtsToSealMintBatch']);
+          }
+
+          if (!isTapd({method, type, tapd: args.tapd})) {
+            return cbk([400, 'ExpectedAuthenticatedTapdToSealMintBatch']);
+          }
+
+          return cbk();
+        },
+
+        // Seal the batch
+        seal: [
+          'validate',
+          ({}, cbk) => {
+            const request = {
+              group_witnesses: (args.group_witnesses || []).map(n => ({
+                genesis_id: Buffer.from(n.asset_id, 'hex'),
+                witness: n.witness.map(element => Buffer.from(element, 'hex')),
+              })),
+              short_response: false,
+              signed_group_virtual_psbts: (args.signed_group_psbts || []).map(
+                hexAsBase64,
+              ),
+            };
+
+            return args.tapd[type][method](request, (err: any, res: any) => {
+              if (isConnectionFailure({err})) {
+                return cbk([503, 'FailedToConnectToTapdToSealMintBatch']);
+              }
+
+              if (isPermissionDenied({err})) {
+                return cbk([403, 'PermissionDeniedToSealMintBatch']);
+              }
+
+              const knownError = mintRpcError({err});
+
+              if (!!knownError) {
+                return cbk(knownError);
+              }
+
+              if (!!err) {
+                return cbk([503, 'UnexpectedErrorSealingMintBatch', {err}]);
+              }
+
+              if (!res) {
+                return cbk([503, 'ExpectedResponseToSealMintBatch']);
+              }
+
+              try {
+                return cbk(null, rpcBatchAsBatch({batch: res.batch}));
+              } catch (err: any) {
+                return cbk([503, err.message]);
+              }
+            });
+          },
+        ],
+      },
+      returnResult({reject, resolve, of: 'seal'}, cbk),
+    );
+  });
+};
+
+export default sealMintBatch;

package/src/tapd_methods/mint/subscribe_to_mint_events.ts

@@ -0,0 +1,104 @@
+import EventEmitter from 'node:events';
+
+import {emitSubscriptionError} from '../../grpc/index.js';
+import {handleRemoveListener} from '../../grpc/index.js';
+import {isTapd} from '../../tapd_requests/index.js';
+import {batchStates} from '../../tapd_responses/index.js';
+import {rpcBatchAsBatch} from '../../tapd_responses/index.js';
+import type {AuthenticatedTapdArgs} from '../../typescript/index.js';
+
+const events = ['batch'];
+const isNumeric = (n: unknown) => typeof n === 'string' && /^\d+$/.test(n);
+const method = 'subscribeMintEvents';
+const microsecondsPerMillisecond = 1e3;
+const type = 'mint';
+
+export type SubscribeToMintEventsArgs = AuthenticatedTapdArgs;
+
+/** Subscribe to the state changes of mint batches
+
+  Requires `mint:read` permission
+
+  {
+    tapd: <Authenticated tapd API Object>
+  }
+
+  @throws
+  <Error>
+
+  @returns
+  <EventEmitter Object>
+
+  // A mint batch changed state, or it failed to change state
+  @event 'batch'
+  {
+    at: <Event At ISO 8601 Date String>
+    batch: {
+      assets: [{
+        amount: <Asset Units Numeric String>
+        [group_anchor]: <Name of the Asset That Anchors a New Group String>
+        [group_internal_key]: <Group Internal Public Key Hex String>
+        [group_key]: <Group Key Hex String>
+        [group_tapscript_root]: <Group Tapscript Root Hex String>
+        is_collectible: <Asset Is Collectible Bool>
+        is_new_group: <Asset Starts a New Group Bool>
+        [metadata]: <Metadata Hex String>
+        [metadata_hash]: <Metadata Hash Hex String>
+        [metadata_type]: <Metadata Type String> // json, opaque
+        name: <Asset Name String>
+        [script_key]: <Script Key Hex String>
+        version: <Asset Version Number>
+      }]
+      created_at: <Created At ISO 8601 Date String>
+      created_height: <Block Height When Created Number>
+      id: <Batch Key Hex String>
+      [psbt]: <Genesis Transaction PSBT Hex String>
+      state: <Batch State String>
+      [transaction_id]: <Genesis Transaction Id Hex String>
+      unsealed_assets: []
+    }
+    [error]: <State Change Error String>
+    state: <Last Done Batch State String>
+  }
+*/
+export default ({tapd}: SubscribeToMintEventsArgs): EventEmitter => {
+  if (!isTapd({method, type, tapd})) {
+    throw new Error('ExpectedAuthenticatedTapdToSubscribeToMintEvents');
+  }
+
+  const emitter = new EventEmitter();
+  const subscription = tapd[type][method]({short_response: false});
+
+  const errored = emitSubscriptionError({emitter, subscription});
+
+  // Terminate the subscription when all listeners are removed
+  handleRemoveListener({emitter, events, subscription});
+
+  subscription.on('end', () => emitter.emit('end'));
+  subscription.on('error', (err: any) => errored(err));
+  subscription.on('status', (n: unknown) => emitter.emit('status', n));
+
+  subscription.on('data', (event: any) => {
+    try {
+      if (!event || !isNumeric(event.timestamp)) {
+        throw new Error('ExpectedTimestampInMintEvent');
+      }
+
+      const batch = rpcBatchAsBatch({batch: event.batch});
+
+      const ms = Number(event.timestamp) / microsecondsPerMillisecond;
+
+      // Notify listeners of the batch event
+      return emitter.emit('batch', {
+        batch,
+        at: new Date(ms).toISOString(),
+        error: event.error || undefined,
+        state: batchStates[event.batch_state] || 'unknown',
+      });
+    } catch (err: any) {
+      return errored([503, err.message] as any);
+    }
+  });
+
+  return emitter;
+};