Support for contracts metadata V2

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

@@ -1,7 +1,7 @@
 // Copyright 2017-2021 @polkadot/api-contract authors & contributors
 // SPDX-License-Identifier: Apache-2.0
 
-import type { AnyJson, Registry } from '@polkadot/types/types';
+import type { Registry } from '@polkadot/types/types';
 
 import fs from 'fs';
 import path from 'path';
@@ -14,6 +14,7 @@ import { Abi } from '.';
 
 interface SpecDef {
   messages: {
+    label: string;
     name: string[] | string
   }[]
 }
@@ -28,6 +29,9 @@ interface JSONAbi {
   spec: SpecDef;
   V1: {
     spec: SpecDef;
+  },
+  V2: {
+    spec: SpecDef;
   }
 }
 
@@ -47,11 +51,19 @@ function stringifyJson (registry: Registry): string {
 
 describe('Abi', (): void => {
   describe('ABI', (): void => {
-    Object.entries(abis).forEach(([abiName, abi]: [string, JSONAbi]) => {
+    Object.entries(abis).forEach(([abiName, _abi]) => {
+      const abi = _abi as unknown as JSONAbi;
+
       it(`initializes from a contract ABI (${abiName})`, (): void => {
         try {
-          const messageIds = (abi.V1 ? abi.V1 : abi).spec.messages.map(({ name }) => Array.isArray(name) ? name[0] : name);
-          const inkAbi = new Abi(abis[abiName] as AnyJson);
+          const messageIds = (abi.V2 || abi.V1 || abi).spec.messages.map(({ label, name }) =>
+            label || (
+              Array.isArray(name)
+                ? name[0]
+                : name
+            )
+          );
+          const inkAbi = new Abi(abis[abiName]);
 
           expect(inkAbi.messages.map(({ identifier }) => identifier)).toEqual(messageIds);
         } catch (error) {
@@ -66,7 +78,7 @@ describe('Abi', (): void => {
   describe('TypeDef', (): void => {
     Object.keys(abis).forEach((abiName) => {
       it(`initializes from a contract ABI (${abiName})`, (): void => {
-        const abi = new Abi(abis[abiName] as AnyJson);
+        const abi = new Abi(abis[abiName]);
         const json = stringifyJson(abi.registry);
         const cmpPath = path.join(__dirname, `../../test/compare/${abiName}.test.json`);
 
@@ -87,8 +99,8 @@ describe('Abi', (): void => {
   });
 
   it('has the correct hash for the source', (): void => {
-    const bundle = abis.ink_v0_flipperBundle as JSONAbi;
-    const abi = new Abi(bundle as unknown as AnyJson);
+    const abi = new Abi(abis.ink_v0_flipperBundle);
+    const bundle = abis.ink_v0_flipperBundle as unknown as JSONAbi;
 
     // manual
     expect(bundle.source.hash).toEqual(blake2AsHex(bundle.source.wasm));

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

@@ -2,24 +2,14 @@
 // SPDX-License-Identifier: Apache-2.0
 
 import type { Bytes, PortableRegistry } from '@polkadot/types';
-import type { ChainProperties, ContractConstructorSpec, ContractEventSpec, ContractMessageParamSpec, ContractMessageSpec, ContractMetadataLatest, ContractProjectInfo } from '@polkadot/types/interfaces';
-import type { AnyJson, Codec, Registry } from '@polkadot/types/types';
+import type { ChainProperties, ContractConstructorSpecLatest, ContractEventSpecLatest, ContractMessageParamSpecLatest, ContractMessageSpecLatest, ContractMetadataLatest, ContractProjectInfo } from '@polkadot/types/interfaces';
+import type { Codec, Registry } from '@polkadot/types/types';
 import type { AbiConstructor, AbiEvent, AbiMessage, AbiParam, DecodedEvent, DecodedMessage } from '../types';
 
 import { TypeDefInfo, TypeRegistry } from '@polkadot/types';
 import { assert, assertReturn, compactAddLength, compactStripLength, isNumber, isObject, isString, logger, stringCamelCase, stringify, u8aConcat, u8aToHex } from '@polkadot/util';
 
-import { toLatest } from './toLatest';
-
-interface V0AbiJson {
-  metadataVersion: string;
-  spec: {
-    constructors: unknown[];
-    events: unknown[];
-    messages: unknown[];
-  };
-  types: unknown[];
-}
+import { v0ToLatest, v1ToLatest } from './toLatest';
 
 const l = logger('Abi');
 
@@ -35,16 +25,29 @@ function findMessage <T extends AbiMessage> (list: T[], messageOrId: T | string
   return assertReturn(message, () => `Attempted to call an invalid contract interface, ${stringify(messageOrId)}`);
 }
 
-function parseJson (json: AnyJson, chainProperties?: ChainProperties): [AnyJson, Registry, ContractMetadataLatest, ContractProjectInfo] {
+// FIXME: This is still workable with V0, V1 & V2, but certainly is not a scalable
+// approach (right at this point don't quite have better ideas that is not as complex
+// as the conversion tactics in the runtime Metadata)
+function getLatestMeta (registry: Registry, json: Record<string, unknown>): ContractMetadataLatest {
+  const metadata = registry.createType('ContractMetadata',
+    isObject(json.V2)
+      ? { V2: json.V2 }
+      : isObject(json.V1)
+        ? { V1: json.V1 }
+        : { V0: json }
+  );
+
+  return metadata.isV2
+    ? metadata.asV2
+    : metadata.isV1
+      ? v1ToLatest(registry, metadata.asV1)
+      : v0ToLatest(registry, metadata.asV0);
+}
+
+function parseJson (json: Record<string, unknown>, chainProperties?: ChainProperties): [Record<string, unknown>, Registry, ContractMetadataLatest, ContractProjectInfo] {
   const registry = new TypeRegistry();
   const info = registry.createType('ContractProjectInfo', json);
-  const metadata = registry.createType('ContractMetadata', isString((json as unknown as V0AbiJson).metadataVersion)
-    ? { V0: json }
-    : { V1: (json as Record<string, AnyJson>).V1 }
-  );
-  const latest = metadata.isV0
-    ? toLatest(registry, metadata.asV0)
-    : metadata.asV1;
+  const latest = getLatestMeta(registry, json);
   const lookup = registry.createType<PortableRegistry>('PortableRegistry', { types: latest.types });
 
   // attach the lookup to the registry - now the types are known
@@ -69,30 +72,30 @@ export class Abi {
 
   public readonly info: ContractProjectInfo;
 
-  public readonly json: AnyJson;
+  public readonly json: Record<string, unknown>;
 
   public readonly messages: AbiMessage[];
 
   public readonly metadata: ContractMetadataLatest;
 
   public readonly registry: Registry;
 
-  constructor (abiJson: AnyJson, chainProperties?: ChainProperties) {
+  constructor (abiJson: Record<string, unknown> | string, chainProperties?: ChainProperties) {
     [this.json, this.registry, this.metadata, this.info] = parseJson(
       isString(abiJson)
-        ? JSON.parse(abiJson) as AnyJson
+        ? JSON.parse(abiJson) as Record<string, unknown>
         : abiJson,
       chainProperties
     );
-    this.constructors = this.metadata.spec.constructors.map((spec: ContractConstructorSpec, index) =>
+    this.constructors = this.metadata.spec.constructors.map((spec: ContractConstructorSpecLatest, index) =>
       this.#createMessage(spec, index, {
         isConstructor: true
       })
     );
-    this.events = this.metadata.spec.events.map((spec: ContractEventSpec, index) =>
+    this.events = this.metadata.spec.events.map((spec: ContractEventSpecLatest, index) =>
       this.#createEvent(spec, index)
     );
-    this.messages = this.metadata.spec.messages.map((spec: ContractMessageSpec, index): AbiMessage => {
+    this.messages = this.metadata.spec.messages.map((spec: ContractMessageSpecLatest, index): AbiMessage => {
       const typeSpec = spec.returnType.unwrapOr(null);
 
       return this.#createMessage(spec, index, {
@@ -139,15 +142,15 @@ export class Abi {
     return findMessage(this.messages, messageOrId);
   }
 
-  #createArgs = (args: ContractMessageParamSpec[], spec: unknown): AbiParam[] => {
-    return args.map(({ name, type }, index): AbiParam => {
+  #createArgs = (args: ContractMessageParamSpecLatest[], spec: unknown): AbiParam[] => {
+    return args.map(({ label, type }, index): AbiParam => {
       try {
         assert(isObject(type), 'Invalid type definition found');
 
         const displayName = type.displayName.length
           ? type.displayName[type.displayName.length - 1].toString()
           : undefined;
-        const camelName = stringCamelCase(name);
+        const camelName = stringCamelCase(label);
 
         if (displayName && PRIMITIVE_ALWAYS.includes(displayName)) {
           return {
@@ -175,7 +178,7 @@ export class Abi {
     });
   };
 
-  #createEvent = (spec: ContractEventSpec, index: number): AbiEvent => {
+  #createEvent = (spec: ContractEventSpecLatest, index: number): AbiEvent => {
     const args = this.#createArgs(spec.args, spec);
     const event = {
       args,
@@ -184,16 +187,16 @@ export class Abi {
         args: this.#decodeArgs(args, data),
         event
       }),
-      identifier: spec.name.toString(),
+      identifier: spec.label.toString(),
       index
     };
 
     return event;
   };
 
-  #createMessage = (spec: ContractMessageSpec | ContractConstructorSpec, index: number, add: Partial<AbiMessage> = {}): AbiMessage => {
+  #createMessage = (spec: ContractMessageSpecLatest | ContractConstructorSpecLatest, index: number, add: Partial<AbiMessage> = {}): AbiMessage => {
     const args = this.#createArgs(spec.args, spec);
-    const identifier = spec.name.toString();
+    const identifier = spec.label.toString();
     const message = {
       ...add,
       args,
@@ -237,8 +240,8 @@ export class Abi {
     return message.fromU8a(trimmed.subarray(4));
   };
 
-  #encodeArgs = ({ name, selector }: ContractMessageSpec | ContractConstructorSpec, args: AbiParam[], data: unknown[]): Uint8Array => {
-    assert(data.length === args.length, () => `Expected ${args.length} arguments to contract message '${name.toString()}', found ${data.length}`);
+  #encodeArgs = ({ label, selector }: ContractMessageSpecLatest | ContractConstructorSpecLatest, args: AbiParam[], data: unknown[]): Uint8Array => {
+    assert(data.length === args.length, () => `Expected ${args.length} arguments to contract message '${label.toString()}', found ${data.length}`);
 
     return compactAddLength(
       u8aConcat(

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

@@ -0,0 +1,73 @@
+// Copyright 2017-2021 @polkadot/api-contract authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+import { TypeRegistry } from '@polkadot/types';
+
+import abis from '../../test/contracts';
+import { v0ToLatest, v1ToLatest } from './toLatest';
+
+describe('v0ToLatest', (): void => {
+  const registry = new TypeRegistry();
+  const contract = registry.createType('ContractMetadata', { V0: abis.ink_v0_erc20 });
+  const latest = v0ToLatest(registry, contract.asV0);
+
+  it('has the correct constructors', (): void => {
+    expect(
+      latest.spec.constructors.map(({ label }) => label.toString())
+    ).toEqual(['new']);
+  });
+
+  it('has the correct messages', (): void => {
+    expect(
+      latest.spec.messages.map(({ label }) => label.toString())
+    ).toEqual(['total_supply', 'balance_of', 'allowance', 'transfer', 'approve', 'transfer_from']);
+  });
+
+  it('has the correct events', (): void => {
+    expect(
+      latest.spec.events.map(({ label }) => label.toString())
+    ).toEqual(['Transfer', 'Approval']);
+  });
+
+  it('has the correct constructor arguments', (): void => {
+    expect(
+      latest.spec.constructors[0].args.map(({ label }) => label.toString())
+    ).toEqual(['initial_supply']);
+  });
+
+  it('has the correct message arguments', (): void => {
+    expect(
+      latest.spec.messages[1].args.map(({ label }) => label.toString())
+    ).toEqual(['owner']);
+  });
+
+  it('has the correct event arguments', (): void => {
+    expect(
+      latest.spec.events[0].args.map(({ label }) => label.toString())
+    ).toEqual(['from', 'to', 'value']);
+  });
+});
+
+describe('v1ToLatest', (): void => {
+  const registry = new TypeRegistry();
+  const contract = registry.createType('ContractMetadata', { V1: abis.ink_v1_flipper.V1 });
+  const latest = v1ToLatest(registry, contract.asV1);
+
+  it('has the correct constructors', (): void => {
+    expect(
+      latest.spec.constructors.map(({ label }) => label.toString())
+    ).toEqual(['new', 'default']);
+  });
+
+  it('has the correct messages', (): void => {
+    expect(
+      latest.spec.messages.map(({ label }) => label.toString())
+    ).toEqual(['flip', 'get']);
+  });
+
+  it('has the correct constructor arguments', (): void => {
+    expect(
+      latest.spec.constructors[0].args.map(({ label }) => label.toString())
+    ).toEqual(['init_value']);
+  });
+});

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

@@ -1,14 +1,16 @@
 // Copyright 2017-2021 @polkadot/api-contract authors & contributors
 // SPDX-License-Identifier: Apache-2.0
 
-import type { ContractMetadataLatest, ContractMetadataV0 } from '@polkadot/types/interfaces';
+import type { ContractMetadataLatest, ContractMetadataV0, ContractMetadataV1 } from '@polkadot/types/interfaces';
 import type { Registry } from '@polkadot/types/types';
 
-import { convertSiV0toV1 } from '@polkadot/types';
+import { v0ToV1 } from './toV1';
+import { v1ToV2 } from './toV2';
 
-export function toLatest (registry: Registry, v0: ContractMetadataV0): ContractMetadataLatest {
-  return registry.createType('ContractMetadataLatest', {
-    ...v0,
-    types: convertSiV0toV1(registry, v0.types)
-  });
+export function v1ToLatest (registry: Registry, v1: ContractMetadataV1): ContractMetadataLatest {
+  return v1ToV2(registry, v1);
+}
+
+export function v0ToLatest (registry: Registry, v0: ContractMetadataV0): ContractMetadataLatest {
+  return v1ToLatest(registry, v0ToV1(registry, v0));
 }

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

@@ -0,0 +1,14 @@
+// Copyright 2017-2021 @polkadot/api-contract authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+import type { ContractMetadataV0, ContractMetadataV1 } from '@polkadot/types/interfaces';
+import type { Registry } from '@polkadot/types/types';
+
+import { convertSiV0toV1 } from '@polkadot/types';
+import { objectSpread } from '@polkadot/util';
+
+export function v0ToV1 (registry: Registry, v0: ContractMetadataV0): ContractMetadataV1 {
+  return registry.createType('ContractMetadataV1', objectSpread({}, v0, {
+    types: convertSiV0toV1(registry, v0.types)
+  }));
+}

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

@@ -0,0 +1,52 @@
+// Copyright 2017-2021 @polkadot/api-contract authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+import type { Text } from '@polkadot/types';
+import type { ContractMetadataV1, ContractMetadataV2 } from '@polkadot/types/interfaces';
+import type { InterfaceTypes, Registry } from '@polkadot/types/types';
+
+import { objectSpread } from '@polkadot/util';
+
+type WithArgs = keyof typeof ARG_TYPES;
+
+interface NamedEntry {
+  name: Text | Text[];
+}
+
+interface ArgsEntry <T extends WithArgs> extends NamedEntry {
+  args: InterfaceTypes[`${T}V0`]['args'][0][];
+}
+
+const ARG_TYPES = {
+  ContractConstructorSpec: 'ContractMessageParamSpecV2',
+  ContractEventSpec: 'ContractEventParamSpecV2',
+  ContractMessageSpec: 'ContractMessageParamSpecV2'
+};
+
+function v1ToV2Label (entry: NamedEntry): { label: Text } {
+  return objectSpread({}, entry, {
+    label: Array.isArray(entry.name)
+      ? entry.name[0]
+      : entry.name
+  });
+}
+
+function v1ToV2Labels <T extends WithArgs> (registry: Registry, outType: T, all: ArgsEntry<T>[]): unknown[] {
+  return all.map((e) =>
+    registry.createType(`${outType}V2`, objectSpread(v1ToV2Label(e), {
+      args: e.args.map((a) =>
+        registry.createType(ARG_TYPES[outType], v1ToV2Label(a))
+      )
+    }))
+  );
+}
+
+export function v1ToV2 (registry: Registry, v1: ContractMetadataV1): ContractMetadataV2 {
+  return registry.createType('ContractMetadataV2', objectSpread({}, v1, {
+    spec: objectSpread({}, v1.spec, {
+      constructors: v1ToV2Labels(registry, 'ContractConstructorSpec', v1.spec.constructors),
+      events: v1ToV2Labels(registry, 'ContractEventSpec', v1.spec.events),
+      messages: v1ToV2Labels(registry, 'ContractMessageSpec', v1.spec.messages)
+    })
+  }));
+}