@stacks/blockchain-api-client 4.1.3 → 4.2.0-stacks-2.1.1

package/src/ws/index.ts

@@ -2,11 +2,8 @@ import * as JsonRpcLite from 'jsonrpc-lite';
 import { EventEmitter } from 'eventemitter3';
 import {
   RpcTxUpdateSubscriptionParams,
-  RpcTxUpdateNotificationParams,
   RpcAddressTxSubscriptionParams,
-  RpcAddressTxNotificationParams,
   RpcAddressBalanceSubscriptionParams,
-  RpcAddressBalanceNotificationParams,
   RpcSubscriptionType,
   Block,
   RpcBlockSubscriptionParams,
@@ -14,6 +11,13 @@ import {
   Transaction,
   RpcMicroblockSubscriptionParams,
   RpcMempoolSubscriptionParams,
+  MempoolTransaction,
+  RpcAddressBalanceNotificationParams,
+  RpcAddressTxNotificationParams,
+  NftEvent,
+  RpcNftEventSubscriptionParams,
+  RpcNftAssetEventSubscriptionParams,
+  RpcNftCollectionEventSubscriptionParams,
 } from '@stacks/stacks-blockchain-api-types';
 import { BASE_PATH } from '../generated/runtime';
 
@@ -35,9 +39,12 @@ export class StacksApiWebSocketClient {
     block: (event: Block) => void;
     microblock: (event: Microblock) => void;
     mempool: (event: Transaction) => void;
-    txUpdate: (event: RpcTxUpdateNotificationParams) => any;
+    txUpdate: (event: Transaction | MempoolTransaction) => any;
     addressTxUpdate: (event: RpcAddressTxNotificationParams) => void;
     addressBalanceUpdate: (event: RpcAddressBalanceNotificationParams) => void;
+    nftEventUpdate: (event: NftEvent) => void;
+    nftAssetEventUpdate: (event: NftEvent) => void;
+    nftCollectionEventUpdate: (event: NftEvent) => void;
   }>();
 
   public static async connect(url: string = BASE_PATH): Promise<StacksApiWebSocketClient> {
@@ -93,10 +100,11 @@ export class StacksApiWebSocketClient {
     const method = data.method as RpcSubscriptionType;
     switch (method) {
       case 'tx_update':
-        this.eventEmitter.emit('txUpdate', data.params as RpcTxUpdateNotificationParams);
+        this.eventEmitter.emit('txUpdate', data.params as (Transaction | MempoolTransaction));
         break;
       case 'address_tx_update':
-        this.eventEmitter.emit('addressTxUpdate', data.params as RpcAddressTxNotificationParams);
+        this.eventEmitter.emit('addressTxUpdate',
+          data.params as RpcAddressTxNotificationParams);
         break;
       case 'address_balance_update':
         this.eventEmitter.emit(
@@ -113,6 +121,15 @@ export class StacksApiWebSocketClient {
       case 'mempool':
         this.eventEmitter.emit('mempool', data.params as Transaction);
         break;
+      case 'nft_event':
+        this.eventEmitter.emit('nftEventUpdate', data.params as NftEvent);
+        break;
+      case 'nft_asset_event':
+        this.eventEmitter.emit('nftAssetEventUpdate', data.params as NftEvent);
+        break;
+      case 'nft_collection_event':
+        this.eventEmitter.emit('nftCollectionEventUpdate', data.params as NftEvent);
+        break;
     }
   }
 
@@ -171,11 +188,11 @@ export class StacksApiWebSocketClient {
 
   async subscribeTxUpdates(
     txId: string,
-    update: (event: RpcTxUpdateNotificationParams) => any
+    update: (event: Transaction | MempoolTransaction) => any
   ): Promise<Subscription> {
     const params: RpcTxUpdateSubscriptionParams = { event: 'tx_update', tx_id: txId };
     const subscribed = await this.rpcCall<{ tx_id: string }>('subscribe', params);
-    const listener = (event: RpcTxUpdateNotificationParams) => {
+    const listener = (event: Transaction | MempoolTransaction) => {
       if (event.tx_id === subscribed.tx_id) {
         update(event);
       }
@@ -231,6 +248,71 @@ export class StacksApiWebSocketClient {
       },
     };
   }
+
+  async subscribeNftEventUpdates(update: (event: NftEvent) => any): Promise<Subscription> {
+    const params: RpcNftEventSubscriptionParams = {
+      event: 'nft_event',
+    };
+    await this.rpcCall('subscribe', params);
+    const listener = (event: NftEvent) => {
+      update(event);
+    };
+    this.eventEmitter.addListener('nftEventUpdate', listener);
+    return {
+      unsubscribe: () => {
+        this.eventEmitter.removeListener('nftEventUpdate', listener);
+        return this.rpcCall('unsubscribe', params);
+      },
+    };
+  }
+
+  async subscribeNftAssetEventUpdates(
+    assetIdentifier: string,
+    value: string,
+    update: (event: NftEvent) => any
+  ): Promise<Subscription> {
+    const params: RpcNftAssetEventSubscriptionParams = {
+      event: 'nft_asset_event',
+      asset_identifier: assetIdentifier,
+      value,
+    };
+    const subscribed = await this.rpcCall<{ asset_identifier: string, value: string }>('subscribe', params);
+    const listener = (event: NftEvent) => {
+      if (event.asset_identifier === subscribed.asset_identifier && event.value.hex === subscribed.value) {
+        update(event);
+      }
+    };
+    this.eventEmitter.addListener('nftAssetEventUpdate', listener);
+    return {
+      unsubscribe: () => {
+        this.eventEmitter.removeListener('nftAssetEventUpdate', listener);
+        return this.rpcCall('unsubscribe', params);
+      },
+    };
+  }
+
+  async subscribeNftCollectionEventUpdates(
+    assetIdentifier: string,
+    update: (event: NftEvent) => any
+  ): Promise<Subscription> {
+    const params: RpcNftCollectionEventSubscriptionParams = {
+      event: 'nft_collection_event',
+      asset_identifier: assetIdentifier,
+    };
+    const subscribed = await this.rpcCall<{ asset_identifier: string }>('subscribe', params);
+    const listener = (event: NftEvent) => {
+      if (event.asset_identifier === subscribed.asset_identifier) {
+        update(event);
+      }
+    };
+    this.eventEmitter.addListener('nftCollectionEventUpdate', listener);
+    return {
+      unsubscribe: () => {
+        this.eventEmitter.removeListener('nftCollectionEventUpdate', listener);
+        return this.rpcCall('unsubscribe', params);
+      },
+    };
+  }
 }
 
 export async function connectWebSocketClient(