Merge pull request #675 from LF-Decentralized-Trust-labs/sdk-updates

Misc sdk updates

Author: dwertent

example/event-listener/src/index.ts

@@ -95,7 +95,10 @@ async function main(): Promise<boolean> {
       subscriptions: ["example-event-listener"],
     },
     async (sender, event) => {
-      if (event.method === "ptx_subscription") {
+      if (
+        event.method === "ptx_subscription" &&
+        "receipts" in event.params.result
+      ) {
         for (const receipt of event.params.result.receipts) {
           // Process each transaction receipt
           await processReceipt(receipt);

example/swap/src/index.ts

@@ -183,7 +183,6 @@ async function main(): Promise<boolean> {
       },
     ],
   });
-  if (!checkReceipt(receipt)) return false;
   const preparedCashTransfer = await paladin3.pollForPreparedTransaction(
     txID,
     10000

sdk/typescript/src/interfaces/blockchainevent.ts

@@ -0,0 +1,18 @@
+import { ethers } from "ethers";
+
+export interface IBlockchainEventListener {
+  name: string;
+  sources: IBlockchainEventListenerSource[];
+  options?: IBlockchainEventListenerOptions;
+}
+
+export interface IBlockchainEventListenerOptions {
+  batchSize?: number;
+  batchTimeout?: string;
+  fromBlock?: string;
+}
+
+export interface IBlockchainEventListenerSource {
+  abi: ethers.JsonFragment[];
+  address?: string;
+}

sdk/typescript/src/interfaces/blockindex.ts

@@ -0,0 +1,33 @@
+export interface IIndexedBlock {
+  number: number;
+  hash: string;
+  timestamp: number;
+}
+
+export interface IIndexedTransaction {
+  hash: string;
+  blockNumber: number;
+  transactionIndex: number;
+  from?: string;
+  to?: string;
+  nonce: number;
+  contractAddress?: string;
+  result?: "failure" | "success";
+  block?: IIndexedBlock;
+}
+
+export interface IIndexedEvent {
+  blockNumber: number;
+  transactionIndex: number;
+  logIndex: number;
+  transactionHash: string;
+  signature: string;
+  transaction?: IIndexedTransaction;
+  block?: IIndexedBlock;
+}
+
+export interface IEventWithData extends IIndexedEvent {
+  soliditySignature: string;
+  address: string;
+  data: any;
+}

sdk/typescript/src/interfaces/transaction.ts

@@ -154,24 +154,13 @@ export enum TransactionType {
   Public = "public",
 }
 
-export interface IDecodedEvent {
+export interface IABIDecodedData {
   signature: string;
   definition: ethers.JsonFragment;
   data: any;
   summary: string; // errors only
 }
 
-export interface IEventWithData {
-  blockNumber: number;
-  transactionIndex: number;
-  logIndex: number;
-  transactionHash: string;
-  signature: string;
-  soliditySignature: string;
-  address: string;
-  data: any;
-}
-
 export interface IStoredABI {
   hash: string;
   abi: ethers.InterfaceAbi;

sdk/typescript/src/interfaces/websocket.ts

@@ -1,7 +1,8 @@
 import * as http from "http";
 import WebSocket from "ws";
-import { ITransactionReceipt } from "./transaction";
+import { IEventWithData } from "./blockindex";
 import { Logger } from "./logger";
+import { ITransactionReceipt } from "./transaction";
 
 export interface WebSocketSender {
   send: (json: object) => void;
@@ -18,22 +19,35 @@ export interface WebSocketEventCallback {
 
 export interface WebSocketClientOptions {
   url: string;
-  subscriptions?: string[];
   username?: string;
   password?: string;
+  subscriptions?: string[] | WebSocketSubscription[]; // TODO: deprecate string[]
   logger?: Logger;
   heartbeatInterval?: number;
   reconnectDelay?: number;
   afterConnect?: WebSocketConnectCallback;
   socketOptions?: WebSocket.ClientOptions | http.ClientRequestArgs;
 }
 
+export interface WebSocketSubscription {
+  type: "receipts" | "blockchainevents";
+  name: string;
+}
+
 export interface WebSocketEvent {
   method: "ptx_subscription" | undefined;
   params: {
     subscription: string;
-    result: {
-      receipts: ITransactionReceipt[];
-    };
+    result: TransactionReceiptBatch | TransactionEventBatch;
   };
 }
+
+export interface TransactionReceiptBatch {
+  batchId: number;
+  receipts: ITransactionReceipt[];
+}
+
+export interface TransactionEventBatch {
+  batchId: number;
+  events: IEventWithData[];
+}

sdk/typescript/src/paladin.ts

@@ -8,6 +8,8 @@ import {
   StateStatus,
   Verifiers,
 } from "./interfaces";
+import { IBlockchainEventListener } from "./interfaces/blockchainevent";
+import { IEventWithData } from "./interfaces/blockindex";
 import { Logger } from "./interfaces/logger";
 import {
   JsonRpcResult,
@@ -22,8 +24,7 @@ import {
 } from "./interfaces/privacygroups";
 import { IQuery } from "./interfaces/query";
 import {
-  IDecodedEvent,
-  IEventWithData,
+  IABIDecodedData,
   INotoDomainReceipt,
   IPenteDomainReceipt,
   IPreparedTransaction,
@@ -212,8 +213,8 @@ export default class PaladinClient {
 
   async resolveVerifier(
     lookup: string,
-    algorithm: Algorithms,
-    verifierType: Verifiers
+    algorithm: Algorithms | string,
+    verifierType: Verifiers | string
   ) {
     const res = await this.post<JsonRpcResult<string>>("ptx_resolveVerifier", [
       lookup,
@@ -234,9 +235,17 @@ export default class PaladinClient {
     return res.data.result;
   }
 
+  async decodeCall(callData: string, dataFormat: string) {
+    const res = await this.post<JsonRpcResult<IABIDecodedData>>(
+      "ptx_decodeCall",
+      [callData, dataFormat]
+    );
+    return res.data.result;
+  }
+
   async decodeEvent(topics: string[], data: string) {
     try {
-      const res = await this.post<JsonRpcResult<IDecodedEvent>>(
+      const res = await this.post<JsonRpcResult<IABIDecodedData>>(
         "ptx_decodeEvent",
         [topics, data, ""]
       );
@@ -351,4 +360,38 @@ export default class PaladinClient {
     );
     return res.data.result;
   }
+
+  async getReceiptListener(name: string) {
+    const res = await this.post<JsonRpcResult<ITransactionReceiptListener>>(
+      "ptx_getReceiptListener",
+      [name],
+      { validateStatus: (status) => status < 300 || status === 404 }
+    );
+    return res.status === 404 ? undefined : res.data.result;
+  }
+
+  async createBlockchainEventListener(listener: IBlockchainEventListener) {
+    const res = await this.post<JsonRpcResult<boolean>>(
+      "ptx_createBlockchainEventListener",
+      [listener]
+    );
+    return res.data.result;
+  }
+
+  async deleteBlockchainEventListener(name: string) {
+    const res = await this.post<JsonRpcResult<boolean>>(
+      "ptx_deleteBlockchainEventListener",
+      [name]
+    );
+    return res.data.result;
+  }
+
+  async getBlockchainEventListener(name: string) {
+    const res = await this.post<JsonRpcResult<IBlockchainEventListener>>(
+      "ptx_getBlockchainEventListener",
+      [name],
+      { validateStatus: (status) => status < 300 || status === 404 }
+    );
+    return res.status === 404 ? undefined : res.data.result;
+  }
 }

sdk/typescript/src/websocket.ts

@@ -6,6 +6,7 @@ import {
   WebSocketClientOptions,
   WebSocketEvent,
   WebSocketEventCallback,
+  WebSocketSubscription,
 } from "./interfaces/websocket";
 
 export class PaladinWebSocketClient {
@@ -54,10 +55,14 @@ export class PaladinWebSocketClient {
           this.logger.log("Connected");
         }
         this.schedulePing();
-        for (const name of this.options.subscriptions ?? []) {
+        for (const subOrName of this.options.subscriptions ?? []) {
           // Automatically connect subscriptions
-          this.subscribe("receipts", name);
-          this.logger.log(`Started listening on subscription ${name}`);
+          const sub: WebSocketSubscription =
+            typeof subOrName === "string"
+              ? { type: "receipts", name: subOrName }
+              : subOrName;
+          this.subscribe(sub.type, sub.name);
+          this.logger.log(`Started listening on subscription ${sub.name}`);
         }
         if (this.options?.afterConnect !== undefined) {
           this.options.afterConnect(this);