1107 lines
46 KiB
JavaScript
1107 lines
46 KiB
JavaScript
|
(function (global, factory) {
|
||
|
|
typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports, require('@polkadot/types'), require('@polkadot/util'), require('@polkadot/api'), require('@polkadot/util-crypto')) :
|
||
|
|
typeof define === 'function' && define.amd ? define(['exports', '@polkadot/types', '@polkadot/util', '@polkadot/api', '@polkadot/util-crypto'], factory) :
|
||
|
|
(global = typeof globalThis !== 'undefined' ? globalThis : global || self, factory(global.polkadotApiContract = {}, global.polkadotTypes, global.polkadotUtil, global.polkadotApi, global.polkadotUtilCrypto));
|
||
|
|
})(this, (function (exports, types, util, api, utilCrypto) { 'use strict';
|
||
|
|
|
||
|
|
const global = typeof globalThis !== "undefined" ? globalThis : typeof self !== "undefined" ? self : window;
|
||
|
|
|
||
|
|
var _documentCurrentScript = typeof document !== 'undefined' ? document.currentScript : null;
|
||
|
|
var TypeDefInfo;
|
||
|
|
(function (TypeDefInfo) {
|
||
|
|
TypeDefInfo[TypeDefInfo["BTreeMap"] = 0] = "BTreeMap";
|
||
|
|
TypeDefInfo[TypeDefInfo["BTreeSet"] = 1] = "BTreeSet";
|
||
|
|
TypeDefInfo[TypeDefInfo["Compact"] = 2] = "Compact";
|
||
|
|
TypeDefInfo[TypeDefInfo["DoNotConstruct"] = 3] = "DoNotConstruct";
|
||
|
|
TypeDefInfo[TypeDefInfo["Enum"] = 4] = "Enum";
|
||
|
|
TypeDefInfo[TypeDefInfo["HashMap"] = 5] = "HashMap";
|
||
|
|
TypeDefInfo[TypeDefInfo["Int"] = 6] = "Int";
|
||
|
|
TypeDefInfo[TypeDefInfo["Linkage"] = 7] = "Linkage";
|
||
|
|
TypeDefInfo[TypeDefInfo["Null"] = 8] = "Null";
|
||
|
|
TypeDefInfo[TypeDefInfo["Option"] = 9] = "Option";
|
||
|
|
TypeDefInfo[TypeDefInfo["Plain"] = 10] = "Plain";
|
||
|
|
TypeDefInfo[TypeDefInfo["Range"] = 11] = "Range";
|
||
|
|
TypeDefInfo[TypeDefInfo["RangeInclusive"] = 12] = "RangeInclusive";
|
||
|
|
TypeDefInfo[TypeDefInfo["Result"] = 13] = "Result";
|
||
|
|
TypeDefInfo[TypeDefInfo["Set"] = 14] = "Set";
|
||
|
|
TypeDefInfo[TypeDefInfo["Si"] = 15] = "Si";
|
||
|
|
TypeDefInfo[TypeDefInfo["Struct"] = 16] = "Struct";
|
||
|
|
TypeDefInfo[TypeDefInfo["Tuple"] = 17] = "Tuple";
|
||
|
|
TypeDefInfo[TypeDefInfo["UInt"] = 18] = "UInt";
|
||
|
|
TypeDefInfo[TypeDefInfo["Vec"] = 19] = "Vec";
|
||
|
|
TypeDefInfo[TypeDefInfo["VecFixed"] = 20] = "VecFixed";
|
||
|
|
TypeDefInfo[TypeDefInfo["WrapperKeepOpaque"] = 21] = "WrapperKeepOpaque";
|
||
|
|
TypeDefInfo[TypeDefInfo["WrapperOpaque"] = 22] = "WrapperOpaque";
|
||
|
|
})(TypeDefInfo || (TypeDefInfo = {}));
|
||
|
|
|
||
|
|
function v0ToV1Names(all) {
|
||
|
|
return all.map((e) => util.objectSpread({}, e, {
|
||
|
|
name: Array.isArray(e.name)
|
||
|
|
? e.name
|
||
|
|
: [e.name]
|
||
|
|
}));
|
||
|
|
}
|
||
|
|
function v0ToV1(registry, v0) {
|
||
|
|
if (!v0.metadataVersion.length) {
|
||
|
|
throw new Error('Invalid format for V0 (detected) contract metadata');
|
||
|
|
}
|
||
|
|
return registry.createType('ContractMetadataV1', util.objectSpread({}, v0, {
|
||
|
|
spec: util.objectSpread({}, v0.spec, {
|
||
|
|
constructors: v0ToV1Names(v0.spec.constructors),
|
||
|
|
messages: v0ToV1Names(v0.spec.messages)
|
||
|
|
}),
|
||
|
|
types: types.convertSiV0toV1(registry, v0.types)
|
||
|
|
}));
|
||
|
|
}
|
||
|
|
|
||
|
|
const ARG_TYPES = {
|
||
|
|
ContractConstructorSpec: 'ContractMessageParamSpecV2',
|
||
|
|
ContractEventSpec: 'ContractEventParamSpecV2',
|
||
|
|
ContractMessageSpec: 'ContractMessageParamSpecV2'
|
||
|
|
};
|
||
|
|
function v1ToV2Label(entry) {
|
||
|
|
return util.objectSpread({}, entry, {
|
||
|
|
label: Array.isArray(entry.name)
|
||
|
|
? entry.name.join('::')
|
||
|
|
: entry.name
|
||
|
|
});
|
||
|
|
}
|
||
|
|
function v1ToV2Labels(registry, outType, all) {
|
||
|
|
return all.map((e) => registry.createType(`${outType}V2`, util.objectSpread(v1ToV2Label(e), {
|
||
|
|
args: e.args.map((a) => registry.createType(ARG_TYPES[outType], v1ToV2Label(a)))
|
||
|
|
})));
|
||
|
|
}
|
||
|
|
function v1ToV2(registry, v1) {
|
||
|
|
return registry.createType('ContractMetadataV2', util.objectSpread({}, v1, {
|
||
|
|
spec: util.objectSpread({}, v1.spec, {
|
||
|
|
constructors: v1ToV2Labels(registry, 'ContractConstructorSpec', v1.spec.constructors),
|
||
|
|
events: v1ToV2Labels(registry, 'ContractEventSpec', v1.spec.events),
|
||
|
|
messages: v1ToV2Labels(registry, 'ContractMessageSpec', v1.spec.messages)
|
||
|
|
})
|
||
|
|
}));
|
||
|
|
}
|
||
|
|
|
||
|
|
function v2ToV3(registry, v2) {
|
||
|
|
return registry.createType('ContractMetadataV3', util.objectSpread({}, v2, {
|
||
|
|
spec: util.objectSpread({}, v2.spec, {
|
||
|
|
constructors: v2.spec.constructors.map((c) =>
|
||
|
|
registry.createType('ContractConstructorSpecV3', util.objectSpread({}, c, { payable: true })))
|
||
|
|
})
|
||
|
|
}));
|
||
|
|
}
|
||
|
|
|
||
|
|
function v3ToV4(registry, v3) {
|
||
|
|
return registry.createType('ContractMetadataV4', util.objectSpread({}, v3, {
|
||
|
|
spec: util.objectSpread({}, v3.spec, {
|
||
|
|
constructors: v3.spec.constructors.map((c) => registry.createType('ContractConstructorSpecV4', util.objectSpread({}, c))),
|
||
|
|
messages: v3.spec.messages.map((m) => registry.createType('ContractMessageSpecV3', util.objectSpread({}, m)))
|
||
|
|
})
|
||
|
|
}));
|
||
|
|
}
|
||
|
|
|
||
|
|
const enumVersions = ['V4', 'V3', 'V2', 'V1'];
|
||
|
|
function createConverter(next, step) {
|
||
|
|
return (registry, input) => next(registry, step(registry, input));
|
||
|
|
}
|
||
|
|
function v4ToLatest(_registry, v4) {
|
||
|
|
return v4;
|
||
|
|
}
|
||
|
|
const v3ToLatest = createConverter(v4ToLatest, v3ToV4);
|
||
|
|
const v2ToLatest = createConverter(v3ToLatest, v2ToV3);
|
||
|
|
const v1ToLatest = createConverter(v2ToLatest, v1ToV2);
|
||
|
|
const v0ToLatest = createConverter(v1ToLatest, v0ToV1);
|
||
|
|
const convertVersions = [
|
||
|
|
['V4', v4ToLatest],
|
||
|
|
['V3', v3ToLatest],
|
||
|
|
['V2', v2ToLatest],
|
||
|
|
['V1', v1ToLatest],
|
||
|
|
['V0', v0ToLatest]
|
||
|
|
];
|
||
|
|
|
||
|
|
const l$1 = util.logger('Abi');
|
||
|
|
const PRIMITIVE_ALWAYS = ['AccountId', 'AccountIndex', 'Address', 'Balance'];
|
||
|
|
function findMessage(list, messageOrId) {
|
||
|
|
const message = util.isNumber(messageOrId)
|
||
|
|
? list[messageOrId]
|
||
|
|
: util.isString(messageOrId)
|
||
|
|
? list.find(({ identifier }) => [identifier, util.stringCamelCase(identifier)].includes(messageOrId.toString()))
|
||
|
|
: messageOrId;
|
||
|
|
return util.assertReturn(message, () => `Attempted to call an invalid contract interface, ${util.stringify(messageOrId)}`);
|
||
|
|
}
|
||
|
|
function getLatestMeta(registry, json) {
|
||
|
|
const vx = enumVersions.find((v) => util.isObject(json[v]));
|
||
|
|
const jsonVersion = json.version;
|
||
|
|
if (!vx && jsonVersion && !enumVersions.find((v) => v === `V${jsonVersion}`)) {
|
||
|
|
throw new Error(`Unable to handle version ${jsonVersion}`);
|
||
|
|
}
|
||
|
|
const metadata = registry.createType('ContractMetadata', vx
|
||
|
|
? { [vx]: json[vx] }
|
||
|
|
: jsonVersion
|
||
|
|
? { [`V${jsonVersion}`]: json }
|
||
|
|
: { V0: json });
|
||
|
|
const converter = convertVersions.find(([v]) => metadata[`is${v}`]);
|
||
|
|
if (!converter) {
|
||
|
|
throw new Error(`Unable to convert ABI with version ${metadata.type} to latest`);
|
||
|
|
}
|
||
|
|
return converter[1](registry, metadata[`as${converter[0]}`]);
|
||
|
|
}
|
||
|
|
function parseJson(json, chainProperties) {
|
||
|
|
const registry = new types.TypeRegistry();
|
||
|
|
const info = registry.createType('ContractProjectInfo', json);
|
||
|
|
const latest = getLatestMeta(registry, json);
|
||
|
|
const lookup = registry.createType('PortableRegistry', { types: latest.types }, true);
|
||
|
|
registry.setLookup(lookup);
|
||
|
|
if (chainProperties) {
|
||
|
|
registry.setChainProperties(chainProperties);
|
||
|
|
}
|
||
|
|
lookup.types.forEach(({ id }) => lookup.getTypeDef(id));
|
||
|
|
return [json, registry, latest, info];
|
||
|
|
}
|
||
|
|
function isTypeSpec(value) {
|
||
|
|
return !!value && value instanceof Map && !util.isUndefined(value.type) && !util.isUndefined(value.displayName);
|
||
|
|
}
|
||
|
|
function isOption(value) {
|
||
|
|
return !!value && value instanceof types.Option;
|
||
|
|
}
|
||
|
|
class Abi {
|
||
|
|
events;
|
||
|
|
constructors;
|
||
|
|
info;
|
||
|
|
json;
|
||
|
|
messages;
|
||
|
|
metadata;
|
||
|
|
registry;
|
||
|
|
environment = new Map();
|
||
|
|
constructor(abiJson, chainProperties) {
|
||
|
|
[this.json, this.registry, this.metadata, this.info] = parseJson(util.isString(abiJson)
|
||
|
|
? JSON.parse(abiJson)
|
||
|
|
: abiJson, chainProperties);
|
||
|
|
this.constructors = this.metadata.spec.constructors.map((spec, index) => this.__internal__createMessage(spec, index, {
|
||
|
|
isConstructor: true,
|
||
|
|
isDefault: spec.default.isTrue,
|
||
|
|
isPayable: spec.payable.isTrue,
|
||
|
|
returnType: spec.returnType.isSome
|
||
|
|
? this.registry.lookup.getTypeDef(spec.returnType.unwrap().type)
|
||
|
|
: null
|
||
|
|
}));
|
||
|
|
this.events = this.metadata.spec.events.map((spec, index) => this.__internal__createEvent(spec, index));
|
||
|
|
this.messages = this.metadata.spec.messages.map((spec, index) => this.__internal__createMessage(spec, index, {
|
||
|
|
isDefault: spec.default.isTrue,
|
||
|
|
isMutating: spec.mutates.isTrue,
|
||
|
|
isPayable: spec.payable.isTrue,
|
||
|
|
returnType: spec.returnType.isSome
|
||
|
|
? this.registry.lookup.getTypeDef(spec.returnType.unwrap().type)
|
||
|
|
: null
|
||
|
|
}));
|
||
|
|
for (const [key, opt] of this.metadata.spec.environment.entries()) {
|
||
|
|
if (isOption(opt)) {
|
||
|
|
if (opt.isSome) {
|
||
|
|
const value = opt.unwrap();
|
||
|
|
if (util.isBn(value)) {
|
||
|
|
this.environment.set(key, value);
|
||
|
|
}
|
||
|
|
else if (isTypeSpec(value)) {
|
||
|
|
this.environment.set(key, this.registry.lookup.getTypeDef(value.type));
|
||
|
|
}
|
||
|
|
else {
|
||
|
|
throw new Error(`Invalid environment definition for ${key}:: Expected either Number or ContractTypeSpec`);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
else {
|
||
|
|
throw new Error(`Expected Option<*> definition for ${key} in ContractEnvironment`);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
decodeEvent(data) {
|
||
|
|
const index = data[0];
|
||
|
|
const event = this.events[index];
|
||
|
|
if (!event) {
|
||
|
|
throw new Error(`Unable to find event with index ${index}`);
|
||
|
|
}
|
||
|
|
return event.fromU8a(data.subarray(1));
|
||
|
|
}
|
||
|
|
decodeConstructor(data) {
|
||
|
|
return this.__internal__decodeMessage('message', this.constructors, data);
|
||
|
|
}
|
||
|
|
decodeMessage(data) {
|
||
|
|
return this.__internal__decodeMessage('message', this.messages, data);
|
||
|
|
}
|
||
|
|
findConstructor(constructorOrId) {
|
||
|
|
return findMessage(this.constructors, constructorOrId);
|
||
|
|
}
|
||
|
|
findMessage(messageOrId) {
|
||
|
|
return findMessage(this.messages, messageOrId);
|
||
|
|
}
|
||
|
|
__internal__createArgs = (args, spec) => {
|
||
|
|
return args.map(({ label, type }, index) => {
|
||
|
|
try {
|
||
|
|
if (!util.isObject(type)) {
|
||
|
|
throw new Error('Invalid type definition found');
|
||
|
|
}
|
||
|
|
const displayName = type.displayName.length
|
||
|
|
? type.displayName[type.displayName.length - 1].toString()
|
||
|
|
: undefined;
|
||
|
|
const camelName = util.stringCamelCase(label);
|
||
|
|
if (displayName && PRIMITIVE_ALWAYS.includes(displayName)) {
|
||
|
|
return {
|
||
|
|
name: camelName,
|
||
|
|
type: {
|
||
|
|
info: TypeDefInfo.Plain,
|
||
|
|
type: displayName
|
||
|
|
}
|
||
|
|
};
|
||
|
|
}
|
||
|
|
const typeDef = this.registry.lookup.getTypeDef(type.type);
|
||
|
|
return {
|
||
|
|
name: camelName,
|
||
|
|
type: displayName && !typeDef.type.startsWith(displayName)
|
||
|
|
? { displayName, ...typeDef }
|
||
|
|
: typeDef
|
||
|
|
};
|
||
|
|
}
|
||
|
|
catch (error) {
|
||
|
|
l$1.error(`Error expanding argument ${index} in ${util.stringify(spec)}`);
|
||
|
|
throw error;
|
||
|
|
}
|
||
|
|
});
|
||
|
|
};
|
||
|
|
__internal__createEvent = (spec, index) => {
|
||
|
|
const args = this.__internal__createArgs(spec.args, spec);
|
||
|
|
const event = {
|
||
|
|
args,
|
||
|
|
docs: spec.docs.map((d) => d.toString()),
|
||
|
|
fromU8a: (data) => ({
|
||
|
|
args: this.__internal__decodeArgs(args, data),
|
||
|
|
event
|
||
|
|
}),
|
||
|
|
identifier: spec.label.toString(),
|
||
|
|
index
|
||
|
|
};
|
||
|
|
return event;
|
||
|
|
};
|
||
|
|
__internal__createMessage = (spec, index, add = {}) => {
|
||
|
|
const args = this.__internal__createArgs(spec.args, spec);
|
||
|
|
const identifier = spec.label.toString();
|
||
|
|
const message = {
|
||
|
|
...add,
|
||
|
|
args,
|
||
|
|
docs: spec.docs.map((d) => d.toString()),
|
||
|
|
fromU8a: (data) => ({
|
||
|
|
args: this.__internal__decodeArgs(args, data),
|
||
|
|
message
|
||
|
|
}),
|
||
|
|
identifier,
|
||
|
|
index,
|
||
|
|
isDefault: spec.default.isTrue,
|
||
|
|
method: util.stringCamelCase(identifier),
|
||
|
|
path: identifier.split('::').map((s) => util.stringCamelCase(s)),
|
||
|
|
selector: spec.selector,
|
||
|
|
toU8a: (params) => this.__internal__encodeArgs(spec, args, params)
|
||
|
|
};
|
||
|
|
return message;
|
||
|
|
};
|
||
|
|
__internal__decodeArgs = (args, data) => {
|
||
|
|
let offset = 0;
|
||
|
|
return args.map(({ type: { lookupName, type } }) => {
|
||
|
|
const value = this.registry.createType(lookupName || type, data.subarray(offset));
|
||
|
|
offset += value.encodedLength;
|
||
|
|
return value;
|
||
|
|
});
|
||
|
|
};
|
||
|
|
__internal__decodeMessage = (type, list, data) => {
|
||
|
|
const [, trimmed] = util.compactStripLength(data);
|
||
|
|
const selector = trimmed.subarray(0, 4);
|
||
|
|
const message = list.find((m) => m.selector.eq(selector));
|
||
|
|
if (!message) {
|
||
|
|
throw new Error(`Unable to find ${type} with selector ${util.u8aToHex(selector)}`);
|
||
|
|
}
|
||
|
|
return message.fromU8a(trimmed.subarray(4));
|
||
|
|
};
|
||
|
|
__internal__encodeArgs = ({ label, selector }, args, data) => {
|
||
|
|
if (data.length !== args.length) {
|
||
|
|
throw new Error(`Expected ${args.length} arguments to contract message '${label.toString()}', found ${data.length}`);
|
||
|
|
}
|
||
|
|
return util.compactAddLength(util.u8aConcat(this.registry.createType('ContractSelector', selector).toU8a(), ...args.map(({ type: { lookupName, type } }, index) => this.registry.createType(lookupName || type, data[index]).toU8a())));
|
||
|
|
};
|
||
|
|
}
|
||
|
|
|
||
|
|
const packageInfo = { name: '@polkadot/api-contract', path: (({ url: (typeof document === 'undefined' && typeof location === 'undefined' ? require('u' + 'rl').pathToFileURL(__filename).href : typeof document === 'undefined' ? location.href : (_documentCurrentScript && _documentCurrentScript.src || new URL('bundle-polkadot-api-contract.js', document.baseURI).href)) }) && (typeof document === 'undefined' && typeof location === 'undefined' ? require('u' + 'rl').pathToFileURL(__filename).href : typeof document === 'undefined' ? location.href : (_documentCurrentScript && _documentCurrentScript.src || new URL('bundle-polkadot-api-contract.js', document.baseURI).href))) ? new URL((typeof document === 'undefined' && typeof location === 'undefined' ? require('u' + 'rl').pathToFileURL(__filename).href : typeof document === 'undefined' ? location.href : (_documentCurrentScript && _documentCurrentScript.src || new URL('bundle-polkadot-api-contract.js', document.baseURI).href))).pathname.substring(0, new URL((typeof document === 'undefined' && typeof location === 'undefined' ? require('u' + 'rl').pathToFileURL(__filename).href : typeof document === 'undefined' ? location.href : (_documentCurrentScript && _documentCurrentScript.src || new URL('bundle-polkadot-api-contract.js', document.baseURI).href))).pathname.lastIndexOf('/') + 1) : 'auto', type: 'esm', version: '10.11.1' };
|
||
|
|
|
||
|
|
function applyOnEvent(result, types, fn) {
|
||
|
|
if (result.isInBlock || result.isFinalized) {
|
||
|
|
const records = result.filterRecords('contracts', types);
|
||
|
|
if (records.length) {
|
||
|
|
return fn(records);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
return undefined;
|
||
|
|
}
|
||
|
|
|
||
|
|
class Base {
|
||
|
|
abi;
|
||
|
|
api;
|
||
|
|
_decorateMethod;
|
||
|
|
_isWeightV1;
|
||
|
|
constructor(api, abi, decorateMethod) {
|
||
|
|
if (!api || !api.isConnected || !api.tx) {
|
||
|
|
throw new Error('Your API has not been initialized correctly and is not connected to a chain');
|
||
|
|
}
|
||
|
|
else if (!api.tx.contracts || !util.isFunction(api.tx.contracts.instantiateWithCode) || api.tx.contracts.instantiateWithCode.meta.args.length !== 6) {
|
||
|
|
throw new Error('The runtime does not expose api.tx.contracts.instantiateWithCode with storageDepositLimit');
|
||
|
|
}
|
||
|
|
else if (!api.call.contractsApi || !util.isFunction(api.call.contractsApi.call)) {
|
||
|
|
throw new Error('Your runtime does not expose the api.call.contractsApi.call runtime interfaces');
|
||
|
|
}
|
||
|
|
this.abi = abi instanceof Abi
|
||
|
|
? abi
|
||
|
|
: new Abi(abi, api.registry.getChainProperties());
|
||
|
|
this.api = api;
|
||
|
|
this._decorateMethod = decorateMethod;
|
||
|
|
this._isWeightV1 = !api.registry.createType('Weight').proofSize;
|
||
|
|
}
|
||
|
|
get registry() {
|
||
|
|
return this.api.registry;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
var extendStatics = function(d, b) {
|
||
|
|
extendStatics = Object.setPrototypeOf ||
|
||
|
|
({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
|
||
|
|
function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
|
||
|
|
return extendStatics(d, b);
|
||
|
|
};
|
||
|
|
function __extends(d, b) {
|
||
|
|
if (typeof b !== "function" && b !== null)
|
||
|
|
throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
|
||
|
|
extendStatics(d, b);
|
||
|
|
function __() { this.constructor = d; }
|
||
|
|
d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
|
||
|
|
}
|
||
|
|
function __values(o) {
|
||
|
|
var s = typeof Symbol === "function" && Symbol.iterator, m = s && o[s], i = 0;
|
||
|
|
if (m) return m.call(o);
|
||
|
|
if (o && typeof o.length === "number") return {
|
||
|
|
next: function () {
|
||
|
|
if (o && i >= o.length) o = void 0;
|
||
|
|
return { value: o && o[i++], done: !o };
|
||
|
|
}
|
||
|
|
};
|
||
|
|
throw new TypeError(s ? "Object is not iterable." : "Symbol.iterator is not defined.");
|
||
|
|
}
|
||
|
|
function __read(o, n) {
|
||
|
|
var m = typeof Symbol === "function" && o[Symbol.iterator];
|
||
|
|
if (!m) return o;
|
||
|
|
var i = m.call(o), r, ar = [], e;
|
||
|
|
try {
|
||
|
|
while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
|
||
|
|
}
|
||
|
|
catch (error) { e = { error: error }; }
|
||
|
|
finally {
|
||
|
|
try {
|
||
|
|
if (r && !r.done && (m = i["return"])) m.call(i);
|
||
|
|
}
|
||
|
|
finally { if (e) throw e.error; }
|
||
|
|
}
|
||
|
|
return ar;
|
||
|
|
}
|
||
|
|
function __spreadArray(to, from, pack) {
|
||
|
|
if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
|
||
|
|
if (ar || !(i in from)) {
|
||
|
|
if (!ar) ar = Array.prototype.slice.call(from, 0, i);
|
||
|
|
ar[i] = from[i];
|
||
|
|
}
|
||
|
|
}
|
||
|
|
return to.concat(ar || Array.prototype.slice.call(from));
|
||
|
|
}
|
||
|
|
typeof SuppressedError === "function" ? SuppressedError : function (error, suppressed, message) {
|
||
|
|
var e = new Error(message);
|
||
|
|
return e.name = "SuppressedError", e.error = error, e.suppressed = suppressed, e;
|
||
|
|
};
|
||
|
|
|
||
|
|
function isFunction(value) {
|
||
|
|
return typeof value === 'function';
|
||
|
|
}
|
||
|
|
|
||
|
|
function createErrorClass(createImpl) {
|
||
|
|
var _super = function (instance) {
|
||
|
|
Error.call(instance);
|
||
|
|
instance.stack = new Error().stack;
|
||
|
|
};
|
||
|
|
var ctorFunc = createImpl(_super);
|
||
|
|
ctorFunc.prototype = Object.create(Error.prototype);
|
||
|
|
ctorFunc.prototype.constructor = ctorFunc;
|
||
|
|
return ctorFunc;
|
||
|
|
}
|
||
|
|
|
||
|
|
var UnsubscriptionError = createErrorClass(function (_super) {
|
||
|
|
return function UnsubscriptionErrorImpl(errors) {
|
||
|
|
_super(this);
|
||
|
|
this.message = errors
|
||
|
|
? errors.length + " errors occurred during unsubscription:\n" + errors.map(function (err, i) { return i + 1 + ") " + err.toString(); }).join('\n ')
|
||
|
|
: '';
|
||
|
|
this.name = 'UnsubscriptionError';
|
||
|
|
this.errors = errors;
|
||
|
|
};
|
||
|
|
});
|
||
|
|
|
||
|
|
function arrRemove(arr, item) {
|
||
|
|
if (arr) {
|
||
|
|
var index = arr.indexOf(item);
|
||
|
|
0 <= index && arr.splice(index, 1);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
var Subscription = (function () {
|
||
|
|
function Subscription(initialTeardown) {
|
||
|
|
this.initialTeardown = initialTeardown;
|
||
|
|
this.closed = false;
|
||
|
|
this._parentage = null;
|
||
|
|
this._finalizers = null;
|
||
|
|
}
|
||
|
|
Subscription.prototype.unsubscribe = function () {
|
||
|
|
var e_1, _a, e_2, _b;
|
||
|
|
var errors;
|
||
|
|
if (!this.closed) {
|
||
|
|
this.closed = true;
|
||
|
|
var _parentage = this._parentage;
|
||
|
|
if (_parentage) {
|
||
|
|
this._parentage = null;
|
||
|
|
if (Array.isArray(_parentage)) {
|
||
|
|
try {
|
||
|
|
for (var _parentage_1 = __values(_parentage), _parentage_1_1 = _parentage_1.next(); !_parentage_1_1.done; _parentage_1_1 = _parentage_1.next()) {
|
||
|
|
var parent_1 = _parentage_1_1.value;
|
||
|
|
parent_1.remove(this);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
catch (e_1_1) { e_1 = { error: e_1_1 }; }
|
||
|
|
finally {
|
||
|
|
try {
|
||
|
|
if (_parentage_1_1 && !_parentage_1_1.done && (_a = _parentage_1.return)) _a.call(_parentage_1);
|
||
|
|
}
|
||
|
|
finally { if (e_1) throw e_1.error; }
|
||
|
|
}
|
||
|
|
}
|
||
|
|
else {
|
||
|
|
_parentage.remove(this);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
var initialFinalizer = this.initialTeardown;
|
||
|
|
if (isFunction(initialFinalizer)) {
|
||
|
|
try {
|
||
|
|
initialFinalizer();
|
||
|
|
}
|
||
|
|
catch (e) {
|
||
|
|
errors = e instanceof UnsubscriptionError ? e.errors : [e];
|
||
|
|
}
|
||
|
|
}
|
||
|
|
var _finalizers = this._finalizers;
|
||
|
|
if (_finalizers) {
|
||
|
|
this._finalizers = null;
|
||
|
|
try {
|
||
|
|
for (var _finalizers_1 = __values(_finalizers), _finalizers_1_1 = _finalizers_1.next(); !_finalizers_1_1.done; _finalizers_1_1 = _finalizers_1.next()) {
|
||
|
|
var finalizer = _finalizers_1_1.value;
|
||
|
|
try {
|
||
|
|
execFinalizer(finalizer);
|
||
|
|
}
|
||
|
|
catch (err) {
|
||
|
|
errors = errors !== null && errors !== void 0 ? errors : [];
|
||
|
|
if (err instanceof UnsubscriptionError) {
|
||
|
|
errors = __spreadArray(__spreadArray([], __read(errors)), __read(err.errors));
|
||
|
|
}
|
||
|
|
else {
|
||
|
|
errors.push(err);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
catch (e_2_1) { e_2 = { error: e_2_1 }; }
|
||
|
|
finally {
|
||
|
|
try {
|
||
|
|
if (_finalizers_1_1 && !_finalizers_1_1.done && (_b = _finalizers_1.return)) _b.call(_finalizers_1);
|
||
|
|
}
|
||
|
|
finally { if (e_2) throw e_2.error; }
|
||
|
|
}
|
||
|
|
}
|
||
|
|
if (errors) {
|
||
|
|
throw new UnsubscriptionError(errors);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
};
|
||
|
|
Subscription.prototype.add = function (teardown) {
|
||
|
|
var _a;
|
||
|
|
if (teardown && teardown !== this) {
|
||
|
|
if (this.closed) {
|
||
|
|
execFinalizer(teardown);
|
||
|
|
}
|
||
|
|
else {
|
||
|
|
if (teardown instanceof Subscription) {
|
||
|
|
if (teardown.closed || teardown._hasParent(this)) {
|
||
|
|
return;
|
||
|
|
}
|
||
|
|
teardown._addParent(this);
|
||
|
|
}
|
||
|
|
(this._finalizers = (_a = this._finalizers) !== null && _a !== void 0 ? _a : []).push(teardown);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
};
|
||
|
|
Subscription.prototype._hasParent = function (parent) {
|
||
|
|
var _parentage = this._parentage;
|
||
|
|
return _parentage === parent || (Array.isArray(_parentage) && _parentage.includes(parent));
|
||
|
|
};
|
||
|
|
Subscription.prototype._addParent = function (parent) {
|
||
|
|
var _parentage = this._parentage;
|
||
|
|
this._parentage = Array.isArray(_parentage) ? (_parentage.push(parent), _parentage) : _parentage ? [_parentage, parent] : parent;
|
||
|
|
};
|
||
|
|
Subscription.prototype._removeParent = function (parent) {
|
||
|
|
var _parentage = this._parentage;
|
||
|
|
if (_parentage === parent) {
|
||
|
|
this._parentage = null;
|
||
|
|
}
|
||
|
|
else if (Array.isArray(_parentage)) {
|
||
|
|
arrRemove(_parentage, parent);
|
||
|
|
}
|
||
|
|
};
|
||
|
|
Subscription.prototype.remove = function (teardown) {
|
||
|
|
var _finalizers = this._finalizers;
|
||
|
|
_finalizers && arrRemove(_finalizers, teardown);
|
||
|
|
if (teardown instanceof Subscription) {
|
||
|
|
teardown._removeParent(this);
|
||
|
|
}
|
||
|
|
};
|
||
|
|
Subscription.EMPTY = (function () {
|
||
|
|
var empty = new Subscription();
|
||
|
|
empty.closed = true;
|
||
|
|
return empty;
|
||
|
|
})();
|
||
|
|
return Subscription;
|
||
|
|
}());
|
||
|
|
Subscription.EMPTY;
|
||
|
|
function isSubscription(value) {
|
||
|
|
return (value instanceof Subscription ||
|
||
|
|
(value && 'closed' in value && isFunction(value.remove) && isFunction(value.add) && isFunction(value.unsubscribe)));
|
||
|
|
}
|
||
|
|
function execFinalizer(finalizer) {
|
||
|
|
if (isFunction(finalizer)) {
|
||
|
|
finalizer();
|
||
|
|
}
|
||
|
|
else {
|
||
|
|
finalizer.unsubscribe();
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
var config = {
|
||
|
|
onUnhandledError: null,
|
||
|
|
onStoppedNotification: null,
|
||
|
|
Promise: undefined,
|
||
|
|
useDeprecatedSynchronousErrorHandling: false,
|
||
|
|
useDeprecatedNextContext: false,
|
||
|
|
};
|
||
|
|
|
||
|
|
var timeoutProvider = {
|
||
|
|
setTimeout: function (handler, timeout) {
|
||
|
|
var args = [];
|
||
|
|
for (var _i = 2; _i < arguments.length; _i++) {
|
||
|
|
args[_i - 2] = arguments[_i];
|
||
|
|
}
|
||
|
|
var delegate = timeoutProvider.delegate;
|
||
|
|
if (delegate === null || delegate === void 0 ? void 0 : delegate.setTimeout) {
|
||
|
|
return delegate.setTimeout.apply(delegate, __spreadArray([handler, timeout], __read(args)));
|
||
|
|
}
|
||
|
|
return setTimeout.apply(void 0, __spreadArray([handler, timeout], __read(args)));
|
||
|
|
},
|
||
|
|
clearTimeout: function (handle) {
|
||
|
|
var delegate = timeoutProvider.delegate;
|
||
|
|
return ((delegate === null || delegate === void 0 ? void 0 : delegate.clearTimeout) || clearTimeout)(handle);
|
||
|
|
},
|
||
|
|
delegate: undefined,
|
||
|
|
};
|
||
|
|
|
||
|
|
function reportUnhandledError(err) {
|
||
|
|
timeoutProvider.setTimeout(function () {
|
||
|
|
{
|
||
|
|
throw err;
|
||
|
|
}
|
||
|
|
});
|
||
|
|
}
|
||
|
|
|
||
|
|
function noop() { }
|
||
|
|
|
||
|
|
var Subscriber = (function (_super) {
|
||
|
|
__extends(Subscriber, _super);
|
||
|
|
function Subscriber(destination) {
|
||
|
|
var _this = _super.call(this) || this;
|
||
|
|
_this.isStopped = false;
|
||
|
|
if (destination) {
|
||
|
|
_this.destination = destination;
|
||
|
|
if (isSubscription(destination)) {
|
||
|
|
destination.add(_this);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
else {
|
||
|
|
_this.destination = EMPTY_OBSERVER;
|
||
|
|
}
|
||
|
|
return _this;
|
||
|
|
}
|
||
|
|
Subscriber.create = function (next, error, complete) {
|
||
|
|
return new SafeSubscriber(next, error, complete);
|
||
|
|
};
|
||
|
|
Subscriber.prototype.next = function (value) {
|
||
|
|
if (this.isStopped) ;
|
||
|
|
else {
|
||
|
|
this._next(value);
|
||
|
|
}
|
||
|
|
};
|
||
|
|
Subscriber.prototype.error = function (err) {
|
||
|
|
if (this.isStopped) ;
|
||
|
|
else {
|
||
|
|
this.isStopped = true;
|
||
|
|
this._error(err);
|
||
|
|
}
|
||
|
|
};
|
||
|
|
Subscriber.prototype.complete = function () {
|
||
|
|
if (this.isStopped) ;
|
||
|
|
else {
|
||
|
|
this.isStopped = true;
|
||
|
|
this._complete();
|
||
|
|
}
|
||
|
|
};
|
||
|
|
Subscriber.prototype.unsubscribe = function () {
|
||
|
|
if (!this.closed) {
|
||
|
|
this.isStopped = true;
|
||
|
|
_super.prototype.unsubscribe.call(this);
|
||
|
|
this.destination = null;
|
||
|
|
}
|
||
|
|
};
|
||
|
|
Subscriber.prototype._next = function (value) {
|
||
|
|
this.destination.next(value);
|
||
|
|
};
|
||
|
|
Subscriber.prototype._error = function (err) {
|
||
|
|
try {
|
||
|
|
this.destination.error(err);
|
||
|
|
}
|
||
|
|
finally {
|
||
|
|
this.unsubscribe();
|
||
|
|
}
|
||
|
|
};
|
||
|
|
Subscriber.prototype._complete = function () {
|
||
|
|
try {
|
||
|
|
this.destination.complete();
|
||
|
|
}
|
||
|
|
finally {
|
||
|
|
this.unsubscribe();
|
||
|
|
}
|
||
|
|
};
|
||
|
|
return Subscriber;
|
||
|
|
}(Subscription));
|
||
|
|
var _bind = Function.prototype.bind;
|
||
|
|
function bind(fn, thisArg) {
|
||
|
|
return _bind.call(fn, thisArg);
|
||
|
|
}
|
||
|
|
var ConsumerObserver = (function () {
|
||
|
|
function ConsumerObserver(partialObserver) {
|
||
|
|
this.partialObserver = partialObserver;
|
||
|
|
}
|
||
|
|
ConsumerObserver.prototype.next = function (value) {
|
||
|
|
var partialObserver = this.partialObserver;
|
||
|
|
if (partialObserver.next) {
|
||
|
|
try {
|
||
|
|
partialObserver.next(value);
|
||
|
|
}
|
||
|
|
catch (error) {
|
||
|
|
handleUnhandledError(error);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
};
|
||
|
|
ConsumerObserver.prototype.error = function (err) {
|
||
|
|
var partialObserver = this.partialObserver;
|
||
|
|
if (partialObserver.error) {
|
||
|
|
try {
|
||
|
|
partialObserver.error(err);
|
||
|
|
}
|
||
|
|
catch (error) {
|
||
|
|
handleUnhandledError(error);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
else {
|
||
|
|
handleUnhandledError(err);
|
||
|
|
}
|
||
|
|
};
|
||
|
|
ConsumerObserver.prototype.complete = function () {
|
||
|
|
var partialObserver = this.partialObserver;
|
||
|
|
if (partialObserver.complete) {
|
||
|
|
try {
|
||
|
|
partialObserver.complete();
|
||
|
|
}
|
||
|
|
catch (error) {
|
||
|
|
handleUnhandledError(error);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
};
|
||
|
|
return ConsumerObserver;
|
||
|
|
}());
|
||
|
|
var SafeSubscriber = (function (_super) {
|
||
|
|
__extends(SafeSubscriber, _super);
|
||
|
|
function SafeSubscriber(observerOrNext, error, complete) {
|
||
|
|
var _this = _super.call(this) || this;
|
||
|
|
var partialObserver;
|
||
|
|
if (isFunction(observerOrNext) || !observerOrNext) {
|
||
|
|
partialObserver = {
|
||
|
|
next: (observerOrNext !== null && observerOrNext !== void 0 ? observerOrNext : undefined),
|
||
|
|
error: error !== null && error !== void 0 ? error : undefined,
|
||
|
|
complete: complete !== null && complete !== void 0 ? complete : undefined,
|
||
|
|
};
|
||
|
|
}
|
||
|
|
else {
|
||
|
|
var context_1;
|
||
|
|
if (_this && config.useDeprecatedNextContext) {
|
||
|
|
context_1 = Object.create(observerOrNext);
|
||
|
|
context_1.unsubscribe = function () { return _this.unsubscribe(); };
|
||
|
|
partialObserver = {
|
||
|
|
next: observerOrNext.next && bind(observerOrNext.next, context_1),
|
||
|
|
error: observerOrNext.error && bind(observerOrNext.error, context_1),
|
||
|
|
complete: observerOrNext.complete && bind(observerOrNext.complete, context_1),
|
||
|
|
};
|
||
|
|
}
|
||
|
|
else {
|
||
|
|
partialObserver = observerOrNext;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
_this.destination = new ConsumerObserver(partialObserver);
|
||
|
|
return _this;
|
||
|
|
}
|
||
|
|
return SafeSubscriber;
|
||
|
|
}(Subscriber));
|
||
|
|
function handleUnhandledError(error) {
|
||
|
|
{
|
||
|
|
reportUnhandledError(error);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
function defaultErrorHandler(err) {
|
||
|
|
throw err;
|
||
|
|
}
|
||
|
|
var EMPTY_OBSERVER = {
|
||
|
|
closed: true,
|
||
|
|
next: noop,
|
||
|
|
error: defaultErrorHandler,
|
||
|
|
complete: noop,
|
||
|
|
};
|
||
|
|
|
||
|
|
function hasLift(source) {
|
||
|
|
return isFunction(source === null || source === void 0 ? void 0 : source.lift);
|
||
|
|
}
|
||
|
|
function operate(init) {
|
||
|
|
return function (source) {
|
||
|
|
if (hasLift(source)) {
|
||
|
|
return source.lift(function (liftedSource) {
|
||
|
|
try {
|
||
|
|
return init(liftedSource, this);
|
||
|
|
}
|
||
|
|
catch (err) {
|
||
|
|
this.error(err);
|
||
|
|
}
|
||
|
|
});
|
||
|
|
}
|
||
|
|
throw new TypeError('Unable to lift unknown Observable type');
|
||
|
|
};
|
||
|
|
}
|
||
|
|
|
||
|
|
function createOperatorSubscriber(destination, onNext, onComplete, onError, onFinalize) {
|
||
|
|
return new OperatorSubscriber(destination, onNext, onComplete, onError, onFinalize);
|
||
|
|
}
|
||
|
|
var OperatorSubscriber = (function (_super) {
|
||
|
|
__extends(OperatorSubscriber, _super);
|
||
|
|
function OperatorSubscriber(destination, onNext, onComplete, onError, onFinalize, shouldUnsubscribe) {
|
||
|
|
var _this = _super.call(this, destination) || this;
|
||
|
|
_this.onFinalize = onFinalize;
|
||
|
|
_this.shouldUnsubscribe = shouldUnsubscribe;
|
||
|
|
_this._next = onNext
|
||
|
|
? function (value) {
|
||
|
|
try {
|
||
|
|
onNext(value);
|
||
|
|
}
|
||
|
|
catch (err) {
|
||
|
|
destination.error(err);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
: _super.prototype._next;
|
||
|
|
_this._error = onError
|
||
|
|
? function (err) {
|
||
|
|
try {
|
||
|
|
onError(err);
|
||
|
|
}
|
||
|
|
catch (err) {
|
||
|
|
destination.error(err);
|
||
|
|
}
|
||
|
|
finally {
|
||
|
|
this.unsubscribe();
|
||
|
|
}
|
||
|
|
}
|
||
|
|
: _super.prototype._error;
|
||
|
|
_this._complete = onComplete
|
||
|
|
? function () {
|
||
|
|
try {
|
||
|
|
onComplete();
|
||
|
|
}
|
||
|
|
catch (err) {
|
||
|
|
destination.error(err);
|
||
|
|
}
|
||
|
|
finally {
|
||
|
|
this.unsubscribe();
|
||
|
|
}
|
||
|
|
}
|
||
|
|
: _super.prototype._complete;
|
||
|
|
return _this;
|
||
|
|
}
|
||
|
|
OperatorSubscriber.prototype.unsubscribe = function () {
|
||
|
|
var _a;
|
||
|
|
if (!this.shouldUnsubscribe || this.shouldUnsubscribe()) {
|
||
|
|
var closed_1 = this.closed;
|
||
|
|
_super.prototype.unsubscribe.call(this);
|
||
|
|
!closed_1 && ((_a = this.onFinalize) === null || _a === void 0 ? void 0 : _a.call(this));
|
||
|
|
}
|
||
|
|
};
|
||
|
|
return OperatorSubscriber;
|
||
|
|
}(Subscriber));
|
||
|
|
|
||
|
|
function map(project, thisArg) {
|
||
|
|
return operate(function (source, subscriber) {
|
||
|
|
var index = 0;
|
||
|
|
source.subscribe(createOperatorSubscriber(subscriber, function (value) {
|
||
|
|
subscriber.next(project.call(thisArg, value, index++));
|
||
|
|
}));
|
||
|
|
});
|
||
|
|
}
|
||
|
|
|
||
|
|
const EMPTY_SALT = new Uint8Array();
|
||
|
|
function withMeta(meta, creator) {
|
||
|
|
creator.meta = meta;
|
||
|
|
return creator;
|
||
|
|
}
|
||
|
|
function createBluePrintTx(meta, fn) {
|
||
|
|
return withMeta(meta, (options, ...params) => fn(options, params));
|
||
|
|
}
|
||
|
|
function encodeSalt(salt = utilCrypto.randomAsU8a()) {
|
||
|
|
return salt instanceof types.Bytes
|
||
|
|
? salt
|
||
|
|
: salt?.length
|
||
|
|
? util.compactAddLength(util.u8aToU8a(salt))
|
||
|
|
: EMPTY_SALT;
|
||
|
|
}
|
||
|
|
function convertWeight(weight) {
|
||
|
|
const [refTime, proofSize] = isWeightV2(weight)
|
||
|
|
? [weight.refTime.toBn(), weight.proofSize.toBn()]
|
||
|
|
: [util.bnToBn(weight), undefined];
|
||
|
|
return {
|
||
|
|
v1Weight: refTime,
|
||
|
|
v2Weight: { proofSize, refTime }
|
||
|
|
};
|
||
|
|
}
|
||
|
|
function isWeightV2(weight) {
|
||
|
|
return !!weight.proofSize;
|
||
|
|
}
|
||
|
|
|
||
|
|
const MAX_CALL_GAS = new util.BN(5000000000000).isub(util.BN_ONE);
|
||
|
|
const l = util.logger('Contract');
|
||
|
|
function createQuery(meta, fn) {
|
||
|
|
return withMeta(meta, (origin, options, ...params) => fn(origin, options, params));
|
||
|
|
}
|
||
|
|
function createTx(meta, fn) {
|
||
|
|
return withMeta(meta, (options, ...params) => fn(options, params));
|
||
|
|
}
|
||
|
|
class ContractSubmittableResult extends api.SubmittableResult {
|
||
|
|
contractEvents;
|
||
|
|
constructor(result, contractEvents) {
|
||
|
|
super(result);
|
||
|
|
this.contractEvents = contractEvents;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
class Contract extends Base {
|
||
|
|
address;
|
||
|
|
__internal__query = {};
|
||
|
|
__internal__tx = {};
|
||
|
|
constructor(api, abi, address, decorateMethod) {
|
||
|
|
super(api, abi, decorateMethod);
|
||
|
|
this.address = this.registry.createType('AccountId', address);
|
||
|
|
this.abi.messages.forEach((m) => {
|
||
|
|
if (util.isUndefined(this.__internal__tx[m.method])) {
|
||
|
|
this.__internal__tx[m.method] = createTx(m, (o, p) => this.__internal__exec(m, o, p));
|
||
|
|
}
|
||
|
|
if (util.isUndefined(this.__internal__query[m.method])) {
|
||
|
|
this.__internal__query[m.method] = createQuery(m, (f, o, p) => this.__internal__read(m, o, p).send(f));
|
||
|
|
}
|
||
|
|
});
|
||
|
|
}
|
||
|
|
get query() {
|
||
|
|
return this.__internal__query;
|
||
|
|
}
|
||
|
|
get tx() {
|
||
|
|
return this.__internal__tx;
|
||
|
|
}
|
||
|
|
__internal__getGas = (_gasLimit, isCall = false) => {
|
||
|
|
const weight = convertWeight(_gasLimit);
|
||
|
|
if (weight.v1Weight.gt(util.BN_ZERO)) {
|
||
|
|
return weight;
|
||
|
|
}
|
||
|
|
return convertWeight(isCall
|
||
|
|
? MAX_CALL_GAS
|
||
|
|
: convertWeight(this.api.consts.system.blockWeights
|
||
|
|
? this.api.consts.system.blockWeights.maxBlock
|
||
|
|
: this.api.consts.system['maximumBlockWeight']).v1Weight.muln(64).div(util.BN_HUNDRED));
|
||
|
|
};
|
||
|
|
__internal__exec = (messageOrId, { gasLimit = util.BN_ZERO, storageDepositLimit = null, value = util.BN_ZERO }, params) => {
|
||
|
|
return this.api.tx.contracts.call(this.address, value,
|
||
|
|
this._isWeightV1
|
||
|
|
? convertWeight(gasLimit).v1Weight
|
||
|
|
: convertWeight(gasLimit).v2Weight, storageDepositLimit, this.abi.findMessage(messageOrId).toU8a(params)).withResultTransform((result) =>
|
||
|
|
new ContractSubmittableResult(result, applyOnEvent(result, ['ContractEmitted', 'ContractExecution'], (records) => records
|
||
|
|
.map(({ event: { data: [, data] } }) => {
|
||
|
|
try {
|
||
|
|
return this.abi.decodeEvent(data);
|
||
|
|
}
|
||
|
|
catch (error) {
|
||
|
|
l.error(`Unable to decode contract event: ${error.message}`);
|
||
|
|
return null;
|
||
|
|
}
|
||
|
|
})
|
||
|
|
.filter((decoded) => !!decoded))));
|
||
|
|
};
|
||
|
|
__internal__read = (messageOrId, { gasLimit = util.BN_ZERO, storageDepositLimit = null, value = util.BN_ZERO }, params) => {
|
||
|
|
const message = this.abi.findMessage(messageOrId);
|
||
|
|
return {
|
||
|
|
send: this._decorateMethod((origin) => this.api.rx.call.contractsApi.call(origin, this.address, value,
|
||
|
|
this._isWeightV1
|
||
|
|
? this.__internal__getGas(gasLimit, true).v1Weight
|
||
|
|
: this.__internal__getGas(gasLimit, true).v2Weight, storageDepositLimit, message.toU8a(params)).pipe(map(({ debugMessage, gasConsumed, gasRequired, result, storageDeposit }) => ({
|
||
|
|
debugMessage,
|
||
|
|
gasConsumed,
|
||
|
|
gasRequired: gasRequired && !convertWeight(gasRequired).v1Weight.isZero()
|
||
|
|
? gasRequired
|
||
|
|
: gasConsumed,
|
||
|
|
output: result.isOk && message.returnType
|
||
|
|
? this.abi.registry.createTypeUnsafe(message.returnType.lookupName || message.returnType.type, [result.asOk.data.toU8a(true)], { isPedantic: true })
|
||
|
|
: null,
|
||
|
|
result,
|
||
|
|
storageDeposit
|
||
|
|
}))))
|
||
|
|
};
|
||
|
|
};
|
||
|
|
}
|
||
|
|
|
||
|
|
class BlueprintSubmittableResult extends api.SubmittableResult {
|
||
|
|
contract;
|
||
|
|
constructor(result, contract) {
|
||
|
|
super(result);
|
||
|
|
this.contract = contract;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
class Blueprint extends Base {
|
||
|
|
codeHash;
|
||
|
|
__internal__tx = {};
|
||
|
|
constructor(api, abi, codeHash, decorateMethod) {
|
||
|
|
super(api, abi, decorateMethod);
|
||
|
|
this.codeHash = this.registry.createType('Hash', codeHash);
|
||
|
|
this.abi.constructors.forEach((c) => {
|
||
|
|
if (util.isUndefined(this.__internal__tx[c.method])) {
|
||
|
|
this.__internal__tx[c.method] = createBluePrintTx(c, (o, p) => this.__internal__deploy(c, o, p));
|
||
|
|
}
|
||
|
|
});
|
||
|
|
}
|
||
|
|
get tx() {
|
||
|
|
return this.__internal__tx;
|
||
|
|
}
|
||
|
|
__internal__deploy = (constructorOrId, { gasLimit = util.BN_ZERO, salt, storageDepositLimit = null, value = util.BN_ZERO }, params) => {
|
||
|
|
return this.api.tx.contracts.instantiate(value,
|
||
|
|
this._isWeightV1
|
||
|
|
? convertWeight(gasLimit).v1Weight
|
||
|
|
: convertWeight(gasLimit).v2Weight, storageDepositLimit, this.codeHash, this.abi.findConstructor(constructorOrId).toU8a(params), encodeSalt(salt)).withResultTransform((result) => new BlueprintSubmittableResult(result, applyOnEvent(result, ['Instantiated'], ([record]) => new Contract(this.api, this.abi, record.event.data[1], this._decorateMethod))));
|
||
|
|
};
|
||
|
|
}
|
||
|
|
|
||
|
|
class CodeSubmittableResult extends api.SubmittableResult {
|
||
|
|
blueprint;
|
||
|
|
contract;
|
||
|
|
constructor(result, blueprint, contract) {
|
||
|
|
super(result);
|
||
|
|
this.blueprint = blueprint;
|
||
|
|
this.contract = contract;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
function isValidCode(code) {
|
||
|
|
return util.isWasm(code) || util.isRiscV(code);
|
||
|
|
}
|
||
|
|
class Code extends Base {
|
||
|
|
code;
|
||
|
|
__internal__tx = {};
|
||
|
|
constructor(api, abi, wasm, decorateMethod) {
|
||
|
|
super(api, abi, decorateMethod);
|
||
|
|
this.code = isValidCode(this.abi.info.source.wasm)
|
||
|
|
? this.abi.info.source.wasm
|
||
|
|
: util.u8aToU8a(wasm);
|
||
|
|
if (!isValidCode(this.code)) {
|
||
|
|
throw new Error('Invalid code provided');
|
||
|
|
}
|
||
|
|
this.abi.constructors.forEach((c) => {
|
||
|
|
if (util.isUndefined(this.__internal__tx[c.method])) {
|
||
|
|
this.__internal__tx[c.method] = createBluePrintTx(c, (o, p) => this.__internal__instantiate(c, o, p));
|
||
|
|
}
|
||
|
|
});
|
||
|
|
}
|
||
|
|
get tx() {
|
||
|
|
return this.__internal__tx;
|
||
|
|
}
|
||
|
|
__internal__instantiate = (constructorOrId, { gasLimit = util.BN_ZERO, salt, storageDepositLimit = null, value = util.BN_ZERO }, params) => {
|
||
|
|
return this.api.tx.contracts.instantiateWithCode(value,
|
||
|
|
this._isWeightV1
|
||
|
|
? convertWeight(gasLimit).v1Weight
|
||
|
|
: convertWeight(gasLimit).v2Weight, storageDepositLimit, util.compactAddLength(this.code), this.abi.findConstructor(constructorOrId).toU8a(params), encodeSalt(salt)).withResultTransform((result) => new CodeSubmittableResult(result, ...(applyOnEvent(result, ['CodeStored', 'Instantiated'], (records) => records.reduce(([blueprint, contract], { event }) => 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], [undefined, undefined])) || [undefined, undefined])));
|
||
|
|
};
|
||
|
|
}
|
||
|
|
|
||
|
|
class BlueprintPromise extends Blueprint {
|
||
|
|
constructor(api$1, abi, codeHash) {
|
||
|
|
super(api$1, abi, codeHash, api.toPromiseMethod);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
class CodePromise extends Code {
|
||
|
|
constructor(api$1, abi, wasm) {
|
||
|
|
super(api$1, abi, wasm, api.toPromiseMethod);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
class ContractPromise extends Contract {
|
||
|
|
constructor(api$1, abi, address) {
|
||
|
|
super(api$1, abi, address, api.toPromiseMethod);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
class BlueprintRx extends Blueprint {
|
||
|
|
constructor(api$1, abi, codeHash) {
|
||
|
|
super(api$1, abi, codeHash, api.toRxMethod);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
class CodeRx extends Code {
|
||
|
|
constructor(api$1, abi, wasm) {
|
||
|
|
super(api$1, abi, wasm, api.toRxMethod);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
class ContractRx extends Contract {
|
||
|
|
constructor(api$1, abi, address) {
|
||
|
|
super(api$1, abi, address, api.toRxMethod);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
exports.Abi = Abi;
|
||
|
|
exports.BlueprintPromise = BlueprintPromise;
|
||
|
|
exports.BlueprintRx = BlueprintRx;
|
||
|
|
exports.CodePromise = CodePromise;
|
||
|
|
exports.CodeRx = CodeRx;
|
||
|
|
exports.ContractPromise = ContractPromise;
|
||
|
|
exports.ContractRx = ContractRx;
|
||
|
|
exports.packageInfo = packageInfo;
|
||
|
|
|
||
|
|
}));
|