test(contracts): add specs for decodeEvent

packages/api/src/client/__tests__/MockProvider.ts

@@ -1,5 +1,5 @@
 import staticSubstrateV15 from '@polkadot/types-support/metadata/v15/substrate-hex';
-import { RuntimeVersion } from '@dedot/codecs';
+import { OpaqueMetadata, RuntimeVersion } from '@dedot/codecs';
 import {
   ConnectionStatus,
   JsonRpcProvider,
@@ -30,7 +30,7 @@ export default class MockProvider extends EventEmitter<ProviderEvent> implements
 
   rpcRequests: Record<string, AnyFunc>;
 
-  constructor(mockedRuntimeVersion: RuntimeVersion = MockedRuntimeVersion) {
+  constructor(mockedRuntimeVersion: RuntimeVersion = MockedRuntimeVersion, metadata: OpaqueMetadata = staticSubstrateV15) {
     super();
     this.rpcRequests = {
       chain_getBlockHash: () => '0x0000000000000000000000000000000000000000000000000000000000000000',
@@ -39,7 +39,7 @@ export default class MockProvider extends EventEmitter<ProviderEvent> implements
       state_unsubscribeRuntimeVersion: () => null,
       system_chain: () => 'MockedChain',
       system_properties: () => ({ ss58Format: 42 }) as ChainProperties,
-      state_getMetadata: () => staticSubstrateV15,
+      state_getMetadata: () => metadata,
       state_call: () => '0x',
       state_getStorage: () => '0x',
       state_queryStorageAt: () => [{ block: '0x', changes: ['0x', '0x'] }],

packages/contracts/src/__tests__/Contract.spec.ts

@@ -3,22 +3,25 @@ import MockProvider from '@dedot/api/client/__tests__/MockProvider';
 import { RuntimeVersion } from '@dedot/codecs';
 import { beforeEach, describe, expect, it } from 'vitest';
 import { Contract } from '../Contract.js';
-import { FLIPPER_CONTRACT_METADATA, PSP22_CONTRACT_METADATA, RANDOM_CONTRACT_ADDRESS } from './contracts-metadata.js';
+import { FLIPPER_CONTRACT_METADATA_V4, FLIPPER_CONTRACT_METADATA_V5, PSP22_CONTRACT_METADATA, RANDOM_CONTRACT_ADDRESS } from './contracts-metadata.js';
+import { FrameSystemEventRecord } from '@dedot/api/chaintypes/index.js';
+import substrateContractMetadata from './substrateContractMetadata.js';
+import { ContractMetadataV5 } from 'src/types/v5.js';
 
 export const MockedRuntimeVersionWithContractsApi: RuntimeVersion = {
   specName: 'mock-spec',
   implName: 'mock-spec-impl',
-  authoringVersion: 0,
-  specVersion: 1,
+  authoringVersion: 1,
+  specVersion: 100,
   implVersion: 0,
   apis: [
     // @ts-ignore
     ...Object.entries(FallbackRuntimeApis),
     // @ts-ignore
     ['0x68b66ba122c93fa7', 2], // ContractsApi v2
   ],
-  transactionVersion: 25,
-  stateVersion: 0,
+  transactionVersion: 1,
+  stateVersion: 1,
 };
 
 describe('Contract', () => {
@@ -28,7 +31,7 @@ describe('Contract', () => {
     beforeEach(async () => {
       provider = new MockProvider(MockedRuntimeVersionWithContractsApi);
       api = await Dedot.new({ provider });
-      flipper = new Contract(api, RANDOM_CONTRACT_ADDRESS, FLIPPER_CONTRACT_METADATA);
+      flipper = new Contract(api, RANDOM_CONTRACT_ADDRESS, FLIPPER_CONTRACT_METADATA_V4);
       psp22 = new Contract(api, RANDOM_CONTRACT_ADDRESS, PSP22_CONTRACT_METADATA);
     });
 
@@ -73,9 +76,67 @@ describe('Contract', () => {
     it('should throw error', async () => {
       provider = new MockProvider();
       api = await Dedot.new({ provider });
-      expect(() => new Contract(api, RANDOM_CONTRACT_ADDRESS, FLIPPER_CONTRACT_METADATA)).toThrowError(
+      expect(() => new Contract(api, RANDOM_CONTRACT_ADDRESS, FLIPPER_CONTRACT_METADATA_V4)).toThrowError(
         'Contracts pallet is not available',
       );
     });
   });
+
+  describe('decodeEvent', () => {
+    beforeEach(async () => {
+      provider = new MockProvider(MockedRuntimeVersionWithContractsApi, substrateContractMetadata);
+      api = await Dedot.new({ provider });
+      flipper = new Contract(api, RANDOM_CONTRACT_ADDRESS, FLIPPER_CONTRACT_METADATA_V5);
+    });
+
+    it('should throw error if eventRecord is not ContractEmitted palletEvent', () => {
+      const notContractEmittedEventRecordHex = '0x00010000000408d43593c715fdd31c61141abd04a99fd6822c8558854ccde39a5684e7a56da27d7bd1726000000000000000000000000000';
+      const eventRecord = api.registry.findCodec(19).tryDecode(notContractEmittedEventRecordHex) as FrameSystemEventRecord;
+
+      expect(() => flipper.decodeEvent(eventRecord)).toThrowError(`Event Record is not valid!`)
+    })
+
+    describe('decodeEventV5', () => {
+      beforeEach(async () => {
+        flipper = new Contract(api, RANDOM_CONTRACT_ADDRESS, FLIPPER_CONTRACT_METADATA_V5);
+      })
+
+      it('should decode properly', () => {
+        const contractEmittedEventRecord = '0x00010000000803f2773dba008bbe3bb76fa8cb89fddb534b4e81dcaf52faaf94190a89ab3d3b04080001040a39b5ca0b8b3a5172476100ae7b9168b269cc91d5648efe180c75d935d3e886'
+        const eventRecord = api.registry.findCodec(19).tryDecode(contractEmittedEventRecord) as FrameSystemEventRecord;
+
+        const decodedEvent = flipper.decodeEvent(eventRecord);
+
+        expect(decodedEvent).toEqual({ name: 'Flipped', data: { old: false, new: true }});
+      });
+
+      it('should throw error if cannot determine the event meta', () => {
+        const mockFlipper = structuredClone(FLIPPER_CONTRACT_METADATA_V5) as ContractMetadataV5;
+        mockFlipper.spec.events.at(0)!.signature_topic = null;
+        mockFlipper.spec.events.push(mockFlipper.spec.events.at(0)!);
+
+        flipper = new Contract(api, RANDOM_CONTRACT_ADDRESS, mockFlipper);
+
+        const contractEmittedEventRecord = '0x00010000000803f2773dba008bbe3bb76fa8cb89fddb534b4e81dcaf52faaf94190a89ab3d3b04080001040a39b5ca0b8b3a5172476100ae7b9168b269cc91d5648efe180c75d935d3e886'
+        const eventRecord = api.registry.findCodec(19).tryDecode(contractEmittedEventRecord) as FrameSystemEventRecord;
+
+        expect(() => flipper.decodeEvent(eventRecord)).toThrowError('Unable to determine event!');
+      })
+    })
+
+    describe('decodeEventV4', () => {
+      beforeEach(async () => {
+        flipper = new Contract(api, RANDOM_CONTRACT_ADDRESS, FLIPPER_CONTRACT_METADATA_V4);
+      })
+
+      it('should decode properly', () => {
+        const contractEmittedEventRecord = '0x00010000000803f2773dba008bbe3bb76fa8cb89fddb534b4e81dcaf52faaf94190a89ab3d3b04080001040a39b5ca0b8b3a5172476100ae7b9168b269cc91d5648efe180c75d935d3e886'
+        const eventRecord = api.registry.findCodec(19).tryDecode(contractEmittedEventRecord) as FrameSystemEventRecord;
+
+        const decodedEvent = flipper.decodeEvent(eventRecord);
+
+        expect(decodedEvent).toEqual({ name: 'Flipped', data: { old: true, new: false }});
+      })
+    })
+  })
 });

packages/contracts/src/__tests__/ContractDeployer.spec.ts

@@ -3,7 +3,7 @@ import MockProvider from '@dedot/api/client/__tests__/MockProvider';
 import { beforeEach, describe, expect, it } from 'vitest';
 import { ContractDeployer } from '../ContractDeployer.js';
 import { MockedRuntimeVersionWithContractsApi } from './Contract.spec.js';
-import { FLIPPER_CONTRACT_METADATA, PSP22_CONTRACT_METADATA } from './contracts-metadata.js';
+import { FLIPPER_CONTRACT_METADATA_V4, PSP22_CONTRACT_METADATA } from './contracts-metadata.js';
 
 describe('ContractDeployer', () => {
   let api: Dedot, provider: MockProvider, flipper: ContractDeployer, psp22: ContractDeployer;
@@ -12,7 +12,7 @@ describe('ContractDeployer', () => {
     beforeEach(async () => {
       provider = new MockProvider(MockedRuntimeVersionWithContractsApi);
       api = await Dedot.new({ provider });
-      flipper = new ContractDeployer(api, FLIPPER_CONTRACT_METADATA, FLIPPER_CONTRACT_METADATA.source.hash);
+      flipper = new ContractDeployer(api, FLIPPER_CONTRACT_METADATA_V4, FLIPPER_CONTRACT_METADATA_V4.source.hash);
       psp22 = new ContractDeployer(api, PSP22_CONTRACT_METADATA, PSP22_CONTRACT_METADATA.source.hash);
     });
 
@@ -34,7 +34,7 @@ describe('ContractDeployer', () => {
       provider = new MockProvider();
       api = await Dedot.new({ provider });
       expect(
-        () => new ContractDeployer(api, FLIPPER_CONTRACT_METADATA, FLIPPER_CONTRACT_METADATA.source.hash),
+        () => new ContractDeployer(api, FLIPPER_CONTRACT_METADATA_V4, FLIPPER_CONTRACT_METADATA_V4.source.hash),
       ).toThrowError('Contracts pallet is not available');
     });
   });

packages/contracts/src/__tests__/TypinkRegistry.spec.ts

@@ -1,20 +1,21 @@
 import * as util from 'node:util';
 import { beforeEach, describe, expect, it } from 'vitest';
 import { TypinkRegistry } from '../TypinkRegistry.js';
-import { FLIPPER_CONTRACT_METADATA } from './contracts-metadata.js';
+import { FLIPPER_CONTRACT_METADATA_V4 } from './contracts-metadata.js';
 
 describe('TypinkRegistry', () => {
   describe('with metadata', () => {
     let registry: TypinkRegistry;
 
     beforeEach(() => {
-      registry = new TypinkRegistry(FLIPPER_CONTRACT_METADATA);
+      registry = new TypinkRegistry(FLIPPER_CONTRACT_METADATA_V4);
     });
 
     it('should have metadata', () => {
       expect(registry.metadata).toBeDefined();
     });
 
+
     describe('findCodec', () => {
       it('should find existing codec', () => {
         expect(util.inspect(registry.findCodec(1))).toEqual(

packages/contracts/src/__tests__/contracts-metadata.ts

@@ -1,11 +1,13 @@
 import { parseRawMetadata } from "../utils.js";
 // @ts-ignore
-import flipperRaw from './flipper.json' assert { type: 'json' };
+import flipperV4Raw from './flipper_v4.json' assert { type: 'json' };
+// @ts-ignore
+import flipperV5Raw from './flipper_v5.json' assert { type: 'json' };
 // @ts-ignore
 import psp22Raw from './psp22.json' assert { type: 'json' };
 
-
 export const RANDOM_CONTRACT_ADDRESS = '5GpTe4rrVUcZbndCc6HGNCLNfs84R9xaQ9FhPYXQFUZqMVZn';
 
-export const FLIPPER_CONTRACT_METADATA = parseRawMetadata(JSON.stringify(flipperRaw));
+export const FLIPPER_CONTRACT_METADATA_V4 = parseRawMetadata(JSON.stringify(flipperV4Raw));
+export const FLIPPER_CONTRACT_METADATA_V5 = parseRawMetadata(JSON.stringify(flipperV5Raw));
 export const PSP22_CONTRACT_METADATA = parseRawMetadata(JSON.stringify(psp22Raw))