event APIs

src/cairoUtilFuncGen/event.ts

@@ -76,38 +76,47 @@ export class EventFunction extends StringIndexedFuncGen {
       return existing.name;
     }
 
-    const [params, keysInsertions, dataInsertions] = node.vParameters.vParameters.reduce(
-      ([params, keysInsertions, dataInsertions], param, index) => {
-        const paramType = generalizeType(safeGetNodeType(param, this.ast.inference))[0];
-        const cairoType = CairoType.fromSol(paramType, this.ast, TypeConversionContext.Ref);
-
-        params.push({ name: `param${index}`, type: cairoType.toString() });
-
-        if (param.indexed) {
-          // An indexed parameter should go to the keys array
-          if (isValueType(paramType)) {
-            // If the parameter is a value type, we can just add it to the keys array
-            // as it is, as we do regular abi encoding
-            keysInsertions.push(
-              this.generateSimpleEncodingCode(paramType, 'keys', `param${index}`),
-            );
+    const [params, keysInsertions, dataParams, dataParamTypes] =
+      node.vParameters.vParameters.reduce(
+        ([params, keysInsertions, dataParams, dataParamTypes], param, index) => {
+          const paramType = generalizeType(safeGetNodeType(param, this.ast.inference))[0];
+          const cairoType = CairoType.fromSol(paramType, this.ast, TypeConversionContext.Ref);
+
+          params.push({ name: `param${index}`, type: cairoType.toString() });
+
+          if (param.indexed) {
+            // An indexed parameter should go to the keys array
+            if (isValueType(paramType)) {
+              // If the parameter is a value type, we can just add it to the keys array
+              // as it is, as we do regular abi encoding
+              keysInsertions.push(
+                this.generateSimpleEncodingCode([paramType], 'keys', [`param${index}`]),
+              );
+            } else {
+              // If the parameter is a reference type, we hash the with special encoding
+              // function: more at:
+              //   https://docs.soliditylang.org/en/v0.8.14/abi-spec.html#encoding-of-indexed-event-parameters
+              keysInsertions.push(
+                this.generateComplexEncodingCode([paramType], 'keys', [`param${index}`]),
+              );
+            }
           } else {
-            // If the parameter is a reference type, we hash the with special encoding
-            // function: more at:
-            //   https://docs.soliditylang.org/en/v0.8.14/abi-spec.html#encoding-of-indexed-event-parameters
-            keysInsertions.push(
-              this.generateComplexEncodingCode(paramType, 'keys', `param${index}`),
-            );
+            // A non-indexed parameter should go to the data array
+            dataParams.push(`param${index}`);
+            dataParamTypes.push(paramType);
           }
-        } else {
-          // A non-indexed parameter should go to the data array
-          dataInsertions.push(this.generateSimpleEncodingCode(paramType, 'data', `param${index}`));
-        }
-
-        return [params, keysInsertions, dataInsertions];
-      },
-      [new Array<{ name: string; type: string }>(), new Array<string>(), new Array<string>()],
-    );
+
+          return [params, keysInsertions, dataParams, dataParamTypes];
+        },
+        [
+          new Array<{ name: string; type: string }>(),
+          new Array<string>(),
+          new Array<string>(),
+          new Array<TypeNode>(),
+        ],
+      );
+
+    const dataInsertions = this.generateSimpleEncodingCode(dataParamTypes, 'data', dataParams);
 
     const cairoParams = params.map((p) => `${p.name} : ${p.type}`).join(', ');
 
@@ -133,7 +142,7 @@ export class EventFunction extends StringIndexedFuncGen {
       `   // data arrays`,
       `   let data_len: felt = 0;`,
       `   let (data: felt*) = alloc();`,
-      ...dataInsertions,
+      dataInsertions,
       `   // data: pack 31 bytes felts into a single 248 bits felt`,
       `   let (data_len: felt, data: felt*) = pack_bytes_felt(${BYTES_IN_FELT_PACKING}, ${BIG_ENDIAN}, data_len, data);`,
       `   emit_event(keys_len, keys, data_len, data);`,
@@ -167,29 +176,37 @@ export class EventFunction extends StringIndexedFuncGen {
     ].join('\n');
   }
 
-  private generateSimpleEncodingCode(type: TypeNode, arrayName: string, argName: string): string {
-    const abiFunc = this.abiEncode.getOrCreate([type]);
+  private generateSimpleEncodingCode(
+    types: TypeNode[],
+    arrayName: string,
+    argNames: string[],
+  ): string {
+    const abiFunc = this.abiEncode.getOrCreate(types);
 
     this.requireImport('warplib.memory', 'wm_to_felt_array');
     this.requireImport('warplib.keccak', 'felt_array_concat');
 
     return [
-      `   let (mem_encode: felt) = ${abiFunc}(${argName});`,
+      `   let (mem_encode: felt) = ${abiFunc}(${argNames.join(',')});`,
       `   let (encode_bytes_len: felt, encode_bytes: felt*) = wm_to_felt_array(mem_encode);`,
       `   let (${arrayName}_len: felt) = felt_array_concat(encode_bytes_len, 0, encode_bytes, ${arrayName}_len, ${arrayName});`,
     ].join('\n');
   }
 
-  private generateComplexEncodingCode(type: TypeNode, arrayName: string, argName: string): string {
-    const abiFunc = this.indexEncode.getOrCreate([type]);
+  private generateComplexEncodingCode(
+    types: TypeNode[],
+    arrayName: string,
+    argNames: string[],
+  ): string {
+    const abiFunc = this.indexEncode.getOrCreate(types);
 
     this.requireImport('starkware.cairo.common.uint256', 'Uint256');
     this.requireImport(`warplib.maths.utils`, 'felt_to_uint256');
     this.requireImport('warplib.keccak', 'warp_keccak');
     this.requireImport('warplib.dynamic_arrays_util', 'fixed_bytes256_to_felt_dynamic_array_spl');
 
     return [
-      `   let (mem_encode: felt) = ${abiFunc}(${argName});`,
+      `   let (mem_encode: felt) = ${abiFunc}(${argNames.join(',')});`,
       `   let (keccak_hash256: Uint256) = warp_keccak(mem_encode);`,
       `   let (${arrayName}_len: felt) = fixed_bytes256_to_felt_dynamic_array_spl(${arrayName}_len, ${arrayName}, 0, keccak_hash256);`,
     ].join('\n');

src/export.ts

@@ -14,3 +14,4 @@ export * from './transpiler';
 export * from './utils/export';
 export * from './transcode/encode';
 export * from './transcode/decode';
+export * from './transcode/interface';

src/passes/rejectUnsupportedFeatures.ts

@@ -7,6 +7,7 @@ import {
   ContractKind,
   DataLocation,
   ErrorDefinition,
+  EventDefinition,
   ExpressionStatement,
   ExternalReferenceType,
   FunctionCall,
@@ -15,9 +16,12 @@ import {
   FunctionDefinition,
   FunctionKind,
   FunctionType,
+  generalizeType,
   Identifier,
   IndexAccess,
+  isReferenceType,
   Literal,
+  MappingType,
   MemberAccess,
   PointerType,
   RevertStatement,
@@ -33,7 +37,7 @@ import { AST } from '../ast/ast';
 import { ASTMapper } from '../ast/mapper';
 import { printNode } from '../utils/astPrinter';
 import { getErrorMessage, WillNotSupportError } from '../utils/errors';
-import { isDynamicArray, safeGetNodeType } from '../utils/nodeTypeProcessing';
+import { isDynamicArray, safeGetNodeType, isValueType } from '../utils/nodeTypeProcessing';
 import { isExternalCall, isExternallyVisible } from '../utils/utils';
 
 const PATH_REGEX = /^[\w-@/\\]*$/;
@@ -93,6 +97,33 @@ export class RejectUnsupportedFeatures extends ASTMapper {
     this.addUnsupported('User defined Errors are not supported', node);
   }
 
+  visitEventDefinition(node: EventDefinition, ast: AST): void {
+    node.vParameters.vParameters.forEach((param) => {
+      if (param.indexed) {
+        const paramType = generalizeType(safeGetNodeType(param, ast.inference))[0];
+        if (isValueType(paramType)) {
+          this.commonVisit(node, ast);
+          return;
+        }
+        if (
+          paramType instanceof ArrayType ||
+          paramType instanceof MappingType ||
+          (paramType instanceof PointerType && isReferenceType(paramType.to))
+        )
+          this.addUnsupported(
+            `Indexed parameters of type: ${paramType.constructor.name} are not supported`,
+            node,
+          );
+
+        if (
+          paramType instanceof UserDefinedType &&
+          paramType.definition instanceof StructDefinition
+        )
+          this.addUnsupported(`Indexed parameters of type: Structs are not supported`, node);
+      }
+    });
+  }
+
   visitFunctionCallOptions(node: FunctionCallOptions, ast: AST): void {
     // Allow options only when passing salt values for contract creation
     if (

src/transcode/encode.ts

@@ -158,7 +158,7 @@ export function encodeComplex(type: ParamType, inputs: IterableIterator<SolValue
   throw new Error(`Can't encode complex type ${type}`);
 }
 
-export function makeIterator(value: SolValue) {
+export function makeIterator<T>(value: T): IterableIterator<T> {
   if (Array.isArray(value)) {
     return value.values();
   }

src/transcode/export.ts

@@ -1,3 +1,4 @@
 export * from './decode';
 export * from './encode';
 export * from './utils';
+export * from './interface';

src/transcode/interface.ts

@@ -0,0 +1,28 @@
+import { EventFragment, Interface, Result } from 'ethers/lib/utils';
+import { argType, EventItem, join248bitChunks, splitInto248BitChunks } from '../utils/event';
+
+export class WarpInterface extends Interface {
+  decodeWarpEvent(fragment: EventFragment | string, warpEvent: EventItem): Result {
+    // reverse 248 bit packing
+    const data = join248bitChunks(warpEvent.data);
+    const keys = join248bitChunks(warpEvent.keys);
+
+    // Remove leading 0x from each element and join them
+    const chunkedData = `0x${data.map((x) => x.slice(2)).join('')}`;
+
+    return super.decodeEventLog(fragment, chunkedData, keys);
+  }
+
+  encodeWarpEvent(fragment: EventFragment, values: argType[], order = 0): EventItem {
+    const { data, topics }: { data: string; topics: string[] } = super.encodeEventLog(
+      fragment,
+      values,
+    );
+
+    const topicFlatHex = '0x' + topics.map((x) => x.slice(2).padStart(64, '0')).join('');
+    const topicItems248: string[] = splitInto248BitChunks(topicFlatHex);
+    const dataItems248: string[] = splitInto248BitChunks(data);
+
+    return { order, keys: topicItems248, data: dataItems248 };
+  }
+}

src/utils/event.ts

@@ -1,48 +1,49 @@
 import createKeccakHash from 'keccak';
 import { toUintOrFelt } from './export';
 
-export type EventItem = { data: string[]; keys: string[]; order: number };
+export type EventItem = { data: string[]; keys: string[]; order?: number };
 
-export function decodeEventLog(eventsLog: EventItem[]): EventItem[] {
-  // flat number to hex string with rjust 62
-  const flatNumberToHexString = (num: number | bigint | string): string => {
+export function splitInto248BitChunks(data: string): string[] {
+  if (data.startsWith('0x')) data = data.slice(2);
+  if (data === '') return [];
+  const paddedData = data.padEnd(data.length + (62 - (data.length % 62)), '0');
+
+  const result = [];
+  // get number from every 62 hex digits chunk
+  for (let i = 0; i < paddedData.length; i += 62) {
+    result.push(BigInt(`0x${paddedData.slice(i, i + 62)}`).toString());
+  }
+  return result;
+}
+
+export function join248bitChunks(data: string[]): string[] {
+  // numbers to hex in 248 bits
+  const numberToHex248 = (num: number | bigint | string): string => {
     return `${BigInt(num).toString(16).padStart(62, '0')}`;
   };
 
   // decode number from raw hex input string
-  const byte32numbers = (hexArray: string[]): bigint[] => {
-    const raw_hex_input = hexArray.reduce((pv, cv) => {
-      return `${pv}${flatNumberToHexString(cv)}`;
-    }, '');
+  const decode248BitEncoding = (hexArray: string[]): bigint[] => {
+    const rawHex = hexArray.map(numberToHex248).join('');
 
     // pad '0' to the end of the string to make it a multiple of 64
-    const padded_hex_input = raw_hex_input.padEnd(
-      raw_hex_input.length + (64 - (raw_hex_input.length % 64)),
-      '0',
-    );
+    const paddedHexVals = rawHex.padEnd(rawHex.length + (64 - (rawHex.length % 64)), '0');
 
     // get number from every 64 hex digits chunk
-    const numbers: bigint[] = [];
-    for (let i = 0; i < padded_hex_input.length; i += 64) {
-      numbers.push(BigInt(`0x${padded_hex_input.slice(i, i + 64)}`));
+    const result: bigint[] = [];
+    for (let i = 0; i < paddedHexVals.length; i += 64) {
+      result.push(BigInt(`0x${paddedHexVals.slice(i, i + 64)}`));
     }
 
     //remove trailing zero
-    if (padded_hex_input.length !== raw_hex_input.length && numbers[numbers.length - 1] === 0n) {
-      numbers.pop();
+    if (paddedHexVals.length !== rawHex.length && result[result.length - 1] === 0n) {
+      result.pop();
     }
 
-    return numbers;
+    return result;
   };
 
-  const events: EventItem[] = eventsLog.map((event) => {
-    return {
-      order: event.order,
-      keys: byte32numbers(event.keys).map((num) => `0x${num.toString(16)}`),
-      data: byte32numbers(event.data).map((num) => `0x${num.toString(16)}`),
-    };
-  });
-  return events;
+  return decode248BitEncoding(data).map((num) => `0x${num.toString(16).padStart(64, '0')}`);
 }
 
 export type argType = string | argType[];

tests/behaviour/behaviour.test.ts

@@ -17,7 +17,7 @@ import { expectations } from './expectations';
 import { AsyncTest, Expect, OUTPUT_DIR } from './expectations/types';
 import { DeployResponse } from '../testnetInterface';
 import { getDependencyGraph } from '../../src/utils/postCairoWrite';
-import { decodeEventLog, EventItem } from '../../src/utils/event';
+import { EventItem } from '../../src/utils/event';
 
 const PRINT_STEPS = false;
 const PARALLEL_COUNT = 8;
@@ -242,12 +242,8 @@ async function behaviourTest(
           `${name} - Return data should match expectation`,
         ).to.deep.equal(replaced_expectedResult);
         if (events !== undefined) {
-          events.forEach((e) => {
-            e.data = e.data.map((n) => `0x${BigInt(n).toString(16)}`);
-            e.keys = e.keys.map((n) => `0x${BigInt(n).toString(16)}`);
-          });
           expect(
-            decodeEventLog(response.events as EventItem[]),
+            response.events as EventItem[],
             `${name} - Events should match events expectation`,
           ).to.deep.equal(events);
         }

tests/behaviour/contracts/events/indexed.sol

@@ -6,10 +6,10 @@ contract WARP{
 
     //Event Definitions
     event uintEvent(uint indexed);
-    event arrayEvent(uint[] indexed);
-    event arrayStringEvent(string[] indexed);
-    event nestedArrayEvent(uint[][] indexed);
-    event structEvent(C indexed);
+    event arrayEvent(uint[]);
+    event arrayStringEvent(string[]);
+    event nestedArrayEvent(uint[][]);
+    event structEvent(C);
 
     function add(uint256 a, uint256 b) public {
         emit uintEvent(a+b);
@@ -25,9 +25,9 @@ contract WARP{
 
     function arrayString() public {
         string[] memory a = new string[](3);
-        a[0] = "a";
-        a[1] = "b";
-        a[2] = "c";
+        a[0] = "roh";
+        a[1] = "itra";
+        a[2] = "njan";
         emit arrayStringEvent(a);
     }