feat!: Upgrade to casper-js-sdk 5.x

package.json

@@ -39,15 +39,15 @@
     "ts-results": "^3.3.0"
   },
   "peerDependencies": {
-    "casper-js-sdk": "^2.12.0"
+    "casper-js-sdk": "^5.0.11-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": "^2.12.0",
+    "casper-js-sdk": "^5.0.11-beta2",
     "copy-webpack-plugin": "^11.0.0",
     "crypto-browserify": "^3.12.0",
     "eslint": "^8.34.0",

src/event.ts

@@ -1,29 +1,23 @@
-import { CLValue, decodeBase16, matchByteParserByCLType } from 'casper-js-sdk';
-import { WithRemainder } from './casper/types';
+import {CLTypeString, CLValue, CLValueParser, Conversions, Hash, IResultWithBytes} from 'casper-js-sdk';
 
-import {
-  parseBytesWithRemainder,
-  parseCLValueFromBytesWithRemainder,
-} from './casper/utils';
-import { Schema, Schemas } from './schema';
+import {Schema, Schemas} from './schema';
 
 const EVENT_PREFIX = 'event_';
 
 export interface Event {
   name: string;
-  contractHash: Uint8Array | null;
-  contractPackageHash: Uint8Array | null;
+  contractHash: Hash | null;
+  contractPackageHash: Hash | null;
+  eventId: number;
   data: Record<string, CLValue>;
 }
 
 export function parseEventNameWithRemainder(
   rawEvent: Uint8Array,
-): WithRemainder<string> {
-  const eventNameWithRemainder = parseBytesWithRemainder(rawEvent);
+): IResultWithBytes<string> {
+  const eventNameWithRemainder = CLValueParser.fromBytesByType(rawEvent, CLTypeString);
 
-  const eventNameWithPrefix = new TextDecoder().decode(
-    eventNameWithRemainder.data,
-  );
+  const eventNameWithPrefix = eventNameWithRemainder.result.toString();
 
   if (!eventNameWithPrefix.startsWith(EVENT_PREFIX)) {
     throw new Error('no event_ prefix for event');
@@ -32,8 +26,8 @@
   const eventName = eventNameWithPrefix.replace('event_', '');
 
   return {
-    data: eventName,
-    remainder: eventNameWithRemainder.remainder,
+    result: eventName,
+    bytes: eventNameWithRemainder.bytes,
   };
 }
 
@@ -44,28 +38,28 @@
   name: string;
   data: Record<string, CLValue>;
 } {
-  const event = decodeBase16(rawEvent);
+  const event = Conversions.decodeBase16(rawEvent);
 
-  const clValueWithRemainder = parseCLValueFromBytesWithRemainder(event);
+  const clValueWithRemainder = CLValueParser.fromBytesWithType(event);
 
-  if (clValueWithRemainder.data.bytes.length < 4) {
+  if (clValueWithRemainder.result.bytes().length < 4) {
     throw new Error('invalid event bytes');
   }
 
   const eventNameWithRemainder = parseEventNameWithRemainder(
-    clValueWithRemainder.data.bytes.subarray(4),
+    clValueWithRemainder.result.bytes().subarray(4),
   );
 
-  const eventSchema = schemas[eventNameWithRemainder.data];
+  const eventSchema = schemas[eventNameWithRemainder.result];
   if (!eventSchema) {
     throw new Error('event name not in schema');
   }
 
   return {
-    name: eventNameWithRemainder.data,
+    name: eventNameWithRemainder.result,
     data: parseEventDataFromBytes(
       eventSchema,
-      eventNameWithRemainder.remainder,
+      eventNameWithRemainder.bytes,
     ),
   };
 }
@@ -79,19 +73,14 @@
   let remainder = rawBytes;
 
   for (const item of schema) {
-    const parser = matchByteParserByCLType(item.value).unwrap();
-
-    const clValueWithRemainder = parser.fromBytesWithRemainder(
-      remainder,
-      item.value,
-    );
+    const clValueWithRemainder = CLValueParser.fromBytesByType(remainder, item.value);
 
-    if (!clValueWithRemainder.remainder) {
+    if (!clValueWithRemainder.bytes) {
       throw new Error('remainder is empty');
     }
 
-    result[item.property] = clValueWithRemainder.result.unwrap();
-    remainder = clValueWithRemainder.remainder;
+    result[item.property] = clValueWithRemainder.result;
+    remainder = clValueWithRemainder.bytes;
   }
 
   return result;

src/index.ts

@@ -11,8 +11,3 @@ export {
   parseEventDataFromBytes,
   parseEventNameWithRemainder,
 } from './event';
-export { ExecutionResult } from './casper/types';
-export {
-  parseBytesWithRemainder,
-  parseCLValueFromBytesWithRemainder,
-} from './casper/utils';