feat: ink! v5

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

@@ -2,7 +2,7 @@
 // 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 { ChainProperties, ContractConstructorSpecLatest, ContractEventSpecLatest, ContractMessageParamSpecLatest, ContractMessageSpecLatest, ContractMetadata, ContractMetadataLatest, ContractProjectInfo, ContractTypeSpec, EventRecord } from '@polkadot/types/interfaces';
 import type { Codec, Registry, TypeDef } from '@polkadot/types/types';
 import type { AbiConstructor, AbiEvent, AbiMessage, AbiParam, DecodedEvent, DecodedMessage } from '../types.js';
 
@@ -162,9 +162,18 @@ export class Abi {
   /**
    * Warning: Unstable API, bound to change
    */
-  public decodeEvent (data: Bytes | Uint8Array): DecodedEvent {
+  public decodeEvent (data: Bytes | Uint8Array, topic: EventRecord['topics'][0]): DecodedEvent {
+    // try to find a topic signature match - ink! v5 upwards
+    let event = this.events.find((e) => e.signatureTopic === topic.toHex());
+
+    if (event) {
+      return event.fromU8a(data.subarray(0));
+    }
+
+    // otherwise fallback to using the index to determine event - ink! v4 downwards
     const index = data[0];
-    const event = this.events[index];
+
+    event = this.events[index];
 
     if (!event) {
       throw new Error(`Unable to find event with index ${index}`);
@@ -235,15 +244,17 @@ export class Abi {
 
   #createEvent = (spec: ContractEventSpecLatest, 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.label.toString(),
-      index
+      identifier: [spec.module_path, spec.label.toString()].join('::'),
+      index,
+      signatureTopic: spec.signature_topic.toHex() || undefined
     };
 
     return event;

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

@@ -6,7 +6,7 @@
 import { TypeRegistry } from '@polkadot/types';
 
 import abis from '../test/contracts/index.js';
-import { v0ToLatest, v1ToLatest, v2ToLatest, v3ToLatest, v4ToLatest } from './toLatest.js';
+import { v0ToLatest, v1ToLatest, v2ToLatest, v3ToLatest, v4ToLatest, v5ToLatest } from './toLatest.js';
 
 describe('v0ToLatest', (): void => {
   const registry = new TypeRegistry();
@@ -137,3 +137,19 @@ describe('v4ToLatest', (): void => {
     ).toEqual(false);
   });
 });
+
+describe('v5ToLatest', (): void => {
+  const registry = new TypeRegistry();
+  const contract = registry.createType('ContractMetadata', { V5: abis['ink_v5_erc20'] });
+  const latest = v5ToLatest(registry, contract.asV5);
+
+  it('has new event fields', (): void => {
+    expect(
+      latest.spec.events.every((e) => e.has('module_path'))
+    ).toEqual(true);
+
+    expect(
+      latest.spec.events.every((e) => e.has('signature_topic'))
+    ).toEqual(true);
+  });
+});

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

@@ -1,17 +1,18 @@
 // Copyright 2017-2024 @polkadot/api-contract authors & contributors
 // SPDX-License-Identifier: Apache-2.0
 
-import type { ContractMetadataLatest, ContractMetadataV4 } from '@polkadot/types/interfaces';
+import type { ContractMetadataLatest, ContractMetadataV5 } from '@polkadot/types/interfaces';
 import type { Registry } from '@polkadot/types/types';
 
 import { v0ToV1 } from './toV1.js';
 import { v1ToV2 } from './toV2.js';
 import { v2ToV3 } from './toV3.js';
 import { v3ToV4 } from './toV4.js';
+import { v4ToV5 } from './toV5.js';
 
 // The versions where an enum is used, aka V0 is missing
 // (Order from newest, i.e. we expect more on newest vs oldest)
-export const enumVersions = ['V4', 'V3', 'V2', 'V1'] as const;
+export const enumVersions = ['V5', 'V4', 'V3', 'V2', 'V1'] as const;
 
 type Versions = typeof enumVersions[number] | 'V0';
 
@@ -23,16 +24,18 @@ function createConverter <I, O> (next: (registry: Registry, input: O) => Contrac
     next(registry, step(registry, input));
 }
 
-export function v4ToLatest (_registry: Registry, v4: ContractMetadataV4): ContractMetadataLatest {
-  return v4;
+export function v5ToLatest (_registry: Registry, v5: ContractMetadataV5): ContractMetadataLatest {
+  return v5;
 }
 
+export const v4ToLatest = /*#__PURE__*/ createConverter(v5ToLatest, v4ToV5);
 export const v3ToLatest = /*#__PURE__*/ createConverter(v4ToLatest, v3ToV4);
 export const v2ToLatest = /*#__PURE__*/ createConverter(v3ToLatest, v2ToV3);
 export const v1ToLatest = /*#__PURE__*/ createConverter(v2ToLatest, v1ToV2);
 export const v0ToLatest = /*#__PURE__*/ createConverter(v1ToLatest, v0ToV1);
 
 export const convertVersions: [Versions, Converter][] = [
+  ['V5', v5ToLatest],
   ['V4', v4ToLatest],
   ['V3', v3ToLatest],
   ['V2', v2ToLatest],

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

@@ -0,0 +1,20 @@
+// Copyright 2017-2024 @polkadot/api-contract authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+import type { ContractMetadataV4, ContractMetadataV5 } from '@polkadot/types/interfaces';
+import type { Registry } from '@polkadot/types/types';
+
+import { objectSpread } from '@polkadot/util';
+
+export function v4ToV5 (registry: Registry, v4: ContractMetadataV4): ContractMetadataV5 {
+  return registry.createType('ContractMetadataV5', objectSpread({}, v4, {
+    spec: objectSpread({}, v4.spec, {
+      events: v4.spec.events.map((e) =>
+        registry.createType('ContractEventSpecV3', objectSpread({
+          module_path: undefined,
+          signature_topic: undefined
+        }, e))
+      )
+    })
+  }));
+}

packages/api-contract/src/base/Contract.ts

@@ -115,9 +115,9 @@ export class Contract<ApiType extends ApiTypes> extends Base<ApiType> {
       // ContractEmitted is the current generation, ContractExecution is the previous generation
       new ContractSubmittableResult(result, applyOnEvent(result, ['ContractEmitted', 'ContractExecution'], (records: EventRecord[]) =>
         records
-          .map(({ event: { data: [, data] } }): DecodedEvent | null => {
+          .map(({ event: { data: [, data] }, topics }): DecodedEvent | null => {
             try {
-              return this.abi.decodeEvent(data as Bytes);
+              return this.abi.decodeEvent(data as Bytes, topics[0]);
             } catch (error) {
               l.error(`Unable to decode contract event: ${(error as Error).message}`);