feat: ink! v5

packages/api-contract/package.json

@@ -33,6 +33,7 @@
   },
   "devDependencies": {
     "@polkadot/api-augment": "10.11.3",
-    "@polkadot/keyring": "^12.6.2"
+    "@polkadot/keyring": "^12.6.2",
+    "@polkadot/types-support": "10.11.3"
   }
 }

packages/api-contract/src/Abi/Abi.spec.ts

@@ -9,8 +9,10 @@ import fs from 'node:fs';
 import process from 'node:process';
 
 import { TypeDefInfo } from '@polkadot/types/types';
+import rpcMetadata from '@polkadot/types-support/metadata/static-substrate-contracts-node';
 import { blake2AsHex } from '@polkadot/util-crypto';
 
+import { Metadata, TypeRegistry } from '../../../types/src/bundle.js';
 import abis from '../test/contracts/index.js';
 import { Abi } from './index.js';
 
@@ -122,4 +124,78 @@ describe('Abi', (): void => {
     // the hash as per the actual Abi
     expect(bundle.source.hash).toEqual(abi.info.source.wasmHash.toHex());
   });
+
+  describe('Events', (): void => {
+    const registry = new TypeRegistry();
+
+    beforeAll((): void => {
+      const metadata = new Metadata(registry, rpcMetadata);
+
+      registry.setMetadata(metadata);
+    });
+
+    it('decoding <=ink!v4 events', (): void => {
+      const abiJson = abis['ink_v4_erc20Metadata'];
+
+      expect(abiJson).toBeDefined();
+      const abi = new Abi(abiJson);
+
+      const eventRecordHex =
+      '0x0001000000080360951b8baf569bca905a279c12d6ce17db7cdce23a42563870ef585129ce5dc64d010001d43593c715fdd31c61141abd04a99fd6822c8558854ccde39a5684e7a56da27d018eaf04151687736326c9fea17e25fc5287613693c912909cb226aa4794f26a4800505a4f7e9f4eb106000000000000000c0045726332303a3a5472616e7366657200000000000000000000000000000000da2d695d3b5a304e0039e7fc4419c34fa0c1f239189c99bb72a6484f1634782b2b00c7d40fe6d84d660f3e6bed90f218e022a0909f7e1a7ea35ada8b6e003564';
+      const record = registry.createType('EventRecord', eventRecordHex);
+
+      const decodedEvent = abi.decodeEvent(record);
+
+      expect(decodedEvent.event.args.length).toEqual(3);
+      expect(decodedEvent.args.length).toEqual(3);
+      expect(decodedEvent.event.identifier).toEqual('Transfer');
+
+      const decodedEventHuman = decodedEvent.event.args.reduce((prev, cur, index) => {
+        return {
+          ...prev,
+          [cur.name]: decodedEvent.args[index].toHuman()
+        };
+      }, {});
+
+      const expectedEvent = {
+        from: '5GrwvaEF5zXb26Fz9rcQpDWS57CtERHpNehXCPcNoHGKutQY',
+        to: '5FHneW46xGXgs5mUiveU4sbTyGBzmstUspZC92UhjJM694ty',
+        value: '123.4567 MUnit'
+      };
+
+      expect(decodedEventHuman).toEqual(expectedEvent);
+    });
+
+    it('decoding <=ink!v5 events', (): void => {
+      const abiJson = abis['ink_v5_erc20Metadata'];
+
+      expect(abiJson).toBeDefined();
+      const abi = new Abi(abiJson);
+
+      const eventRecordHex =
+    '0x00010000000803da17150e96b3955a4db6ad35ddeb495f722f9c1d84683113bfb096bf3faa30f2490101d43593c715fdd31c61141abd04a99fd6822c8558854ccde39a5684e7a56da27d018eaf04151687736326c9fea17e25fc5287613693c912909cb226aa4794f26a4800505a4f7e9f4eb106000000000000000cb5b61a3e6a21a16be4f044b517c28ac692492f73c5bfd3f60178ad98c767f4cbd43593c715fdd31c61141abd04a99fd6822c8558854ccde39a5684e7a56da27d8eaf04151687736326c9fea17e25fc5287613693c912909cb226aa4794f26a48';
+      const record = registry.createType('EventRecord', eventRecordHex);
+
+      const decodedEvent = abi.decodeEvent(record);
+
+      expect(decodedEvent.event.args.length).toEqual(3);
+      expect(decodedEvent.args.length).toEqual(3);
+      expect(decodedEvent.event.identifier).toEqual('erc20::erc20::Transfer');
+
+      const decodedEventHuman = decodedEvent.event.args.reduce((prev, cur, index) => {
+        return {
+          ...prev,
+          [cur.name]: decodedEvent.args[index].toHuman()
+        };
+      }, {});
+
+      const expectedEvent = {
+        from: '5GrwvaEF5zXb26Fz9rcQpDWS57CtERHpNehXCPcNoHGKutQY',
+        to: '5FHneW46xGXgs5mUiveU4sbTyGBzmstUspZC92UhjJM694ty',
+        value: '123.4567 MUnit'
+      };
+
+      expect(decodedEventHuman).toEqual(expectedEvent);
+    });
+  });
 });

packages/api-contract/src/Abi/index.ts

@@ -2,22 +2,24 @@
 // SPDX-License-Identifier: Apache-2.0
 
 import type { Bytes } from '@polkadot/types';
-import type { ChainProperties, ContractConstructorSpecLatest, ContractEventSpecLatest, ContractMessageParamSpecLatest, ContractMessageSpecLatest, ContractMetadata, ContractMetadataLatest, ContractProjectInfo, ContractTypeSpec } from '@polkadot/types/interfaces';
 import type { Codec, Registry, TypeDef } from '@polkadot/types/types';
 import type { AbiConstructor, AbiEvent, AbiMessage, AbiParam, DecodedEvent, DecodedMessage } from '../types.js';
 
 import { Option, TypeRegistry } from '@polkadot/types';
+import { type ChainProperties, type ContractConstructorSpecLatest, type ContractMessageParamSpecLatest, type ContractMessageSpecLatest, type ContractMetadata, type ContractMetadataV4, type ContractMetadataV5, type ContractProjectInfo, type ContractTypeSpec, type EventRecord } from '@polkadot/types/interfaces';
 import { TypeDefInfo } from '@polkadot/types-create';
 import { assertReturn, compactAddLength, compactStripLength, isBn, isNumber, isObject, isString, isUndefined, logger, stringCamelCase, stringify, u8aConcat, u8aToHex } from '@polkadot/util';
 
-import { convertVersions, enumVersions } from './toLatest.js';
+import { convertVersions as convertVersionsCompatible, enumVersions } from './toLatestCompatible.js';
 
 interface AbiJson {
   version?: string;
 
   [key: string]: unknown;
 }
 
+export type ContractMetadataSupported = ContractMetadataV4 | ContractMetadataV5;
+
 const l = logger('Abi');
 
 const PRIMITIVE_ALWAYS = ['AccountId', 'AccountIndex', 'Address', 'Balance'];
@@ -32,7 +34,7 @@ function findMessage <T extends AbiMessage> (list: T[], messageOrId: T | string
   return assertReturn(message, () => `Attempted to call an invalid contract interface, ${stringify(messageOrId)}`);
 }
 
-function getLatestMeta (registry: Registry, json: AbiJson): ContractMetadataLatest {
+function getMetadata (registry: Registry, json: AbiJson): ContractMetadataSupported {
   // this is for V1, V2, V3
   const vx = enumVersions.find((v) => isObject(json[v]));
 
@@ -50,20 +52,23 @@ function getLatestMeta (registry: Registry, json: AbiJson): ContractMetadataLate
         ? { [`V${jsonVersion}`]: json }
         : { V0: json }
   );
-  const converter = convertVersions.find(([v]) => metadata[`is${v}`]);
+
+  const converter = convertVersionsCompatible.find(([v]) => metadata[`is${v}`]);
 
   if (!converter) {
-    throw new Error(`Unable to convert ABI with version ${metadata.type} to latest`);
+    throw new Error(`Unable to convert ABI with version ${metadata.type} to a supported version`);
   }
 
-  return converter[1](registry, metadata[`as${converter[0]}`]);
+  const upgradedMetadata = converter[1](registry, metadata[`as${converter[0]}`]);
+
+  return upgradedMetadata;
 }
 
-function parseJson (json: Record<string, unknown>, chainProperties?: ChainProperties): [Record<string, unknown>, Registry, ContractMetadataLatest, ContractProjectInfo] {
+function parseJson (json: Record<string, unknown>, chainProperties?: ChainProperties): [Record<string, unknown>, Registry, ContractMetadataSupported, ContractProjectInfo] {
   const registry = new TypeRegistry();
   const info = registry.createType('ContractProjectInfo', json) as unknown as ContractProjectInfo;
-  const latest = getLatestMeta(registry, json as unknown as AbiJson);
-  const lookup = registry.createType('PortableRegistry', { types: latest.types }, true);
+  const metadata = getMetadata(registry, json as unknown as AbiJson);
+  const lookup = registry.createType('PortableRegistry', { types: metadata.types }, true);
 
   // attach the lookup to the registry - now the types are known
   registry.setLookup(lookup);
@@ -77,7 +82,7 @@ function parseJson (json: Record<string, unknown>, chainProperties?: ChainProper
     lookup.getTypeDef(id)
   );
 
-  return [json, registry, latest, info];
+  return [json, registry, metadata, info];
 }
 
 /**
@@ -102,7 +107,7 @@ export class Abi {
   readonly info: ContractProjectInfo;
   readonly json: Record<string, unknown>;
   readonly messages: AbiMessage[];
-  readonly metadata: ContractMetadataLatest;
+  readonly metadata: ContractMetadataSupported;
   readonly registry: Registry;
   readonly environment = new Map<string, TypeDef | Codec>();
 
@@ -123,8 +128,8 @@ export class Abi {
           : null
       })
     );
-    this.events = this.metadata.spec.events.map((spec: ContractEventSpecLatest, index) =>
-      this.#createEvent(spec, index)
+    this.events = this.metadata.spec.events.map((_: ContractMetadataSupported['spec']['events'][number], index: number) =>
+      this.#createEvent(index)
     );
     this.messages = this.metadata.spec.messages.map((spec: ContractMessageSpecLatest, index): AbiMessage =>
       this.#createMessage(spec, index, {
@@ -162,7 +167,31 @@ export class Abi {
   /**
    * Warning: Unstable API, bound to change
    */
-  public decodeEvent (data: Bytes | Uint8Array): DecodedEvent {
+  public decodeEvent (record: EventRecord): DecodedEvent {
+    switch (this.metadata.version.toString()) {
+      // earlier version are hoisted to v4
+      case '4':
+        return this.#decodeEventV4(record);
+      // Latest
+      default:
+        return this.#decodeEventV5(record);
+    }
+  }
+
+  #decodeEventV5 = (record: EventRecord): DecodedEvent => {
+    const data = record.event.data[1] as Bytes;
+    const signatureTopic = record.topics[0];
+    const event = this.events.find((e) => e.signatureTopic !== undefined && e.signatureTopic === signatureTopic.toHex());
+
+    if (!event) {
+      throw new Error(`Unable to find event with signature_topic ${signatureTopic.toHex()}`);
+    }
+
+    return event.fromU8a(data.subarray(0));
+  };
+
+  #decodeEventV4 = (record: EventRecord): DecodedEvent => {
+    const data = record.event.data[1] as Bytes;
     const index = data[0];
     const event = this.events[index];
 
@@ -171,7 +200,7 @@ export class Abi {
     }
 
     return event.fromU8a(data.subarray(1));
-  }
+  };
 
   /**
    * Warning: Unstable API, bound to change
@@ -233,7 +262,36 @@ export class Abi {
     });
   };
 
-  #createEvent = (spec: ContractEventSpecLatest, index: number): AbiEvent => {
+  #createEvent = (index: number): AbiEvent => {
+    // TODO TypeScript would narrow this type to the correct version,
+    // but version is `Text` so I need to call `toString()` here,
+    // which breaks the type inference.
+    switch (this.metadata.version.toString()) {
+      case '4':
+        return this.#createEventV4((this.metadata as ContractMetadataV4).spec.events[index], index);
+      default:
+        return this.#createEventV5((this.metadata as ContractMetadataV5).spec.events[index], index);
+    }
+  };
+
+  #createEventV5 = (spec: ContractMetadataV5['spec']['events'][number], index: number): AbiEvent => {
+    const args = this.#createArgs(spec.args, spec);
+    const event = {
+      args,
+      docs: spec.docs.map((d) => d.toString()),
+      fromU8a: (data: Uint8Array): DecodedEvent => ({
+        args: this.#decodeArgs(args, data),
+        event
+      }),
+      identifier: [spec.module_path, spec.label].join('::'),
+      index,
+      signatureTopic: spec.signature_topic.toHex()
+    };
+
+    return event;
+  };
+
+  #createEventV4 = (spec: ContractMetadataV4['spec']['events'][number], index: number): AbiEvent => {
     const args = this.#createArgs(spec.args, spec);
     const event = {
       args,