fix: Fix lint errors and upgrade casper-js-sdk

Author: Volodymyr-Kuchinskyi

package-lock.json

@@ -39,15 +39,15 @@
     "ts-results": "^3.3.0"
   },
   "peerDependencies": {
-    "casper-js-sdk": "^5.0.11-beta2"
+    "casper-js-sdk": "^5.0.12-beta2"
   },
   "devDependencies": {
     "@types/jest": "^29.4.0",
     "@typescript-eslint/eslint-plugin": "^5.53.0",
     "@typescript-eslint/parser": "^5.53.0",
     "browserify-zlib": "^0.2.0",
     "buffer": "^6.0.3",
-    "casper-js-sdk": "^5.0.11-beta2",
+    "casper-js-sdk": "^5.0.12-beta2",
     "copy-webpack-plugin": "^11.0.0",
     "crypto-browserify": "^3.12.0",
     "eslint": "^8.34.0",

package.json

@@ -1,6 +1,13 @@
-import {CLTypeString, CLValue, CLValueParser, Conversions, Hash, IResultWithBytes} from 'casper-js-sdk';
+import {
+  CLTypeString,
+  CLValue,
+  CLValueParser,
+  Conversions,
+  Hash,
+  IResultWithBytes,
+} from 'casper-js-sdk';
 
-import {Schema, Schemas} from './schema';
+import { Schema, Schemas } from './schema';
 
 const EVENT_PREFIX = 'event_';
 
@@ -15,7 +22,10 @@ export interface Event {
 export function parseEventNameWithRemainder(
   rawEvent: Uint8Array,
 ): IResultWithBytes<string> {
-  const eventNameWithRemainder = CLValueParser.fromBytesByType(rawEvent, CLTypeString);
+  const eventNameWithRemainder = CLValueParser.fromBytesByType(
+    rawEvent,
+    CLTypeString,
+  );
 
   const eventNameWithPrefix = eventNameWithRemainder.result.toString();
 
@@ -57,10 +67,7 @@ export function parseEventNameAndData(
 
   return {
     name: eventNameWithRemainder.result,
-    data: parseEventDataFromBytes(
-      eventSchema,
-      eventNameWithRemainder.bytes,
-    ),
+    data: parseEventDataFromBytes(eventSchema, eventNameWithRemainder.bytes),
   };
 }
 
@@ -73,7 +80,10 @@ export function parseEventDataFromBytes(
   let remainder = rawBytes;
 
   for (const item of schema) {
-    const clValueWithRemainder = CLValueParser.fromBytesByType(remainder, item.value);
+    const clValueWithRemainder = CLValueParser.fromBytesByType(
+      remainder,
+      item.value,
+    );
 
     if (!clValueWithRemainder.bytes) {
       throw new Error('remainder is empty');

src/event.ts

@@ -11,8 +11,12 @@ import {
   RpcClient,
   TypeID,
 } from 'casper-js-sdk';
-import {Event, parseEventDataFromBytes, parseEventNameWithRemainder,} from './event';
-import {parseSchemasFromBytes, Schemas} from './schema';
+import {
+  Event,
+  parseEventDataFromBytes,
+  parseEventNameWithRemainder,
+} from './event';
+import { parseSchemasFromBytes, Schemas } from './schema';
 
 export interface ContractMetadata {
   schemas: Schemas;
@@ -23,9 +27,9 @@ export interface ContractMetadata {
 }
 
 interface Dictionary {
-  uref: string,
-  key: string,
-  value: Uint8Array,
+  uref: string;
+  key: string;
+  value: Uint8Array;
 }
 
 export const EVENTS_SCHEMA_NAMED_KEY = '__events_schema';
@@ -64,7 +68,11 @@ export class Parser {
 
     for (const contractHash of contractHashes) {
       const contractData = (
-        await rpcClient.getStateItem(stateRootHash.stateRootHash.toHex(), `hash-${contractHash}`, [])
+        await rpcClient.getStateItem(
+          stateRootHash.stateRootHash.toHex(),
+          `hash-${contractHash}`,
+          [],
+        )
       ).storedValue.contract;
 
       const namedKeys = Object.values(contractData!.namedKeys);
@@ -73,8 +81,8 @@ export class Parser {
         throw new Error('contract data not found');
       }
 
-      let eventsSchemaUref = "";
-      let eventsUref = "";
+      let eventsSchemaUref = '';
+      let eventsUref = '';
 
       for (const namedKey of namedKeys) {
         if (namedKey.name === EVENTS_SCHEMA_NAMED_KEY) {
@@ -83,7 +91,7 @@ export class Parser {
           eventsUref = namedKey.key;
         }
 
-        if (eventsSchemaUref !== "" && eventsUref !== "") {
+        if (eventsSchemaUref !== '' && eventsUref !== '') {
           break;
         }
       }
@@ -96,12 +104,20 @@ export class Parser {
         throw new Error(`no '${EVENTS_NAMED_KEY}' uref found`);
       }
 
-      const schemaResponse = await rpcClient.getStateItem(stateRootHash.stateRootHash.toHex(), eventsSchemaUref.toString(), []);
+      const schemaResponse = await rpcClient.getStateItem(
+        stateRootHash.stateRootHash.toHex(),
+        eventsSchemaUref.toString(),
+        [],
+      );
       if (!schemaResponse.storedValue.clValue) {
         throw new Error(`no schema uref for ${eventsSchemaUref}`);
       }
 
-      const schemas = parseSchemasFromBytes(Conversions.decodeBase16(schemaResponse.rawJSON.stored_value.CLValue.bytes));
+      const schemas = parseSchemasFromBytes(
+        Conversions.decodeBase16(
+          schemaResponse.rawJSON.stored_value.CLValue.bytes,
+        ),
+      );
 
       contractsSchemas[eventsUref.toString()] = {
         schemas,
@@ -142,9 +158,7 @@ export class Parser {
       try {
         dictionary = this.newDictionaryFromBytes(clValue.any.bytes());
 
-        eventNameWithRemainder = parseEventNameWithRemainder(
-          dictionary.value,
-        );
+        eventNameWithRemainder = parseEventNameWithRemainder(dictionary.value);
       } catch (err) {
         continue;
       }
@@ -170,7 +184,8 @@ export class Parser {
       parsedEvent.contractHash = contractMetadata.contractHash;
       parsedEvent.contractPackageHash = contractMetadata.contractPackageHash;
 
-      const eventSchema = contractMetadata.schemas[eventNameWithRemainder.result];
+      const eventSchema =
+        contractMetadata.schemas[eventNameWithRemainder.result];
       if (!eventSchema) {
         results.push({
           event: parsedEvent,
@@ -213,28 +228,41 @@ export class Parser {
 
     const clValue = CLValueParser.fromBytesWithType(u32.bytes);
 
-    if (!(clValue.result.type instanceof CLTypeList) || clValue.result.type.elementsType.getTypeID() !== TypeID.U8) {
+    if (
+      !(clValue.result.type instanceof CLTypeList) ||
+      clValue.result.type.elementsType.getTypeID() !== TypeID.U8
+    ) {
       throw new Error('failed to parse CLList(CLU8) from bytes');
     }
 
     const clValueByteSize = CLValueUInt32.fromBytes(clValue.bytes);
 
-    const clByteArrayAsUref = CLValueParser.fromBytesByType(clValueByteSize.bytes, new CLTypeByteArray(clValueByteSize.result.toNumber()));
+    const clByteArrayAsUref = CLValueParser.fromBytesByType(
+      clValueByteSize.bytes,
+      new CLTypeByteArray(clValueByteSize.result.toNumber()),
+    );
     if (!clByteArrayAsUref.result.byteArray) {
       throw new Error('failed to parse CLByteArray from bytes');
     }
 
-    const uref = `uref-${Conversions.encodeBase16(clByteArrayAsUref.result.byteArray.bytes())}-007`;
+    const uref = `uref-${Conversions.encodeBase16(
+      clByteArrayAsUref.result.byteArray.bytes(),
+    )}-007`;
 
-    const clStringAsDictKey = CLValueParser.fromBytesByType(clByteArrayAsUref.bytes, CLTypeString);
+    const clStringAsDictKey = CLValueParser.fromBytesByType(
+      clByteArrayAsUref.bytes,
+      CLTypeString,
+    );
     if (!clStringAsDictKey.result.stringVal) {
       throw new Error('failed to parse CLString from bytes');
     }
 
     return {
       uref: uref,
       key: clStringAsDictKey.result.stringVal.toString(),
-      value: new Uint8Array(clValue.result.list!.elements.map(el => el.ui8!.toNumber())),
+      value: new Uint8Array(
+        clValue.result.list!.elements.map(el => el.ui8!.toNumber()),
+      ),
     };
   }
 }
@@ -244,7 +272,11 @@ export async function fetchContractSchemasBytes(
   contractHash: string,
   stateRootHash: string,
 ): Promise<Uint8Array> {
-  const schemaResponse = await rpcClient.getStateItem(stateRootHash, `hash-${contractHash}`, [EVENTS_SCHEMA_NAMED_KEY]);
+  const schemaResponse = await rpcClient.getStateItem(
+    stateRootHash,
+    `hash-${contractHash}`,
+    [EVENTS_SCHEMA_NAMED_KEY],
+  );
 
   if (!schemaResponse.storedValue.clValue) {
     throw new Error('no clvalue for contract schema');

src/parser.ts

@@ -6,9 +6,9 @@ import {
   CLValueParser,
   CLValueUInt32,
   IResultWithBytes,
-  RpcClient
+  RpcClient,
 } from 'casper-js-sdk';
-import {EVENTS_SCHEMA_NAMED_KEY} from './parser';
+import { EVENTS_SCHEMA_NAMED_KEY } from './parser';
 
 export type Schemas = Record<string, Schema>;
 
@@ -67,7 +67,9 @@ export function parseSchemaFromBytesWithRemainder(
   for (let i = 0; i < fieldsNumber; i++) {
     const fieldName = CLValueParser.fromBytesByType(remainder, CLTypeString);
 
-    const clTypeWithRemainder = CLTypeParser.matchBytesToCLType(fieldName.bytes);
+    const clTypeWithRemainder = CLTypeParser.matchBytesToCLType(
+      fieldName.bytes,
+    );
 
     if (!clTypeWithRemainder.bytes) {
       throw new Error('remainder is empty');
@@ -92,7 +94,11 @@ export async function fetchContractSchemasBytes(
   contractHash: string,
   stateRootHash: string,
 ): Promise<Uint8Array> {
-  const contractData = await rpcClient.getStateItem(stateRootHash, `hash-${contractHash}`, []);
+  const contractData = await rpcClient.getStateItem(
+    stateRootHash,
+    `hash-${contractHash}`,
+    [],
+  );
 
   if (!contractData || !contractData.storedValue.contract) {
     throw new Error('contract data not found');
@@ -107,7 +113,11 @@ export async function fetchContractSchemasBytes(
     );
   }
 
-  const schemaResponse = await rpcClient.getStateItem(stateRootHash, eventsSchema.key.toString(), []);
+  const schemaResponse = await rpcClient.getStateItem(
+    stateRootHash,
+    eventsSchema.key.toString(),
+    [],
+  );
 
   if (!schemaResponse.storedValue.clValue) {
     throw new Error('no CLValue for schema');