// Copyright 2017-2019 @polkadot/api-contract authors & contributors // This software may be modified and distributed under the terms // of the Apache-2.0 license. See the LICENSE file for details. import { CodecArg, TypeDef } from '@polkadot/types/types'; import { ContractABIArgBasePre, ContractABIContract, ContractABIContractPre, ContractABIEvent, ContractABIEventPre, ContractABIFn, ContractABIFnArg, ContractABIMethod, ContractABIMethodBase, ContractABIMethodPre, ContractABI, ContractABIPre, ContractABIRange, ContractABIRangePre, ContractABIStorage, ContractABIStorageLayout, ContractABIStorageLayoutPre, ContractABIStoragePre, ContractABIStorageStruct, ContractABIStorageStructPre, ContractABITypePre } from './types'; import { Compact } from '@polkadot/types'; import { assert, isNumber, isString, isNull, isObject, isUndefined, stringCamelCase } from '@polkadot/util'; import MetaRegistry from './MetaRegistry'; import { createArgClass } from './method'; export default class ContractRegistry extends MetaRegistry { // Contract ABI helpers public validateArgs (name: string, args: ContractABIArgBasePre[]): void { assert(Array.isArray(args), `Expected 'args' to exist on ${name}`); args.forEach((arg): void => { const unknownKeys = Object.keys(arg).filter((key): boolean => !['name', 'type'].includes(key)); assert(unknownKeys.length === 0, `Unknown keys ${unknownKeys.join(', ')} found in ABI args for ${name}`); assert(isNumber(arg.name) && isString(this.stringAt(arg.name)), `${name} args should have valid name `); assert(isNumber(arg.type.ty) && isObject(this.typeDefAt(arg.type.ty)), `${name} args should have valid type`); }); } public validateConstructors ({ contract: { constructors } }: ContractABIPre): void { constructors.forEach((constructor: ContractABIMethodPre, index): void => { const unknownKeys = Object.keys(constructor).filter((key): boolean => !['args', 'docs', 'name', 'selector'].includes(key)); assert(unknownKeys.length === 0, `Unknown keys ${unknownKeys.join(', ')} found in ABI constructor`); this.validateArgs(`constructor ${index}`, constructor.args); }); } public validateMethods ({ contract: { messages } }: ContractABIPre): void { messages.forEach((method): void => { const unknownKeys = Object.keys(method).filter((key): boolean => !['args', 'docs', 'mutates', 'name', 'selector', 'return_type'].includes(key)); assert(unknownKeys.length === 0, `Unknown keys ${unknownKeys.join(', ')} found in ABI args for messages.${method.name}`); const { name, selector, return_type: returnType } = method; assert(isNumber(name) && isString(this.stringAt(name)), `Expected name for messages.${method.name}`); assert(isNumber(selector), `Expected selector for messages.${method.name}`); assert(isNull(returnType) || (isNumber(returnType.ty) && isObject(this.typeDefAt(returnType.ty))), `Expected return_type for messages.${method.name}`); this.validateArgs(`messages.${method.name}`, method.args); }); } public validateAbi (abi: ContractABIPre): void { const unknownKeys = Object.keys(abi.contract).filter((key): boolean => !['constructors', 'docs', 'events', 'messages', 'name'].includes(key)); assert(unknownKeys.length === 0, `Unknown fields ${unknownKeys.join(', ')} found in ABI`); const { contract: { constructors, messages, name } } = abi; assert(constructors && messages && isString(this.stringAt(name)), 'ABI should have constructors, messages & name sections'); this.validateConstructors(abi); this.validateMethods(abi); } public createMethod (name: string, method: Partial & ContractABIMethodBase): ContractABIFn { const args = method.args.map(({ name, type }): ContractABIFnArg => { assert(isObject(type), `Invalid type at index ${type}`); return { name: stringCamelCase(name), type }; }); const Clazz = createArgClass(args, isUndefined(method.selector) ? {} : { __selector: 'u32' }); const baseStruct: { [index: string]: any } = { __selector: method.selector }; const encoder = (...params: CodecArg[]): Uint8Array => { assert(params.length === args.length, `Expected ${args.length} arguments to contract ${name}, found ${params.length}`); const u8a = new Clazz( args.reduce((mapped, { name }, index): Record => { mapped[name] = params[index]; return mapped; }, { ...baseStruct }) ).toU8a(); return Compact.addLengthPrefix(u8a); }; const fn = (encoder as ContractABIFn); fn.args = args; fn.isConstant = !(method.mutates || false); fn.type = method.returnType || null; return fn; } public convertAbi ({ contract, storage }: ContractABIPre): ContractABI { return { contract: this.convertContract(contract), storage: this.convertStorage(storage) }; } public convertArgs (args: ContractABIArgBasePre[]): any[] { return args.map(({ name, type, ...arg }) => ({ ...arg, name: this.stringAt(name), type: this.convertType(type) })); } public convertType ({ ty, display_name: displayNameIndices }: ContractABITypePre): TypeDef { const displayName = this.stringsAt(displayNameIndices).join('::'); return this.typeDefAt(ty, { displayName }); } public convertContract ({ constructors, messages, name, events, ...contract }: ContractABIContractPre): ContractABIContract { return { constructors: this.convertConstructors(constructors), messages: messages.map(method => this.convertMethod(method)), name: this.stringAt(name), ...(events ? { events: events.map(event => this.convertEvent(event)) } : {}), ...contract }; } public convertConstructors (constructors: ContractABIMethodPre[]): ContractABIMethod[] { return constructors.map( (constructor: ContractABIMethodPre): ContractABIMethod => { return this.convertMethod(constructor); } ); } public convertMethod ({ args, name, return_type: returnType, ...method }: ContractABIMethodPre): ContractABIMethod { return { ...method, args: this.convertArgs(args), name: this.stringAt(name), returnType: returnType ? this.convertType(returnType) : null }; } public convertEvent ({ args }: ContractABIEventPre): ContractABIEvent { return { args: this.convertArgs(args) }; } public convertStorage (storage: ContractABIStoragePre): ContractABIStorage { return this.convertStorageStruct(storage); } public convertStorageLayout (storageLayout: ContractABIStorageLayoutPre): ContractABIStorageLayout { if ((storageLayout as ContractABIStorageStructPre)['struct.type']) { return this.convertStorageStruct(storageLayout as ContractABIStorageStructPre); } else { return this.convertStorageRange(storageLayout as ContractABIRangePre); } } public convertStorageStruct ({ 'struct.type': structType, 'struct.fields': structFields }: ContractABIStorageStructPre): ContractABIStorageStruct { return { 'struct.type': this.typeDefAt(structType), 'struct.fields': structFields.map(({ name, layout }) => ({ name: this.stringAt(name), layout: this.convertStorageLayout(layout) })) }; } public convertStorageRange ({ 'range.elem_type': type, ...range }: ContractABIRangePre): ContractABIRange { return { ...range, 'range.elem_type': this.typeDefAt(type) }; } }