diff --git a/packages/types/src/augment/registry.ts b/packages/types/src/augment/registry.ts index 9e3bbde7d7..230f90703a 100644 --- a/packages/types/src/augment/registry.ts +++ b/packages/types/src/augment/registry.ts @@ -15,6 +15,7 @@ import { EthereumAddress, StatementKind } from '@polkadot/types/interfaces/claim import { CollectiveOrigin, MemberCount, ProposalIndex, Votes, VotesTo230 } from '@polkadot/types/interfaces/collective'; import { AuthorityId, RawVRFOutput } from '@polkadot/types/interfaces/consensus'; import { AliveContractInfo, CodeHash, ContractCallRequest, ContractExecResult, ContractExecResultSuccess, ContractExecResultSuccessTo255, ContractExecResultTo255, ContractInfo, ContractStorageKey, Gas, HostFnWeights, InstructionWeights, PrefabWasmModule, PrefabWasmModuleReserved, Schedule, ScheduleTo212, ScheduleTo258, SeedOf, TombstoneContractInfo, TrieId } from '@polkadot/types/interfaces/contracts'; +import { InkConstructorSpec, InkContractContract, InkContractSource, InkContractSpec, InkCryptoHasher, InkDiscriminant, InkDisplayName, InkEventParamSpec, InkEventSpec, InkLayoutArray, InkLayoutCell, InkLayoutEnum, InkLayoutHash, InkLayoutHashingStrategy, InkLayoutKey, InkLayoutStruct, InkLayoutStructField, InkMessageParamSpec, InkMessageSpec, InkPath, InkProject, InkSelector, InkStorageLayout, InkTypeSpec, MtField, MtLookupTypeId, MtType, MtTypeDef, MtTypeDefArray, MtTypeDefComposite, MtTypeDefPrimitive, MtTypeDefSequence, MtTypeDefSlice, MtTypeDefTuple, MtTypeDefVariant, MtVariant } from '@polkadot/types/interfaces/contractsAbi'; import { AccountVote, AccountVoteSplit, AccountVoteStandard, Conviction, Delegations, PreimageStatus, PreimageStatusAvailable, PriorLock, PropIndex, Proposal, ProxyState, ReferendumIndex, ReferendumInfo, ReferendumInfoFinished, ReferendumInfoTo239, ReferendumStatus, Tally, Voting, VotingDelegating, VotingDirect, VotingDirectVote } from '@polkadot/types/interfaces/democracy'; import { ApprovalFlag, DefunctVoter, Renouncing, SetIndex, Vote, VoteIndex, VoteThreshold, VoterInfo } from '@polkadot/types/interfaces/elections'; import { CreatedBlock, ImportedAux } from '@polkadot/types/interfaces/engine'; @@ -528,6 +529,116 @@ declare module '@polkadot/types/types/registry' { TrieId: TrieId; 'Option': Option; 'Vec': Vec; + InkLayoutKey: InkLayoutKey; + 'Option': Option; + 'Vec': Vec; + InkStorageLayout: InkStorageLayout; + 'Option': Option; + 'Vec': Vec; + InkLayoutCell: InkLayoutCell; + 'Option': Option; + 'Vec': Vec; + InkCryptoHasher: InkCryptoHasher; + 'Option': Option; + 'Vec': Vec; + InkLayoutHash: InkLayoutHash; + 'Option': Option; + 'Vec': Vec; + InkLayoutHashingStrategy: InkLayoutHashingStrategy; + 'Option': Option; + 'Vec': Vec; + InkLayoutArray: InkLayoutArray; + 'Option': Option; + 'Vec': Vec; + InkLayoutStruct: InkLayoutStruct; + 'Option': Option; + 'Vec': Vec; + InkLayoutStructField: InkLayoutStructField; + 'Option': Option; + 'Vec': Vec; + InkDiscriminant: InkDiscriminant; + 'Compact': Compact; + 'Option': Option; + 'Vec': Vec; + InkLayoutEnum: InkLayoutEnum; + 'Option': Option; + 'Vec': Vec; + MtField: MtField; + 'Option': Option; + 'Vec': Vec; + MtLookupTypeId: MtLookupTypeId; + 'Compact': Compact; + 'Option': Option; + 'Vec': Vec; + MtType: MtType; + 'Option': Option; + 'Vec': Vec; + MtTypeDef: MtTypeDef; + 'Option': Option; + 'Vec': Vec; + MtTypeDefArray: MtTypeDefArray; + 'Option': Option; + 'Vec': Vec; + MtTypeDefComposite: MtTypeDefComposite; + 'Option': Option; + 'Vec': Vec; + MtTypeDefPrimitive: MtTypeDefPrimitive; + 'Option': Option; + 'Vec': Vec; + MtTypeDefSequence: MtTypeDefSequence; + 'Option': Option; + 'Vec': Vec; + MtTypeDefSlice: MtTypeDefSlice; + 'Option': Option; + 'Vec': Vec; + MtTypeDefTuple: MtTypeDefTuple; + 'Option': Option; + 'Vec': Vec; + MtTypeDefVariant: MtTypeDefVariant; + 'Option': Option; + 'Vec': Vec; + MtVariant: MtVariant; + 'Option': Option; + 'Vec': Vec; + InkPath: InkPath; + 'Option': Option; + 'Vec': Vec; + InkDisplayName: InkDisplayName; + 'Option': Option; + 'Vec': Vec; + InkConstructorSpec: InkConstructorSpec; + 'Option': Option; + 'Vec': Vec; + InkContractSpec: InkContractSpec; + 'Option': Option; + 'Vec': Vec; + InkEventParamSpec: InkEventParamSpec; + 'Option': Option; + 'Vec': Vec; + InkEventSpec: InkEventSpec; + 'Option': Option; + 'Vec': Vec; + InkMessageParamSpec: InkMessageParamSpec; + 'Option': Option; + 'Vec': Vec; + InkMessageSpec: InkMessageSpec; + 'Option': Option; + 'Vec': Vec; + InkSelector: InkSelector; + 'Option': Option; + 'Vec': Vec; + InkTypeSpec: InkTypeSpec; + 'Option': Option; + 'Vec': Vec; + InkContractContract: InkContractContract; + 'Option': Option; + 'Vec': Vec; + InkContractSource: InkContractSource; + 'Option': Option; + 'Vec': Vec; + InkProject: InkProject; + 'Option': Option; + 'Vec': Vec; AccountVote: AccountVote; 'Option': Option; 'Vec': Vec; diff --git a/packages/types/src/codec/Enum.ts b/packages/types/src/codec/Enum.ts index 2c2e3b0b8b..a44df8667c 100644 --- a/packages/types/src/codec/Enum.ts +++ b/packages/types/src/codec/Enum.ts @@ -64,7 +64,11 @@ function decodeFromJSON (registry: Registry, def: TypesDef, key: string, value?: assert(index !== -1, `Cannot map Enum JSON, unable to find '${key}' in ${keys.join(', ')}`); - return createFromValue(registry, def, index, value); + try { + return createFromValue(registry, def, index, value); + } catch (error) { + throw new Error(`Enum(${key}):: ${(error as Error).message}`); + } } function decodeFromString (registry: Registry, def: TypesDef, value: string): Decoded { diff --git a/packages/types/src/create/types.ts b/packages/types/src/create/types.ts index b82473ab1f..13f5373c9c 100644 --- a/packages/types/src/create/types.ts +++ b/packages/types/src/create/types.ts @@ -44,8 +44,8 @@ export interface TypeDef { name?: string; namespace?: string; params?: TypeDef[]; - type: string; sub?: TypeDef | TypeDef[]; + type: string; } export type TypeIndex = number; diff --git a/packages/types/src/interfaces/contracts/definitions.ts b/packages/types/src/interfaces/contracts/definitions.ts index 0de592f034..0629b22a3e 100644 --- a/packages/types/src/interfaces/contracts/definitions.ts +++ b/packages/types/src/interfaces/contracts/definitions.ts @@ -90,7 +90,7 @@ export default { }, ContractExecResultSuccess: { flags: 'u32', - data: 'Vec', + data: 'Bytes', gasConsumed: 'u64' }, ContractExecResult: { diff --git a/packages/types/src/interfaces/contractsAbi/definitions.ts b/packages/types/src/interfaces/contractsAbi/definitions.ts new file mode 100644 index 0000000000..940368aa54 --- /dev/null +++ b/packages/types/src/interfaces/contractsAbi/definitions.ts @@ -0,0 +1,175 @@ +// Copyright 2017-2020 @polkadot/types authors & contributors +// SPDX-License-Identifier: Apache-2.0 +/* eslint-disable sort-keys */ + +const layout = { + InkCryptoHasher: { + _enum: ['Blake2x256', 'Sha2x256', 'Keccak256'] + }, + InkDiscriminant: 'u32', + InkLayoutArray: { + offset: 'InkLayoutKey', + len: 'u32', + cellsPerElem: 'u64', + layout: 'InkStorageLayout' + }, + InkLayoutCell: { + key: 'InkLayoutKey', + ty: 'MtLookupTypeId' + }, + InkLayoutEnum: { + dispatchKey: 'InkLayoutKey', + variants: 'BTreeMap' + }, + InkLayoutHash: { + offset: 'InkLayoutKey', + strategy: 'InkLayoutHashingStrategy', + layout: 'InkStorageLayout' + }, + InkLayoutHashingStrategy: { + hasher: 'InkCryptoHasher', + postfix: 'Vec', + prefix: 'Vec' + }, + InkLayoutKey: '[u8; 32]', + InkLayoutStruct: { + fields: 'Vec' + }, + InkLayoutStructField: { + layout: 'InkStorageLayout', + name: 'Text' + }, + InkStorageLayout: { + _enum: { + Cell: 'InkLayoutCell', + Hash: 'InkLayoutHash', + Array: 'InkLayoutArray', + Struct: 'InkLayoutStruct', + Enum: 'InkLayoutEnum' + } + } +}; + +const spec = { + InkConstructorSpec: { + name: 'Text', + selector: 'InkSelector', + args: 'Vec', + docs: 'Vec' + }, + InkContractSpec: { + constructors: 'Vec', + messages: 'Vec', + events: 'Vec', + docs: 'Vec' + }, + InkDisplayName: 'MtPath', + InkEventParamSpec: { + name: 'Text', + indexed: 'bool', + type: 'InkTypeSpec', + docs: 'Vec' + }, + InkEventSpec: { + name: 'Text', + args: 'Vec', + docs: 'Vec' + }, + InkMessageParamSpec: { + name: 'Text', + type: 'InkTypeSpec' + }, + InkMessageSpec: { + name: 'Text', + selector: 'InkSelector', + mutates: 'bool', + payable: 'bool', + args: 'Vec', + returnType: 'Option', + docs: 'Vec' + }, + InkSelector: '[u8; 4]', + InkTypeSpec: { + type: 'MtLookupTypeId', + displayName: 'InkDisplayName' + } +}; + +const registry = { + MtField: { + name: 'Option', + type: 'MtLookupTypeId' + }, + MtLookupTypeId: 'u32', + MtPath: 'Vec', + MtType: { + def: 'MtTypeDef', + params: 'Vec', + path: 'MtPath' + }, + MtTypeDef: { + _enum: { + Array: 'MtTypeDefArray', + Composite: 'MtTypeDefComposite', + Primitive: 'MtTypeDefPrimitive', + Sequence: 'MtTypeDefSequence', + Tuple: 'MtTypeDefTuple', + Variant: 'MtTypeDefVariant' + } + }, + MtTypeDefArray: { + len: 'u16', + type: 'MtLookupTypeId' + }, + MtTypeDefComposite: { + fields: 'Vec' + }, + MtTypeDefPrimitive: { + // this enum definition is mapped in api-contracts/inkTypes.ts + _enum: ['Bool', 'Char', 'Str', 'U8', 'U16', 'U32', 'U64', 'U128', 'I8', 'I16', 'I32', 'I64', 'I128'] + }, + MtTypeDefSequence: { + type: 'MtLookupTypeId' + }, + MtTypeDefTuple: 'Vec', + MtTypeDefVariant: { + variants: 'Vec' + }, + MtVariant: { + discriminant: 'Option', + fields: 'Vec', + name: 'Text' + } +}; + +export default { + rpc: {}, + types: { + ...layout, + ...registry, + ...spec, + InkContractContract: { + name: 'Text', + version: 'Text', + authors: 'Vec', + description: 'Option', + documentation: 'Option', + repository: 'Option', + homepage: 'Option', + license: 'Option' + }, + InkContractSource: { + hash: '[u8; 32]', + language: 'Text', + compiler: 'Text' + }, + InkProject: { + metadataVersion: 'Text', + source: 'InkContractSource', + contract: 'InkContractContract', + spec: 'InkContractSpec', + storage: 'InkStorageLayout', + types: 'Vec' + } + } +}; diff --git a/packages/types/src/interfaces/contractsAbi/index.ts b/packages/types/src/interfaces/contractsAbi/index.ts new file mode 100644 index 0000000000..2d307291c3 --- /dev/null +++ b/packages/types/src/interfaces/contractsAbi/index.ts @@ -0,0 +1,4 @@ +// Auto-generated via `yarn polkadot-types-from-defs`, do not edit +/* eslint-disable */ + +export * from './types'; diff --git a/packages/types/src/interfaces/contractsAbi/types.ts b/packages/types/src/interfaces/contractsAbi/types.ts new file mode 100644 index 0000000000..77b59eb80c --- /dev/null +++ b/packages/types/src/interfaces/contractsAbi/types.ts @@ -0,0 +1,253 @@ +// Auto-generated via `yarn polkadot-types-from-defs`, do not edit +/* eslint-disable */ + +import { BTreeMap, Enum, Option, Struct, U8aFixed, Vec } from '@polkadot/types/codec'; +import { Bytes, Text, bool, u16, u32, u64, usize } from '@polkadot/types/primitive'; + +/** @name InkConstructorSpec */ +export interface InkConstructorSpec extends Struct { + readonly name: Text; + readonly selector: InkSelector; + readonly args: Vec; + readonly docs: Vec; +} + +/** @name InkContractContract */ +export interface InkContractContract extends Struct { + readonly authors: Vec; + readonly name: Text; + readonly version: Text; +} + +/** @name InkContractSource */ +export interface InkContractSource extends Struct { + readonly compiler: Text; + readonly hash: U8aFixed; + readonly language: Text; +} + +/** @name InkContractSpec */ +export interface InkContractSpec extends Struct { + readonly constructors: Vec; + readonly messages: Vec; + readonly events: Vec; + readonly docs: Vec; +} + +/** @name InkCryptoHasher */ +export interface InkCryptoHasher extends Enum { + readonly isBlake2X256: boolean; + readonly isSha2X256: boolean; + readonly isKeccak256: boolean; +} + +/** @name InkDiscriminant */ +export interface InkDiscriminant extends usize {} + +/** @name InkDisplayName */ +export interface InkDisplayName extends InkPath {} + +/** @name InkEventParamSpec */ +export interface InkEventParamSpec extends Struct { + readonly name: Text; + readonly indexed: bool; + readonly type: InkTypeSpec; + readonly docs: Vec; +} + +/** @name InkEventSpec */ +export interface InkEventSpec extends Struct { + readonly name: Text; + readonly args: Vec; + readonly docs: Vec; +} + +/** @name InkLayoutArray */ +export interface InkLayoutArray extends Struct { + readonly offset: InkLayoutKey; + readonly len: u32; + readonly cellsPerElem: u64; + readonly layout: InkStorageLayout; +} + +/** @name InkLayoutCell */ +export interface InkLayoutCell extends Struct { + readonly key: InkLayoutKey; + readonly ty: MtLookupTypeId; +} + +/** @name InkLayoutEnum */ +export interface InkLayoutEnum extends Struct { + readonly dispatchKey: InkLayoutKey; + readonly variants: BTreeMap; +} + +/** @name InkLayoutHash */ +export interface InkLayoutHash extends Struct { + readonly offset: InkLayoutKey; + readonly strategy: InkLayoutHashingStrategy; + readonly layout: InkStorageLayout; +} + +/** @name InkLayoutHashingStrategy */ +export interface InkLayoutHashingStrategy extends Struct { + readonly hasher: InkCryptoHasher; + readonly postfix: Bytes; + readonly prefix: Bytes; +} + +/** @name InkLayoutKey */ +export interface InkLayoutKey extends U8aFixed {} + +/** @name InkLayoutStruct */ +export interface InkLayoutStruct extends Struct { + readonly fields: Vec; +} + +/** @name InkLayoutStructField */ +export interface InkLayoutStructField extends Struct { + readonly layout: InkStorageLayout; + readonly name: Text; +} + +/** @name InkMessageParamSpec */ +export interface InkMessageParamSpec extends Struct { + readonly name: Text; + readonly type: InkTypeSpec; +} + +/** @name InkMessageSpec */ +export interface InkMessageSpec extends Struct { + readonly name: Text; + readonly selector: InkSelector; + readonly mutates: bool; + readonly payable: bool; + readonly args: Vec; + readonly returnType: Option; + readonly docs: Vec; +} + +/** @name InkPath */ +export interface InkPath extends Vec {} + +/** @name InkProject */ +export interface InkProject extends Struct { + readonly contract: InkContractContract; + readonly metadata_version: Text; + readonly source: InkContractSource; + readonly spec: InkContractSpec; + readonly storage: InkStorageLayout; + readonly types: Vec; +} + +/** @name InkSelector */ +export interface InkSelector extends U8aFixed {} + +/** @name InkStorageLayout */ +export interface InkStorageLayout extends Enum { + readonly isCell: boolean; + readonly asCell: InkLayoutCell; + readonly isHash: boolean; + readonly asHash: InkLayoutHash; + readonly isArray: boolean; + readonly asArray: InkLayoutArray; + readonly isStruct: boolean; + readonly asStruct: InkLayoutStruct; + readonly isEnum: boolean; + readonly asEnum: InkLayoutEnum; +} + +/** @name InkTypeSpec */ +export interface InkTypeSpec extends Struct { + readonly type: MtLookupTypeId; + readonly displayName: InkDisplayName; +} + +/** @name MtField */ +export interface MtField extends Struct { + readonly name: Option; + readonly type: MtLookupTypeId; +} + +/** @name MtLookupTypeId */ +export interface MtLookupTypeId extends u32 {} + +/** @name MtType */ +export interface MtType extends Struct { + readonly def: MtTypeDef; + readonly params: Vec; + readonly path: Vec; +} + +/** @name MtTypeDef */ +export interface MtTypeDef extends Enum { + readonly isArray: boolean; + readonly asArray: MtTypeDefArray; + readonly isComposite: boolean; + readonly asComposite: MtTypeDefComposite; + readonly isPrimitive: boolean; + readonly asPrimitive: MtTypeDefPrimitive; + readonly isSequence: boolean; + readonly asSequence: MtTypeDefSequence; + readonly isSlice: boolean; + readonly asSlice: MtTypeDefSlice; + readonly isTuple: boolean; + readonly asTuple: MtTypeDefTuple; + readonly isVariant: boolean; + readonly asVariant: MtTypeDefVariant; +} + +/** @name MtTypeDefArray */ +export interface MtTypeDefArray extends Struct { + readonly len: u16; + readonly type: MtLookupTypeId; +} + +/** @name MtTypeDefComposite */ +export interface MtTypeDefComposite extends Struct { + readonly fields: Vec; +} + +/** @name MtTypeDefPrimitive */ +export interface MtTypeDefPrimitive extends Enum { + readonly isBool: boolean; + readonly isChar: boolean; + readonly isStr: boolean; + readonly isU8: boolean; + readonly isU16: boolean; + readonly isU32: boolean; + readonly isU64: boolean; + readonly isU128: boolean; + readonly isI8: boolean; + readonly isI16: boolean; + readonly isI32: boolean; + readonly isI64: boolean; + readonly isI128: boolean; +} + +/** @name MtTypeDefSequence */ +export interface MtTypeDefSequence extends Struct { + readonly type: MtLookupTypeId; +} + +/** @name MtTypeDefSlice */ +export interface MtTypeDefSlice extends Struct { + readonly type: MtLookupTypeId; +} + +/** @name MtTypeDefTuple */ +export interface MtTypeDefTuple extends Vec {} + +/** @name MtTypeDefVariant */ +export interface MtTypeDefVariant extends Struct { + readonly variants: Vec; +} + +/** @name MtVariant */ +export interface MtVariant extends Struct { + readonly discriminant: Option; + readonly fields: Vec; + readonly name: Text; +} + +export type PHANTOM_CONTRACTSABI = 'contractsAbi'; diff --git a/packages/types/src/interfaces/definitions.ts b/packages/types/src/interfaces/definitions.ts index 48289c1ae9..6de1582f55 100644 --- a/packages/types/src/interfaces/definitions.ts +++ b/packages/types/src/interfaces/definitions.ts @@ -12,6 +12,7 @@ export { default as balances } from './balances/definitions'; export { default as collective } from './collective/definitions'; export { default as consensus } from './consensus/definitions'; export { default as contracts } from './contracts/definitions'; +export { default as contractsAbi } from './contractsAbi/definitions'; export { default as democracy } from './democracy/definitions'; export { default as elections } from './elections/definitions'; export { default as engine } from './engine/definitions'; diff --git a/packages/types/src/interfaces/types.ts b/packages/types/src/interfaces/types.ts index 2d61546628..6e12e8f549 100644 --- a/packages/types/src/interfaces/types.ts +++ b/packages/types/src/interfaces/types.ts @@ -9,6 +9,7 @@ export * from './balances/types'; export * from './collective/types'; export * from './consensus/types'; export * from './contracts/types'; +export * from './contractsAbi/types'; export * from './democracy/types'; export * from './elections/types'; export * from './engine/types';