diff --git a/packages/api-contract/src/base/Base.ts b/packages/api-contract/src/base/Base.ts index 8a5106bad8..418e3b4349 100644 --- a/packages/api-contract/src/base/Base.ts +++ b/packages/api-contract/src/base/Base.ts @@ -26,6 +26,6 @@ export abstract class Base { this.registry = this.abi.registry; this._decorateMethod = decorateMethod; - assert(this.api.rx.tx.contracts && this.api.rx.tx.contracts.putCode, 'You need to connect to a node with the contracts module, the metadata does not enable api.tx.contracts on this instance'); + assert(api.rx.tx.contracts?.instantiate, 'You need to connect to a node with the contracts module, the metadata does not enable api.tx.contracts on this instance'); } } diff --git a/packages/api-contract/src/base/Blueprint.ts b/packages/api-contract/src/base/Blueprint.ts index 0cfd42d7fd..e1c66ff8f3 100644 --- a/packages/api-contract/src/base/Blueprint.ts +++ b/packages/api-contract/src/base/Blueprint.ts @@ -6,44 +6,17 @@ import type { ApiTypes, DecorateMethod } from '@polkadot/api/types'; import type { AccountId, EventRecord, Hash } from '@polkadot/types/interfaces'; import type { AnyJson, CodecArg, ISubmittableResult } from '@polkadot/types/types'; import type { AbiConstructor, BlueprintOptions } from '../types'; -import type { BlueprintDeploy, ContractGeneric, MapConstructorExec } from './types'; - -import BN from 'bn.js'; +import type { ContractGeneric, MapConstructorExec } from './types'; import { SubmittableResult } from '@polkadot/api'; import { ApiBase } from '@polkadot/api/base'; -import { Bytes } from '@polkadot/types'; -import { compactAddLength, isUndefined, stringCamelCase, u8aToU8a } from '@polkadot/util'; -import { randomAsU8a } from '@polkadot/util-crypto'; +import { isUndefined, stringCamelCase } from '@polkadot/util'; import { Abi } from '../Abi'; -import { applyOnEvent, extractOptions, isOptions } from '../util'; +import { applyOnEvent } from '../util'; import { Base } from './Base'; import { Contract } from './Contract'; - -const EMPTY_SALT = new Uint8Array(); - -function createTx (fn: (options: BlueprintOptions, params: CodecArg[]) => SubmittableExtrinsic>): BlueprintDeploy { - return (options: BigInt | string | number | BN | BlueprintOptions, ...params: CodecArg[]): SubmittableExtrinsic> => - isOptions(options) - ? fn(options, params) - : fn(...extractOptions(options, params)); -} - -function createWithId (fn: (constructorOrId: AbiConstructor | string | number, options: BlueprintOptions, params: CodecArg[]) => T): ContractGeneric { - return (constructorOrId: AbiConstructor | string | number, options: BigInt | string | number | BN | BlueprintOptions, ...params: CodecArg[]): T => - isOptions(options) - ? fn(constructorOrId, options, params) - : fn(constructorOrId, ...extractOptions(options, params)); -} - -function encodeSalt (salt: Uint8Array | string | null = randomAsU8a()) { - return salt instanceof Bytes - ? salt - : salt && salt.length - ? compactAddLength(u8aToU8a(salt)) - : EMPTY_SALT; -} +import { createBluePrintTx, createBluePrintWithId, EMPTY_SALT, encodeSalt } from './util'; export class BlueprintSubmittableResult extends SubmittableResult { public readonly contract?: Contract; @@ -73,13 +46,13 @@ export class Blueprint extends Base { super(api, abi, decorateMethod); this.codeHash = this.registry.createType('Hash', codeHash); - this.createContract = createWithId(this.#deploy); + this.createContract = createBluePrintWithId(this.#deploy); this.abi.constructors.forEach((c): void => { const messageName = stringCamelCase(c.identifier); if (isUndefined(this.#tx[messageName])) { - this.#tx[messageName] = createTx((o, p) => this.#deploy(c, o, p)); + this.#tx[messageName] = createBluePrintTx((o, p) => this.#deploy(c, o, p)); } }); } @@ -88,7 +61,7 @@ export class Blueprint extends Base { return this.#tx; } - #deploy = (constructorOrId: AbiConstructor | string| number, { gasLimit = 0, salt, value = 0 }: BlueprintOptions, params: CodecArg[]): SubmittableExtrinsic> => { + #deploy = (constructorOrId: AbiConstructor | string | number, { gasLimit = 0, salt, value = 0 }: BlueprintOptions, params: CodecArg[]): SubmittableExtrinsic> => { const encodedSalt = encodeSalt(salt); const withSalt = this.api.tx.contracts.instantiate.meta.args.length === 5; const encoded = this.abi.findConstructor(constructorOrId).toU8a(params, withSalt ? EMPTY_SALT : encodedSalt); @@ -99,7 +72,7 @@ export class Blueprint extends Base { : this.api.tx.contracts.instantiate(value, gasLimit, this.codeHash, encoded); return tx.withResultTransform((result: ISubmittableResult) => - new BlueprintSubmittableResult(result, applyOnEvent(result, 'Instantiated', ([record]: EventRecord[]) => + new BlueprintSubmittableResult(result, applyOnEvent(result, ['Instantiated'], ([record]: EventRecord[]) => new Contract(this.api, this.abi, record.event.data[1] as AccountId, this._decorateMethod) )) ); diff --git a/packages/api-contract/src/base/Code.ts b/packages/api-contract/src/base/Code.ts index 6131a3fce7..315dd43a08 100644 --- a/packages/api-contract/src/base/Code.ts +++ b/packages/api-contract/src/base/Code.ts @@ -4,30 +4,39 @@ import type { SubmittableExtrinsic } from '@polkadot/api/submittable/types'; import type { ApiTypes, DecorateMethod } from '@polkadot/api/types'; import type { EventRecord, Hash } from '@polkadot/types/interfaces'; -import type { AnyJson, ISubmittableResult } from '@polkadot/types/types'; +import type { AnyJson, CodecArg, ISubmittableResult } from '@polkadot/types/types'; +import type { AbiConstructor, BlueprintOptions } from '../types'; +import type { MapConstructorExec } from './types'; import { SubmittableResult } from '@polkadot/api'; import { ApiBase } from '@polkadot/api/base'; -import { assert, compactAddLength, isWasm, u8aToU8a } from '@polkadot/util'; +import { assert, compactAddLength, isFunction, isUndefined, isWasm, stringCamelCase, u8aToU8a } from '@polkadot/util'; +import { blake2AsU8a } from '@polkadot/util-crypto'; import { Abi } from '../Abi'; import { applyOnEvent } from '../util'; import { Base } from './Base'; import { Blueprint } from './Blueprint'; +import { Contract } from './Contract'; +import { createBluePrintTx, EMPTY_SALT, encodeSalt } from './util'; export class CodeSubmittableResult extends SubmittableResult { public readonly blueprint?: Blueprint; + public readonly contract?: Contract; - constructor (result: ISubmittableResult, blueprint?: Blueprint) { + constructor (result: ISubmittableResult, blueprint?: Blueprint, contract?: Contract) { super(result); this.blueprint = blueprint; + this.contract = contract; } } export class Code extends Base { public readonly code: Uint8Array; + readonly #tx: MapConstructorExec = {}; + constructor (api: ApiBase, abi: AnyJson | Abi, wasm: Uint8Array | string | Buffer | null | undefined, decorateMethod: DecorateMethod) { super(api, abi, decorateMethod); @@ -36,18 +45,79 @@ export class Code extends Base { : u8aToU8a(wasm); assert(isWasm(this.code), 'No WASM code provided'); + + this.abi.constructors.forEach((c): void => { + const messageName = stringCamelCase(c.identifier); + + if (isUndefined(this.#tx[messageName])) { + this.#tx[messageName] = createBluePrintTx((o, p) => this.#instantiate(c, o, p)); + } + }); } /** * @description Deploy the code bundle, creating a Blueprint. + * @deprecated Use the `code.tx.(...) format to put code and deploy */ public createBlueprint (): SubmittableExtrinsic> { return this.api.tx.contracts .putCode(compactAddLength(this.code)) .withResultTransform((result: ISubmittableResult) => - new CodeSubmittableResult(result, applyOnEvent(result, 'CodeStored', ([record]: EventRecord[]) => + new CodeSubmittableResult(result, applyOnEvent(result, ['CodeStored'], ([record]: EventRecord[]) => new Blueprint(this.api, this.abi, record.event.data[0] as Hash, this._decorateMethod) )) ); } + + /** + * @description Deploy the code bundle and the contract, creating a Blueprint. + * @deprecated Use the `code.tx.(...) format to put code and deploy + */ + public createContract (constructorOrId: AbiConstructor | string | number, options: BlueprintOptions, params: CodecArg[]): SubmittableExtrinsic> { + return this.#instantiate(constructorOrId, options, params); + } + + public get tx (): MapConstructorExec { + return this.#tx; + } + + #instantiate = (constructorOrId: AbiConstructor | string | number, options: BlueprintOptions, params: CodecArg[]): SubmittableExtrinsic> => { + return isFunction(this.api.tx.contracts.instantiateWithCode) + ? this.#instantiateSingle(constructorOrId, options, params) + : this.#instantiateBatch(constructorOrId, options, params); + } + + #instantiateSingle = (constructorOrId: AbiConstructor | string | number, { gasLimit = 0, salt, value = 0 }: BlueprintOptions, params: CodecArg[]): SubmittableExtrinsic> => { + return this.api.tx.contracts + .instantiateWithCode(value, gasLimit, compactAddLength(this.code), this.abi.findConstructor(constructorOrId).toU8a(params), encodeSalt(salt)) + .withResultTransform(this.#transformEvents); + } + + #instantiateBatch = (constructorOrId: AbiConstructor | string | number, { gasLimit = 0, salt, value = 0 }: BlueprintOptions, params: CodecArg[]): SubmittableExtrinsic> => { + const encodedSalt = encodeSalt(salt); + const withSalt = this.api.tx.contracts.instantiate.meta.args.length === 5; + const encoded = this.abi.findConstructor(constructorOrId).toU8a(params, withSalt ? EMPTY_SALT : encodedSalt); + const codeHash = blake2AsU8a(this.code); + + return this.api.tx.utility.batch([ + this.api.tx.contracts.putCode(compactAddLength(this.code)), + withSalt + ? this.api.tx.contracts.instantiate(value, gasLimit, codeHash, encoded, encodedSalt) + // eslint-disable-next-line @typescript-eslint/ban-ts-comment + // @ts-ignore old style with salt included in the params itself + : this.api.tx.contracts.instantiate(value, gasLimit, codeHash, encoded) + ]).withResultTransform(this.#transformEvents); + } + + #transformEvents = (result: ISubmittableResult): CodeSubmittableResult => { + return new CodeSubmittableResult(result, ...(applyOnEvent(result, ['CodeStored', 'Instantiated'], (records: EventRecord[]) => + records.reduce(([blueprint, contract], { event }): [Blueprint?, Contract?] => + this.api.events.contracts.Instantiated.is(event) + ? [blueprint, new Contract(this.api, this.abi, event.data[1], this._decorateMethod)] + : this.api.events.contracts.CodeStored.is(event) + ? [new Blueprint(this.api, this.abi, event.data[0], this._decorateMethod), contract] + : [blueprint, contract], + [] as [Blueprint?, Contract?]) + ) || [])); + } } diff --git a/packages/api-contract/src/base/Contract.ts b/packages/api-contract/src/base/Contract.ts index 49f7af143a..62a7dd6a7c 100644 --- a/packages/api-contract/src/base/Contract.ts +++ b/packages/api-contract/src/base/Contract.ts @@ -156,7 +156,7 @@ export class Contract extends Base { return this.api.tx.contracts .call(this.address, value, this.#getGas(gasLimit), this.abi.findMessage(messageOrId).toU8a(params)) .withResultTransform((result: ISubmittableResult) => - new ContractSubmittableResult(result, applyOnEvent(result, 'ContractExecution', (records: EventRecord[]) => + new ContractSubmittableResult(result, applyOnEvent(result, ['ContractExecution'], (records: EventRecord[]) => records .map(({ event: { data: [, data] } }): DecodedEvent | null => { try { diff --git a/packages/api-contract/src/base/mock.ts b/packages/api-contract/src/base/mock.ts index d89e0dbc30..8ccf903856 100644 --- a/packages/api-contract/src/base/mock.ts +++ b/packages/api-contract/src/base/mock.ts @@ -11,6 +11,9 @@ export const mockApi = { rx: { tx: { contracts: { + instantiate: (): never => { + throw new Error('mock'); + }, putCode: (): never => { throw new Error('mock'); } diff --git a/packages/api-contract/src/base/util.ts b/packages/api-contract/src/base/util.ts new file mode 100644 index 0000000000..212cc0e188 --- /dev/null +++ b/packages/api-contract/src/base/util.ts @@ -0,0 +1,41 @@ +// Copyright 2017-2021 @polkadot/api-contract authors & contributors +// SPDX-License-Identifier: Apache-2.0 + +import type { SubmittableResult } from '@polkadot/api'; +import type { SubmittableExtrinsic } from '@polkadot/api/submittable/types'; +import type { ApiTypes } from '@polkadot/api/types'; +import type { CodecArg } from '@polkadot/types/types'; +import type { AbiConstructor, BlueprintOptions } from '../types'; +import type { BlueprintDeploy, ContractGeneric } from './types'; + +import BN from 'bn.js'; + +import { Bytes } from '@polkadot/types'; +import { compactAddLength, u8aToU8a } from '@polkadot/util'; +import { randomAsU8a } from '@polkadot/util-crypto'; + +import { extractOptions, isOptions } from '../util'; + +export const EMPTY_SALT = new Uint8Array(); + +export function createBluePrintTx (fn: (options: BlueprintOptions, params: CodecArg[]) => SubmittableExtrinsic): BlueprintDeploy { + return (options: BigInt | string | number | BN | BlueprintOptions, ...params: CodecArg[]): SubmittableExtrinsic => + isOptions(options) + ? fn(options, params) + : fn(...extractOptions(options, params)); +} + +export function createBluePrintWithId (fn: (constructorOrId: AbiConstructor | string | number, options: BlueprintOptions, params: CodecArg[]) => T): ContractGeneric { + return (constructorOrId: AbiConstructor | string | number, options: BigInt | string | number | BN | BlueprintOptions, ...params: CodecArg[]): T => + isOptions(options) + ? fn(constructorOrId, options, params) + : fn(constructorOrId, ...extractOptions(options, params)); +} + +export function encodeSalt (salt: Uint8Array | string | null = randomAsU8a()): Uint8Array { + return salt instanceof Bytes + ? salt + : salt && salt.length + ? compactAddLength(u8aToU8a(salt)) + : EMPTY_SALT; +} diff --git a/packages/api-contract/src/util.ts b/packages/api-contract/src/util.ts index bfa20b45d6..ced23371d2 100644 --- a/packages/api-contract/src/util.ts +++ b/packages/api-contract/src/util.ts @@ -20,9 +20,9 @@ export function formatData (registry: Registry, data: Raw, { type }: TypeDef): C return createTypeUnsafe(registry, type, [data], { isPedantic: true }); } -export function applyOnEvent (result: SubmittableResult, type: ContractEvents, fn: (records: EventRecord[]) => T): T | undefined { +export function applyOnEvent (result: SubmittableResult, types: ContractEvents[], fn: (records: EventRecord[]) => T): T | undefined { if (result.isInBlock || result.isFinalized) { - const records = result.filterRecords('contracts', type); + const records = result.filterRecords('contracts', types); if (records.length) { return fn(records); diff --git a/packages/api/src/submittable/Result.ts b/packages/api/src/submittable/Result.ts index 63a1c61d4a..110244ac92 100644 --- a/packages/api/src/submittable/Result.ts +++ b/packages/api/src/submittable/Result.ts @@ -66,14 +66,14 @@ export class SubmittableResult implements ISubmittableResult { /** * @description Filters EventRecords for the specified method & section (there could be multiple) */ - public filterRecords (section: string, method: string): EventRecord[] { - return filterAndApply(this.events, section, [method], recordIdentity); + public filterRecords (section: string, method: string | string[]): EventRecord[] { + return filterAndApply(this.events, section, Array.isArray(method) ? method : [method], recordIdentity); } /** * @description Finds an EventRecord for the specified method & section */ - public findRecord (section: string, method: string): EventRecord | undefined { + public findRecord (section: string, method: string | string[]): EventRecord | undefined { return this.filterRecords(section, method)[0]; }