@aeternity/aepp-sdk 13.2.0 → 13.2.2

package/dist/aepp-sdk.js

@@ -1,4297 +1,16 @@
 (function webpackUniversalModuleDefinition(root, factory) {
 	if(typeof exports === 'object' && typeof module === 'object')
-		module.exports = factory(require("@azure/core-rest-pipeline"), require("rlp"), require("bs58"), require("buffer"), require("bignumber.js"), require("tweetnacl"), require("varuint-bitcoin"), require("@azure/core-client"), require("canonicalize"), require("@aeternity/uuid"), require("@aeternity/argon2"), require("tweetnacl-auth"), require("bip32-path"), require("aes-js"), require("@aeternity/aepp-calldata"), require("json-bigint"), require("events"), require("websocket"), require("isomorphic-ws"));
+		module.exports = factory(require("@azure/core-rest-pipeline"), require("rlp"), require("bs58"), require("buffer"), require("bignumber.js"), require("tweetnacl"), require("varuint-bitcoin"), require("@azure/core-client"), require("@aeternity/aepp-calldata"), require("canonicalize"), require("@aeternity/uuid"), require("@aeternity/argon2"), require("tweetnacl-auth"), require("bip32-path"), require("aes-js"), require("json-bigint"), require("events"), require("websocket"), require("isomorphic-ws"));
 	else if(typeof define === 'function' && define.amd)
-		define(["@azure/core-rest-pipeline", "rlp", "bs58", "buffer", "bignumber.js", "tweetnacl", "varuint-bitcoin", "@azure/core-client", "canonicalize", "@aeternity/uuid", "@aeternity/argon2", "tweetnacl-auth", "bip32-path", "aes-js", "@aeternity/aepp-calldata", "json-bigint", "events", "websocket", "isomorphic-ws"], factory);
+		define(["@azure/core-rest-pipeline", "rlp", "bs58", "buffer", "bignumber.js", "tweetnacl", "varuint-bitcoin", "@azure/core-client", "@aeternity/aepp-calldata", "canonicalize", "@aeternity/uuid", "@aeternity/argon2", "tweetnacl-auth", "bip32-path", "aes-js", "json-bigint", "events", "websocket", "isomorphic-ws"], factory);
 	else if(typeof exports === 'object')
-		exports["Aeternity"] = factory(require("@azure/core-rest-pipeline"), require("rlp"), require("bs58"), require("buffer"), require("bignumber.js"), require("tweetnacl"), require("varuint-bitcoin"), require("@azure/core-client"), require("canonicalize"), require("@aeternity/uuid"), require("@aeternity/argon2"), require("tweetnacl-auth"), require("bip32-path"), require("aes-js"), require("@aeternity/aepp-calldata"), require("json-bigint"), require("events"), require("websocket"), require("isomorphic-ws"));
+		exports["Aeternity"] = factory(require("@azure/core-rest-pipeline"), require("rlp"), require("bs58"), require("buffer"), require("bignumber.js"), require("tweetnacl"), require("varuint-bitcoin"), require("@azure/core-client"), require("@aeternity/aepp-calldata"), require("canonicalize"), require("@aeternity/uuid"), require("@aeternity/argon2"), require("tweetnacl-auth"), require("bip32-path"), require("aes-js"), require("json-bigint"), require("events"), require("websocket"), require("isomorphic-ws"));
 	else
-		root["Aeternity"] = factory(root["@azure/core-rest-pipeline"], root["rlp"], root["bs58"], root["buffer"], root["bignumber.js"], root["tweetnacl"], root["varuint-bitcoin"], root["@azure/core-client"], root["canonicalize"], root["@aeternity/uuid"], root["@aeternity/argon2"], root["tweetnacl-auth"], root["bip32-path"], root["aes-js"], root["@aeternity/aepp-calldata"], root["json-bigint"], root["events"], root["websocket"], root["isomorphic-ws"]);
-})(global, (__WEBPACK_EXTERNAL_MODULE__5039__, __WEBPACK_EXTERNAL_MODULE__3485__, __WEBPACK_EXTERNAL_MODULE__3783__, __WEBPACK_EXTERNAL_MODULE__9408__, __WEBPACK_EXTERNAL_MODULE__5192__, __WEBPACK_EXTERNAL_MODULE__79__, __WEBPACK_EXTERNAL_MODULE__7480__, __WEBPACK_EXTERNAL_MODULE__4711__, __WEBPACK_EXTERNAL_MODULE__6667__, __WEBPACK_EXTERNAL_MODULE__3983__, __WEBPACK_EXTERNAL_MODULE__7417__, __WEBPACK_EXTERNAL_MODULE__9882__, __WEBPACK_EXTERNAL_MODULE__1986__, __WEBPACK_EXTERNAL_MODULE__8236__, __WEBPACK_EXTERNAL_MODULE__7946__, __WEBPACK_EXTERNAL_MODULE__2716__, __WEBPACK_EXTERNAL_MODULE__3735__, __WEBPACK_EXTERNAL_MODULE__8079__, __WEBPACK_EXTERNAL_MODULE__3153__) => {
+		root["Aeternity"] = factory(root["@azure/core-rest-pipeline"], root["rlp"], root["bs58"], root["buffer"], root["bignumber.js"], root["tweetnacl"], root["varuint-bitcoin"], root["@azure/core-client"], root["@aeternity/aepp-calldata"], root["canonicalize"], root["@aeternity/uuid"], root["@aeternity/argon2"], root["tweetnacl-auth"], root["bip32-path"], root["aes-js"], root["json-bigint"], root["events"], root["websocket"], root["isomorphic-ws"]);
+})(global, (__WEBPACK_EXTERNAL_MODULE__5039__, __WEBPACK_EXTERNAL_MODULE__3485__, __WEBPACK_EXTERNAL_MODULE__3783__, __WEBPACK_EXTERNAL_MODULE__9408__, __WEBPACK_EXTERNAL_MODULE__5192__, __WEBPACK_EXTERNAL_MODULE__79__, __WEBPACK_EXTERNAL_MODULE__7480__, __WEBPACK_EXTERNAL_MODULE__4711__, __WEBPACK_EXTERNAL_MODULE__7946__, __WEBPACK_EXTERNAL_MODULE__6667__, __WEBPACK_EXTERNAL_MODULE__3983__, __WEBPACK_EXTERNAL_MODULE__7417__, __WEBPACK_EXTERNAL_MODULE__9882__, __WEBPACK_EXTERNAL_MODULE__1986__, __WEBPACK_EXTERNAL_MODULE__8236__, __WEBPACK_EXTERNAL_MODULE__2716__, __WEBPACK_EXTERNAL_MODULE__3735__, __WEBPACK_EXTERNAL_MODULE__8079__, __WEBPACK_EXTERNAL_MODULE__3153__) => {
 return /******/ (() => { // webpackBootstrap
 /******/ 	var __webpack_modules__ = ({
 
-/***/ 6477:
-/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
-
-const TypeResolveError = __webpack_require__(6966)
-const {
-    FateTypeVoid,
-    FateTypeInt,
-    FateTypeBool,
-    FateTypeString,
-    FateTypeBits,
-    FateTypeBytes,
-    FateTypeHash,
-    FateTypeSignature,
-    FateTypeAccountAddress,
-    FateTypeContractAddress,
-    FateTypeOracleAddress,
-    FateTypeOracleQueryAddress,
-    FateTypeList,
-    FateTypeMap,
-    FateTypeTuple,
-    FateTypeRecord,
-    FateTypeSet,
-    FateTypeVariant,
-    FateTypeOption,
-    FateTypeChainTTL,
-    FateTypeChainGAMetaTx,
-    FateTypeChainPayingForTx,
-    FateTypeChainBaseTx,
-    FateTypeAENSPointee,
-    FateTypeAENSName,
-    FateTypeEvent,
-    FateTypeBls12381Fr,
-    FateTypeBls12381Fp
-} = __webpack_require__(4265)
-
-const isObject = (value) => {
-    return value && typeof value === 'object' && value.constructor === Object
-}
-
-const isOption = ({type}) => {
-    let key = type
-    let _
-    if (isObject(key)) {
-        [[key, _]] = Object.entries(key)
-    }
-
-    return key === 'option'
-}
-
-class AciTypeResolver {
-    constructor(aci) {
-        this.aci = aci
-    }
-
-    getCallTypes(contract, funName) {
-        const funcAci = this.getNamespaceAci(contract).functions.find(e => e.name === funName)
-
-        if (funcAci) {
-            const types = funcAci.arguments.map(e => this.resolveType(e.type))
-            const options = funcAci.arguments.filter(isOption)
-            return {
-                types,
-                required: types.length - options.length,
-            }
-        }
-
-        if (funName === 'init') {
-            return {types: [], required: 0}
-        }
-
-        throw new TypeResolveError(`Unknown function ${funName}`)
-    }
-
-    getReturnType(contract, funName) {
-        if (funName === 'init') {
-            return this.resolveType('void')
-        }
-
-        const funcAci = this.getNamespaceAci(contract).functions.find(e => e.name === funName)
-
-        if (!funcAci) {
-            throw new TypeResolveError(`Unknown function ${funName}`)
-        }
-
-        return this.resolveType(funcAci.returns)
-    }
-
-    getEventType(contract, topics) {
-        const aci = this.getNamespaceAci(contract)
-
-        if (!aci.hasOwnProperty('event')) {
-            throw new TypeResolveError('Missing event declaration')
-        }
-
-        return FateTypeEvent(this.resolveType(aci.event), topics)
-    }
-
-    isCustomType(type) {
-        if (typeof type !== 'string') {
-            return false
-        }
-
-        if (this.isStdType(type)) {
-            return false
-        }
-
-        const [namespace, _localType] = type.split('.')
-        const namespaceData = this.getNamespaceAci(namespace)
-
-        return !!namespaceData
-    }
-
-    isStdType(type) {
-        if (type === 'Set.set') {
-            return true
-        }
-
-        return false
-    }
-
-    getNamespaceAci(name) {
-        for (const e of this.aci) {
-            const [[_type, data]] = Object.entries(e)
-            if (data.name === name) {
-                return data
-            }
-        }
-
-        return null
-    }
-
-    resolveType(type, vars = {}) {
-        let key = type
-        let valueTypes = []
-        let resolvedTypes = []
-
-        if (isObject(type)) {
-            [[key, valueTypes]] = Object.entries(type)
-        }
-
-        if (this.isCustomType(key)) {
-            const [typeDef, typeVars] = this.resolveTypeDef(key, valueTypes)
-
-            return this.resolveType(typeDef, typeVars)
-        }
-
-        if (Array.isArray(valueTypes)) {
-            if (key !== 'variant') {
-                resolvedTypes = valueTypes.map(v => {
-                    const tpl = v.hasOwnProperty('type') ? v.type : v
-                    const t = vars.hasOwnProperty(tpl) ? vars[tpl] : tpl
-
-                    return this.resolveType(t, vars)
-                })
-            }
-        }
-
-        if (key === 'void') {
-            return FateTypeVoid()
-        }
-
-        if (key === 'unit') {
-            return FateTypeTuple([])
-        }
-
-        if (key === 'int') {
-            return FateTypeInt()
-        }
-
-        if (key === 'bool') {
-            return FateTypeBool()
-        }
-
-        if (key === 'string') {
-            return FateTypeString()
-        }
-
-        if (key === 'bits') {
-            return FateTypeBits()
-        }
-
-        if (key === 'hash') {
-            return FateTypeHash()
-        }
-
-        if (key === 'signature') {
-            return FateTypeSignature()
-        }
-
-        if (key === 'address') {
-            return FateTypeAccountAddress()
-        }
-
-        if (key === 'contract_pubkey') {
-            return FateTypeContractAddress()
-        }
-
-        if (key === 'Chain.ttl') {
-            return FateTypeChainTTL()
-        }
-
-        if (key === 'Chain.ga_meta_tx') {
-            return FateTypeChainGAMetaTx()
-        }
-
-        if (key === 'Chain.paying_for_tx') {
-            return FateTypeChainPayingForTx()
-        }
-
-        if (key === 'Chain.base_tx') {
-            return FateTypeChainBaseTx()
-        }
-
-        if (key === 'AENS.pointee') {
-            return FateTypeAENSPointee()
-        }
-
-        if (key === 'AENS.name') {
-            return FateTypeAENSName()
-        }
-
-        if (key === 'Set.set') {
-            return FateTypeSet(...resolvedTypes)
-        }
-
-        if (key === 'MCL_BLS12_381.fr') {
-            return FateTypeBls12381Fr()
-        }
-
-        if (key === 'MCL_BLS12_381.fp') {
-            return FateTypeBls12381Fp()
-        }
-
-        if (key === 'bytes') {
-            return FateTypeBytes(valueTypes)
-        }
-
-        if (key === 'list') {
-            return FateTypeList(...resolvedTypes)
-        }
-
-        if (key === 'map') {
-            return FateTypeMap(...resolvedTypes)
-        }
-
-        // Unbox singleton tuples and records
-        // https://github.com/aeternity/aesophia/pull/205
-        // https://github.com/aeternity/aesophia/commit/a403a9d227ac56266cf5bb8fbc916f17e6141d15
-        if ((key === 'tuple' || key === 'record') && resolvedTypes.length === 1) {
-            return resolvedTypes[0]
-        }
-
-        if (key === 'tuple') {
-            return FateTypeTuple(resolvedTypes)
-        }
-
-        if (key === 'record') {
-            const keys = valueTypes.map(e => e.name)
-
-            return FateTypeRecord(keys, resolvedTypes)
-        }
-
-        if (key === 'variant') {
-            return this.resolveVariant(valueTypes, vars)
-        }
-
-        if (key === 'option') {
-            return FateTypeOption(resolvedTypes)
-        }
-
-        if (key === 'oracle') {
-            return FateTypeOracleAddress(...resolvedTypes)
-        }
-
-        if (key === 'oracle_query') {
-            return FateTypeOracleQueryAddress(...resolvedTypes)
-        }
-
-        throw new TypeResolveError('Cannot resolve type: ' + JSON.stringify(type))
-    }
-
-    resolveVariant(valueTypes, vars) {
-        const variants = valueTypes.map(e => {
-            const [[variant, args]] = Object.entries(e)
-            const resolvedArgs = args.map(v => {
-                const t = vars.hasOwnProperty(v) ? vars[v] : v
-                return this.resolveType(t, vars)
-            })
-
-            return {[variant]: resolvedArgs}
-        })
-
-        return FateTypeVariant(variants)
-    }
-
-    resolveTypeDef(type, params = []) {
-        const [namespace, localType] = type.split('.')
-        const namespaceData = this.getNamespaceAci(namespace)
-
-        // not a custom type
-        if (!namespaceData) {
-            throw new TypeResolveError('Unknown namespace for ' + JSON.stringify(type))
-        }
-
-        if (namespaceData.name === type) {
-            return ['contract_pubkey', []]
-        }
-
-        const def = [
-            /**
-             * @deprecated use ACIs generated by aesophia@^7.1.0
-             * TODO remove `type_defs` in next major release
-             */
-            ...namespaceData.typedefs || namespaceData.type_defs,
-            ...namespaceData.state ? [{
-                name: 'state',
-                typedef: namespaceData.state,
-                vars: []
-            }] : []
-        ].find(e => e.name === localType)
-
-        if (!def) {
-            throw new TypeResolveError('Unknown type definition: ' + JSON.stringify(type))
-        }
-
-        const vars = {}
-        def.vars.forEach((e, i) => {
-            const [[_, k]] = Object.entries(e)
-            vars[k] = params[i]
-        })
-
-        const typeDef = vars.hasOwnProperty(def.typedef) ? vars[def.typedef] : def.typedef
-
-        return [typeDef, vars]
-    }
-}
-
-module.exports = AciTypeResolver
-
-
-/***/ }),
-
-/***/ 7200:
-/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
-
-const base64check = __webpack_require__(8638)
-const base58check = __webpack_require__(2727)
-const FormatError = __webpack_require__(722)
-const FateTypeError = __webpack_require__(5110)
-
-const TYPES = {
-    key_block_hash: {tag: 'kh', size: 32, encoder: base58check},
-    contract_bytearray: {tag: 'cb', size: 0, encoder: base64check},
-    contract_pubkey: {tag: 'ct', size: 32, encoder: base58check},
-    account_pubkey: {tag: 'ak', size: 32, encoder: base58check},
-    channel: {tag: 'ch', size: 32, encoder: base58check},
-    oracle_pubkey: {tag: 'ok', size: 32, encoder: base58check},
-    oracle_query_id: {tag: 'oq', size: 32, encoder: base58check},
-    peer_pubkey: {tag: 'pp', size: 32, encoder: base58check},
-}
-
-const TAG2TYPE = {
-    kh: 'key_block_hash',
-    cb: 'contract_bytearray',
-    ct: 'contract_pubkey',
-    ak: 'account_pubkey',
-    ch: 'channel',
-    ok: 'oracle_pubkey',
-    oq: 'oracle_query_id',
-    pp: 'peer_pubkey',
-}
-
-class ApiEncoder {
-    encode(typeName, payload) {
-        if (!TYPES.hasOwnProperty(typeName)) {
-            throw new FateTypeError(typeName, `Unsupported API type ${typeName}`)
-        }
-
-        const type = TYPES[typeName]
-
-        if (type.size > 0 && payload.length !== type.size) {
-            throw new FateTypeError(
-                typeName,
-                `Invalid payload. Expected size ${type.size}, but got ${payload.length}`
-            )
-        }
-
-        const encoded = type.encoder.encode(payload)
-
-        return `${type.tag}_${encoded}`
-    }
-
-    decode(data) {
-        const tag = data.substring(0, 2)
-
-        if (!TAG2TYPE.hasOwnProperty(tag)) {
-            throw new FormatError(`Invalid API data format. Unsupported tag: ${tag}`)
-        }
-
-        if (data[2] !== '_') {
-            throw new FormatError(`Invalid API data format. Expected _ separator on position 2, got ${data[2]}`)
-        }
-
-        const type = TYPES[TAG2TYPE[tag]]
-        const payload = data.substring(3)
-        const decoded = type.encoder.decode(payload)
-
-        if (type.size > 0 && decoded.length !== type.size) {
-            throw new FormatError(`Invalid API data format. Expected size ${type.size}, but got ${decoded.length}`)
-        }
-
-        return decoded
-    }
-
-    decodeWithType(data, expectedType) {
-        const tag = data.substring(0, 2)
-
-        if (!TYPES.hasOwnProperty(expectedType)) {
-            throw new FateTypeError(expectedType, 'Unsupported API type')
-        }
-
-        const expectedTag = TYPES[expectedType].tag
-
-        if (tag !== expectedTag) {
-            const capitalized = this.capitalizeType(expectedType)
-
-            throw new FateTypeError(
-                expectedType,
-                `${capitalized} should start with ${expectedTag}_, got ${data} instead`
-            )
-        }
-
-        return this.decode(data)
-    }
-
-    capitalizeType(type) {
-        const s = type.replace('_', ' ')
-
-        return s.charAt(0).toUpperCase() + s.slice(1)
-    }
-}
-
-module.exports = ApiEncoder
-
-
-/***/ }),
-
-/***/ 8323:
-/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
-
-const Serializer = __webpack_require__(7829)
-const ApiEncoder = __webpack_require__(7200)
-const CanonicalMapper = __webpack_require__(880)
-const ExternalDataFactory = __webpack_require__(3451)
-
-class ContractByteArrayEncoder {
-    constructor() {
-        /** @type {Serializer} */
-        this._serializer = new Serializer()
-
-        /** @type {ApiEncoder} */
-        this._apiEncoder = new ApiEncoder()
-
-        /** @type {ExternalDataFactory} */
-        this._externalDataFactory = new ExternalDataFactory()
-
-        /** @type {CanonicalMapper} */
-        this._canonicalMapper = new CanonicalMapper()
-    }
-
-    /**
-     * Encode FATE data to contract bytearray.
-     *
-     * @example
-     * const encoded = encoder.encode("whoolymoly")
-     * console.log(`Encoded data: ${encoded}`)
-     * // Outputs:
-     * // Encoded data: cb_KXdob29seW1vbHlGazSE
-     *
-     * @param {Array} data - Data as Javascript data structures. See README.md
-     * @returns {string} Encoded contract byte array
-    */
-    encode(type, value) {
-        const data = this._externalDataFactory.create(type, value)
-        const serialized = this._serializer.serialize(data)
-        const binData = new Uint8Array(serialized.flat(Infinity))
-
-        return this._apiEncoder.encode('contract_bytearray', binData)
-    }
-
-    /**
-     * Decodes arbitrary contract bytearray data.
-     *
-     * Note that:
-     * - Variants are not annotated with constructor names
-     * - Record keys are lost
-     * - Any custom type information is lost
-     * - STL type information is lost: i.e. Chain, AENS, Set, BLS12_381
-     *
-     * @example
-     * const decoded = encoder.decode('cb_KXdob29seW1vbHlGazSE')
-     * console.log(`Decoded data: ${decoded}`)
-     * // Outputs:
-     * // Decoded data: whoolymoly
-     *
-     * @param {string} data - Contract bytearray data in a canonical format.
-     * @returns {boolean|string|BigInt|Array|Map|Object}
-     *  Decoded value as Javascript data structures. See README.md
-    */
-    decode(data) {
-        const binData = this._apiEncoder.decodeWithType(data, 'contract_bytearray')
-        const deserialized = this._serializer.deserialize(binData)
-
-        return this._canonicalMapper.toCanonical(deserialized)
-    }
-
-    /**
-     * Decodes arbitrary contract bytearray data with type information.
-     *
-     * @example
-     * const decoded = encoder.decode('cb_KXdob29seW1vbHlGazSE')
-     * console.log(`Decoded data: ${decoded}`)
-     * // Outputs:
-     * // Decoded data: whoolymoly
-     *
-     * @param {string} data - Contract bytearray data in a canonical format.
-     * @returns {boolean|string|BigInt|Array|Map|Object}
-     *  Decoded value as Javascript data structures. See README.md
-    */
-    decodeWithType(data, type) {
-        const binData = this._apiEncoder.decodeWithType(data, 'contract_bytearray')
-        const deserialized = this._serializer.deserializeWithType(binData, type)
-
-        return this._canonicalMapper.toCanonical(deserialized)
-    }
-}
-
-module.exports = ContractByteArrayEncoder
-
-
-/***/ }),
-
-/***/ 6040:
-/***/ ((module) => {
-
-class BaseDataFactory {
-    constructor(valueFactory) {
-        this._valueFactory = valueFactory
-    }
-
-    get valueFactory() {
-        return this._valueFactory
-    }
-
-    supports({_name, _valueTypes}) {
-        return false
-    }
-
-    create(_type, _value) {
-        throw new Error('Not implemented.')
-    }
-}
-
-module.exports = BaseDataFactory
-
-
-/***/ }),
-
-/***/ 6097:
-/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
-
-const FateBls12381Fr = __webpack_require__(1565)
-const FateBls12381Fp = __webpack_require__(4077)
-const BaseDataFactory = __webpack_require__(6040)
-
-const TYPES = [
-    'bls12_381.fr',
-    'bls12_381.fp',
-]
-
-class Bls12381DataFactory extends BaseDataFactory {
-    supports({ name, _valueTypes }) {
-        return TYPES.includes(name)
-    }
-
-    create(type, value) {
-        switch (type.name) {
-        case 'bls12_381.fr':
-            return new FateBls12381Fr(value)
-        case 'bls12_381.fp':
-            return new FateBls12381Fp(value)
-        default:
-            throw new Error(`Unsupported type "${type.name}"`)
-        }
-    }
-}
-
-module.exports = Bls12381DataFactory
-
-
-/***/ }),
-
-/***/ 7961:
-/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
-
-const {symbolIdentifier} = __webpack_require__(2665)
-const FateTypeError = __webpack_require__(5110)
-const FateCalldata = __webpack_require__(7255)
-const BaseDataFactory = __webpack_require__(6040)
-
-class CallDataFactory extends BaseDataFactory {
-    supports({ name, _valueTypes }) {
-        return 'calldata' === name
-    }
-
-    create(type, value) {
-        if (!Array.isArray(value)) {
-            throw new FateTypeError(
-                type.name,
-                `Fate calldata arguments must be an Array, got ${value} instead`
-            )
-        }
-
-        const argsData = this.valueFactory.createMultiple(type.argumentTypes, value)
-        const functionId = symbolIdentifier(type.functionName)
-
-        return new FateCalldata(functionId, type.argumentTypes, argsData)
-    }
-}
-
-module.exports = CallDataFactory
-
-
-/***/ }),
-
-/***/ 2320:
-/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
-
-const assert = __webpack_require__(4664)
-const zip = __webpack_require__(5675)
-const PrimitiveDataFactory = __webpack_require__(1168)
-const ListDataFactory = __webpack_require__(9205)
-const SetDataFactory = __webpack_require__(4960)
-const MapDataFactory = __webpack_require__(3353)
-const TupleDataFactory = __webpack_require__(786)
-const RecordDataFactory = __webpack_require__(7211)
-const VariantDataFactory = __webpack_require__(4093)
-const EventDataFactory = __webpack_require__(2954)
-const Bls12381DataFactory = __webpack_require__(6097)
-const CallDataFactory = __webpack_require__(7961)
-
-class CompositeDataFactory {
-    constructor() {
-        this._factories = [
-            new PrimitiveDataFactory(this),
-            new ListDataFactory(this),
-            new SetDataFactory(this),
-            new MapDataFactory(this),
-            new TupleDataFactory(this),
-            new RecordDataFactory(this),
-            new EventDataFactory(this),
-            new VariantDataFactory(this),
-            new Bls12381DataFactory(this),
-            new CallDataFactory(this),
-        ]
-    }
-
-    createMultiple(types, values) {
-        assert(
-            values.length === types.length,
-            `Number of types (${types.length}) and values (${values.length}) should match`
-        )
-
-        return zip(types, values).map(el => this.create(...el))
-    }
-
-    create(type, value) {
-        const factory = this._factories.find(f => f.supports(type))
-        assert(factory, `Unsupported type "${type.name}"`)
-
-        return factory.create(type, value)
-    }
-}
-
-module.exports = CompositeDataFactory
-
-
-/***/ }),
-
-/***/ 2954:
-/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
-
-const {hash} = __webpack_require__(2665)
-const {ByteArray2Int} = __webpack_require__(240)
-const TypeResolveError = __webpack_require__(6966)
-const BaseDataFactory = __webpack_require__(6040)
-
-const DATA_TYPES = [
-    'string',
-    'signature',
-    'bytes',
-]
-
-class EventDataFactory extends BaseDataFactory {
-    supports({ name, _valueTypes }) {
-        return 'event' === name
-    }
-
-    create({variantType, topics}, data) {
-        const [nameHash, ...args] = topics
-
-        if (typeof nameHash !== 'bigint') {
-            throw new TypeResolveError(`Event name hash (first topic) should be of type "BigInt", got "${typeof nameHash}" instead.`)
-        }
-
-        const idx = variantType.variants
-            .map(v => ByteArray2Int(hash(Object.keys(v)[0])))
-            .findIndex(v => v === nameHash)
-
-        if (idx === -1) {
-            throw new TypeResolveError('Event name hash does not match any event variant constructor')
-        }
-
-        const variant = variantType.variants[idx]
-        const variantName = Object.keys(variant)[0]
-        const [argTypes] = Object.values(variant)
-        const resolvedArgs = argTypes.map(t => {
-            if (this._isData(t)) {
-                return data
-            }
-
-            return args.shift()
-        })
-
-        return this.valueFactory.create(variantType, {[variantName]: resolvedArgs})
-    }
-
-    _isData(type) {
-        if (!DATA_TYPES.includes(type.name)) {
-            return false
-        }
-
-        if (type.name === 'bytes' && type.size <= 32) {
-            return false
-        }
-
-        return true
-    }
-}
-
-module.exports = EventDataFactory
-
-
-/***/ }),
-
-/***/ 9205:
-/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
-
-const FateList = __webpack_require__(1041)
-const FateTypeError = __webpack_require__(5110)
-const BaseDataFactory = __webpack_require__(6040)
-
-class ListDataFactory extends BaseDataFactory {
-    supports({name, _valueTypes}) {
-        return 'list' === name
-    }
-
-    create(type, value) {
-        if (!Array.isArray(value)) {
-            throw new FateTypeError(
-                type.name,
-                `Fate list must be an Array, got ${value} instead`
-            )
-        }
-
-        const resolvedValues = value.map(v => this.valueFactory.create(type.valuesType, v))
-
-        return new FateList(type.valuesType, resolvedValues)
-    }
-}
-
-module.exports = ListDataFactory
-
-
-/***/ }),
-
-/***/ 3353:
-/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
-
-const FateMap = __webpack_require__(8804)
-const BaseDataFactory = __webpack_require__(6040)
-
-class MapDataFactory extends BaseDataFactory {
-    supports({ name, _valueTypes }) {
-        return 'map' === name
-    }
-
-    create(type, value) {
-        const resolvedValues = []
-        for (const item of value) {
-            resolvedValues.push([
-                this.valueFactory.create(type.keyType, item[0]),
-                this.valueFactory.create(type.valueType, item[1]),
-            ])
-        }
-
-        return new FateMap(type.keyType, type.valueType, resolvedValues)
-    }
-}
-
-module.exports = MapDataFactory
-
-
-/***/ }),
-
-/***/ 1168:
-/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
-
-const FateInt = __webpack_require__(3509)
-const FateBool = __webpack_require__(4476)
-const FateString = __webpack_require__(6313)
-const FateHash = __webpack_require__(7772)
-const FateSignature = __webpack_require__(3607)
-const FateBytes = __webpack_require__(5779)
-const FateBits = __webpack_require__(3422)
-const FateAccountAddress = __webpack_require__(539)
-const FateContractAddress = __webpack_require__(8623)
-const FateChannelAddress = __webpack_require__(6445)
-const FateOracleAddress = __webpack_require__(687)
-const FateOracleQueryAddress = __webpack_require__(5070)
-const BaseDataFactory = __webpack_require__(6040)
-
-const TYPES = [
-    'int',
-    'bool',
-    'string',
-    'bits',
-    'hash',
-    'bytes',
-    'signature',
-    'account_pubkey',
-    'contract_pubkey',
-    'channel',
-    'oracle_pubkey',
-    'oracle_query_id'
-]
-
-class PrimitiveDataFactory extends BaseDataFactory {
-    supports({ name, _valueTypes }) {
-        return TYPES.includes(name)
-    }
-
-    create(type, value) {
-        switch (type.name) {
-        case 'int':
-            return new FateInt(value)
-        case 'bool':
-            return new FateBool(value)
-        case 'string':
-            return new FateString(value)
-        case 'bits':
-            return new FateBits(value)
-        case 'hash':
-            return new FateHash(value)
-        case 'bytes':
-            return new FateBytes(value, type.valueTypes)
-        case 'signature':
-            return new FateSignature(value)
-        case 'account_pubkey':
-            return new FateAccountAddress(value)
-        case 'contract_pubkey':
-            return new FateContractAddress(value)
-        case 'channel':
-            return new FateChannelAddress(value)
-        case 'oracle_pubkey':
-            return new FateOracleAddress(value)
-        case 'oracle_query_id':
-            return new FateOracleQueryAddress(value)
-        default:
-            throw new Error(`Unsupported type "${type.name}"`)
-        }
-    }
-}
-
-module.exports = PrimitiveDataFactory
-
-
-/***/ }),
-
-/***/ 7211:
-/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
-
-const BaseDataFactory = __webpack_require__(6040)
-const FateTuple = __webpack_require__(6878)
-const {FateTypeRecord} = __webpack_require__(4265)
-const FateTypeError = __webpack_require__(5110)
-
-class RecordDataFactory extends BaseDataFactory {
-    supports({ name, _valueTypes }) {
-        return 'record' === name
-    }
-
-    create(type, value) {
-        if (typeof value !== 'object') {
-            throw new FateTypeError(
-                type.name,
-                `Fate record must be an Object, got ${value} instead`
-            )
-        }
-
-        const keyLen = Object.keys(value).length
-        if (keyLen !== type.keys.length) {
-            throw new FateTypeError(
-                type.name,
-                `Number of expected keys (${type.keys.length}) and actual keys (${keyLen}) should match`
-            )
-        }
-
-        const resolvedValue = type.valueTypes.map((t, i) => {
-            const key = type.keys[i]
-            return this.valueFactory.create(t, value[key])
-        })
-
-        // Unbox singleton tuples and records
-        // https://github.com/aeternity/aesophia/pull/205
-        // https://github.com/aeternity/aesophia/commit/a403a9d227ac56266cf5bb8fbc916f17e6141d15
-        if (resolvedValue.length === 1) {
-            return resolvedValue[0]
-        }
-
-        return new FateTuple(
-            FateTypeRecord(type.keys, type.valueTypes),
-            resolvedValue
-        )
-    }
-}
-
-module.exports = RecordDataFactory
-
-
-/***/ }),
-
-/***/ 4960:
-/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
-
-const FateSet = __webpack_require__(2548)
-const BaseDataFactory = __webpack_require__(6040)
-
-class SetDataFactory extends BaseDataFactory {
-    supports({name, _valueTypes}) {
-        return 'set' === name
-    }
-
-    create(type, value) {
-        const resolvedValues = []
-        for (const item of value) {
-            resolvedValues.push(this.valueFactory.create(type.valuesType, item))
-        }
-
-        return new FateSet(type.valuesType, resolvedValues)
-    }
-}
-
-module.exports = SetDataFactory
-
-
-/***/ }),
-
-/***/ 786:
-/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
-
-const FateTuple = __webpack_require__(6878)
-const FateTypeError = __webpack_require__(5110)
-const BaseDataFactory = __webpack_require__(6040)
-
-class TupleDataFactory extends BaseDataFactory {
-    supports({ name, _valueTypes }) {
-        return 'tuple' === name
-    }
-
-    create(type, value) {
-        if (!Array.isArray(value)) {
-            throw new FateTypeError(
-                type.name,
-                `Fate tuple must be an Array, got ${value} instead`
-            )
-        }
-
-        const resolvedValue = type.valueTypes.map((t, i) => {
-            return this.valueFactory.create(t, value[i])
-        })
-
-        // Unbox singleton tuples and records
-        // https://github.com/aeternity/aesophia/pull/205
-        // https://github.com/aeternity/aesophia/commit/a403a9d227ac56266cf5bb8fbc916f17e6141d15
-        if (resolvedValue.length === 1) {
-            return resolvedValue[0]
-        }
-
-        return new FateTuple(type.valueTypes, resolvedValue)
-    }
-}
-
-module.exports = TupleDataFactory
-
-
-/***/ }),
-
-/***/ 4093:
-/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
-
-const FateVariant = __webpack_require__(2457)
-const FateTypeError = __webpack_require__(5110)
-const BaseDataFactory = __webpack_require__(6040)
-
-const TYPES = [
-    'variant',
-    'Chain.ttl',
-    'AENS.pointee',
-    'AENS.name'
-]
-
-class VariantDataFactory extends BaseDataFactory {
-    supports({ name, _valueTypes }) {
-        return TYPES.includes(name)
-    }
-
-    create(type, value) {
-        if (!this.isValid(value)) {
-            throw new FateTypeError(
-                type.name,
-                `Variant should be an object mapping constructor to array of values, got "${value}" instead`
-            )
-        }
-
-        const [variantCtor, variantArgs] = Object.entries(value)[0]
-
-        const arities = type.variants.map(e => {
-            const [[, args]] = Object.entries(e)
-            return args.length
-        })
-
-        const tag = type.variants.findIndex(e => {
-            const [[key, _]] = Object.entries(e)
-            return key === variantCtor
-        })
-
-        if (tag === -1) {
-            throw new FateTypeError(
-                type.name,
-                `Unknown variant constructor: ${variantCtor}`
-            )
-        }
-
-        const [[, variantTypes]] = Object.entries(type.variants[tag])
-
-        if (variantArgs.length !== variantTypes.length) {
-            throw new FateTypeError(
-                type.name,
-                `"${variantCtor}" variant constructor expects ${variantTypes.length} argument(s) but got ${variantArgs.length} instead`
-            )
-        }
-
-        const variantValue = this.valueFactory.createMultiple(variantTypes, variantArgs)
-
-        return new FateVariant(arities, tag, variantValue, variantTypes, type.variants)
-    }
-
-    isValid(value) {
-        return typeof value === 'object'
-            && value !== null
-            && Object.entries(value).length === 1
-            && Array.isArray(Object.values(value)[0])
-    }
-}
-
-module.exports = VariantDataFactory
-
-
-/***/ }),
-
-/***/ 5462:
-/***/ ((module) => {
-
-class FatePrefixError extends Error {
-    constructor(prefix) {
-        super('Invalid FATE prefix: 0b' + prefix.toString(2).padStart(8, '0'))
-
-        this.name = 'FatePrefixError'
-        this.prefix = prefix
-    }
-}
-
-module.exports = FatePrefixError
-
-
-/***/ }),
-
-/***/ 5110:
-/***/ ((module) => {
-
-class FateTypeError extends Error {
-    constructor(type, message) {
-        super(message)
-        this.name = 'FateTypeError'
-        this.type = type
-    }
-}
-
-module.exports = FateTypeError
-
-
-/***/ }),
-
-/***/ 722:
-/***/ ((module) => {
-
-class FormatError extends Error {
-    constructor(message) {
-        super(message)
-        this.name = 'FormatError'
-    }
-}
-
-module.exports = FormatError
-
-
-/***/ }),
-
-/***/ 2966:
-/***/ ((module) => {
-
-class InternalError extends Error {
-    constructor(message) {
-        super(message)
-        this.name = 'InternalError'
-    }
-}
-
-module.exports = InternalError
-
-
-/***/ }),
-
-/***/ 9098:
-/***/ ((module) => {
-
-class SerializerError extends Error {
-    constructor(message) {
-        super(message)
-        this.name = 'SerializerError'
-    }
-}
-
-module.exports = SerializerError
-
-
-/***/ }),
-
-/***/ 6966:
-/***/ ((module) => {
-
-class TypeResolveError extends Error {
-    constructor(message) {
-        super(message)
-        this.name = 'TypeResolveError'
-    }
-}
-
-module.exports = TypeResolveError
-
-
-/***/ }),
-
-/***/ 3451:
-/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
-
-const CompositeDataFactory = __webpack_require__(2320)
-const InternalMapper = __webpack_require__(1338)
-
-class ExternalDataFactory extends CompositeDataFactory {
-    constructor() {
-        super()
-
-        this._mapper = new InternalMapper()
-    }
-
-    create(type, value) {
-        const internalValue = this._mapper.toInternal(type, value)
-
-        return super.create(type, internalValue)
-    }
-}
-
-module.exports = ExternalDataFactory
-
-
-/***/ }),
-
-/***/ 2689:
-/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
-
-const assert = __webpack_require__(4664)
-const FateList = __webpack_require__(1041)
-const FateTuple = __webpack_require__(6878)
-const {FateTypeTuple, FateTypeInt} = __webpack_require__(4265)
-
-/* eslint-disable no-use-before-define */
-
-// TODO types comparator
-const listComparator = (a, b) => {
-    if (a.length === 0) {
-        return -1
-    }
-
-    if (b.length === 0) {
-        return 1
-    }
-
-    const cmp = FateComparator(a.itemsType)
-    for (let i = 0; i < a.length; i++) {
-        // second list is shorter but matches as prefix of the first one
-        if (typeof b.items[i] === 'undefined') {
-            return 1
-        }
-
-        // element difference
-        const diff = cmp(a.items[i], b.items[i])
-        if (diff !== 0) {
-            return diff
-        }
-    }
-
-    // if there is no early return from the loop above
-    // then the first list match a prefix of the second
-
-    // equal lists
-    if (a.length === b.length) {
-        return 0
-    }
-
-    // first list is shorter, thus smaller
-    return -1
-}
-
-const tupleComparator = (a, b) => {
-    if (a.size === 0) {
-        return -1
-    }
-
-    const sizeDiff = a.size - b.size
-    if (sizeDiff !== 0) {
-        return sizeDiff
-    }
-
-    // equal size - compare elements
-    for (let i = 0; i < a.size; i++) {
-        const valTypeA = a.valueTypes[i]
-
-        // TODO support different types ?
-
-        const diff = FateComparator(valTypeA)(a.items[i], b.items[i])
-        if (diff !== 0) {
-            return diff
-        }
-    }
-
-    // equal tuples
-    return 0
-}
-
-const variantComparator = (a, b) => {
-    const aDiff = a.arities.length - b.arities.length
-    if (aDiff !== 0) {
-        return aDiff
-    }
-
-    const aList = new FateList(a.aritiesType, a.arities)
-    const bList = new FateList(b.aritiesType, b.arities)
-    const aComparator = FateComparator(aList)
-
-    const lDiff = aComparator(aList, bList)
-    if (lDiff !== 0) {
-        return lDiff
-    }
-
-    const tDiff = a.tag - b.tag
-    if (tDiff !== 0) {
-        return tDiff
-    }
-
-    // equal arities and tags - compare elements
-    const elementsComparator = FateComparator(FateTypeTuple())
-
-    return elementsComparator(
-        new FateTuple(a.valueTypes, a.value),
-        new FateTuple(b.valueTypes, b.value)
-    )
-}
-
-const mapItemComparator = (type) => {
-    const keyComparator = FateComparator(type)
-    return (a, b) => keyComparator(a.key, b.key)
-}
-
-const mapComparator = (a, b) => {
-    const aItems = [...a.items]
-    const bItems = [...b.items]
-
-    aItems.sort(mapItemComparator(a.keyType))
-    bItems.sort(mapItemComparator(b.keyType))
-
-    const keyComparator = FateComparator(a.keyType)
-    const valueComparator = FateComparator(a.valueType)
-
-    for (let i = 0; i < aItems.length; i++) {
-        // second map is smaller (less items)
-        if (typeof bItems[i] === 'undefined') {
-            return 1
-        }
-
-        const aItem = aItems[i]
-        const bItem = bItems[i]
-
-        const kDiff = keyComparator(aItem.key, bItem.key)
-        if (kDiff !== 0) {
-            return kDiff
-        }
-
-        const vDiff = valueComparator(aItem.value, bItem.value)
-        if (vDiff !== 0) {
-            return vDiff
-        }
-    }
-
-    // equal number of items
-    if (aItems.length === bItems.length) {
-        return 0
-    }
-
-    // first map item list is shorter, thus smaller
-    return -1
-}
-
-const bytesComparator = (a, b) => {
-    const aList = new FateList(FateTypeInt(), a.valueOf())
-    const bList = new FateList(FateTypeInt(), b.valueOf())
-
-    return listComparator(aList, bList)
-}
-
-const stringComparator = (a, b) => {
-    const as = a.toString()
-    const bs = b.toString()
-
-    if (as.length === bs.length) {
-        return as.localeCompare(bs)
-    }
-
-    return as.length - bs.length
-}
-
-const intComparator = (a, b) => Number(BigInt(a) - BigInt(b))
-const boolComparator = (a, b) => a - b
-const bitsComparator = (a, b) => {
-    return (a < 0 || b < 0) ? -intComparator(a, b) : intComparator(a, b)
-}
-
-const comparators = {
-    'int': intComparator,
-    'bool': boolComparator,
-    'string': stringComparator,
-    'bits': bitsComparator,
-    // composite types
-    'list': listComparator,
-    'tuple': tupleComparator,
-    'variant': variantComparator,
-    'map': mapComparator,
-    // objects (bytes)
-    'bytes': bytesComparator,
-    'account_pubkey': bytesComparator,
-    'channel': bytesComparator,
-    'contract_pubkey': bytesComparator,
-    'oracle_query_id': bytesComparator,
-    'oracle_pubkey': bytesComparator,
-}
-
-const FateComparator = (type) => {
-    assert(type.hasOwnProperty('name'), `Cannot determine type name of ${JSON.stringify(type)}`)
-    assert(comparators.hasOwnProperty(type.name), `Unsupported comparator for ${type.name}`)
-
-    return comparators[type.name]
-}
-
-module.exports = FateComparator
-
-
-/***/ }),
-
-/***/ 105:
-/***/ ((module) => {
-
-/* eslint-disable key-spacing, indent */
-
-// Definition of tag scheme.
-// This has to follow the protocol specification.
-module.exports = Object.freeze({
-    SMALL_INT    :        0b0, // sxxxxxx 0 - 6 bit integer with sign bit
-                                       // 1 Set below
-    LONG_STRING  : 0b00000001, // 000000 01 | RLP encoded array - when size >= 64
-    SHORT_STRING :       0b01, // xxxxxx 01 | [bytes] - when 0 < xxxxxx:size < 64
-                                      // 11  Set below
-    SHORT_LIST   :     0b0011, // xxxx 0011 | [encoded elements] when  0 < length < 16
-                               // xxxx 0111
-                               // 1010 0111
-                               // 1011 0111
-                               // 1100 0111
-                               // 1101 0111
-                               //      0111 Set below
-    TYPE_INTEGER : 0b00000111, // 0000 0111 - Integer typedef
-    TYPE_BOOLEAN : 0b00010111, // 0001 0111 - Boolean typedef
-    TYPE_LIST    : 0b00100111, // 0010 0111 | Type
-    TYPE_TUPLE   : 0b00110111, // 0011 0111 | Size | [Element Types]
-    TYPE_OBJECT  : 0b01000111, // 0100 0111 | ObjectType
-    TYPE_BITS    : 0b01010111, // 0101 0111 - Bits typedef
-    TYPE_MAP     : 0b01100111, // 0110 0111 | Type | Type
-    TYPE_STRING  : 0b01110111, // 0111 0111 - string typedef
-    TYPE_VARIANT : 0b10000111, // 1000 0111 | [Arities] | [Type]
-    TYPE_BYTES   : 0b10010111, // 1001 0111 - Bytes typedef
-    TYPE_CONTRACT_BYTEARRAY: 0b10100111, // 1010 0111 - Fate code typedef
-                               // 1011 0111
-                               // 1100 0111
-                               // 1101 0111
-    TYPE_VAR     : 0b11100111, // 1110 0111 | Id when 0 =< Id < 256 (type variable)
-    TYPE_ANY     : 0b11110111, // 1111 0111 - Any typedef
-
-    LONG_TUPLE   : 0b00001011, // 0000 1011 | RLP encoded (size - 16) | [encoded elements],
-    SHORT_TUPLE  :     0b1011, // xxxx 1011 | [encoded elements] when 0  <  size < 16
-                                    // 1111 Set below
-    LONG_LIST    : 0b00011111, // 0001 1111 | RLP encoded (length - 16) | [encoded elements]
-    MAP          : 0b00101111, // 0010 1111 | RLP encoded size | [encoded key, encoded value]
-    EMPTY_TUPLE  : 0b00111111, // 0011 1111
-    POS_BITS     : 0b01001111, // 0100 1111 | RLP encoded integer (to be interpreted as bitfield)
-    EMPTY_STRING : 0b01011111, // 0101 1111
-    POS_BIG_INT  : 0b01101111, // 0110 1111 | RLP encoded (integer - 64)
-    FALSE        : 0b01111111, // 0111 1111
-                               // 1000 1111 - FREE (Possibly for bytecode in the future.)
-    OBJECT       : 0b10011111, // 1001 1111 | ObjectType | RLP encoded Array
-    VARIANT      : 0b10101111, // 1010 1111 | [encoded arities] | encoded tag | [encoded values]
-    MAP_ID       : 0b10111111, // 1011 1111 | RLP encoded integer (store map id)
-    NEG_BITS     : 0b11001111, // 1100 1111 | RLP encoded integer (infinite 1:s bitfield)
-    EMPTY_MAP    : 0b11011111, // 1101 1111
-    NEG_BIG_INT  : 0b11101111, // 1110 1111 | RLP encoded (integer - 64)
-    TRUE         : 0b11111111, // 1111 1111
-
-    // Object types
-    OTYPE_ADDRESS       : 0,
-    OTYPE_BYTES         : 1,
-    OTYPE_CONTRACT      : 2,
-    OTYPE_ORACLE        : 3,
-    OTYPE_ORACLE_QUERY  : 4,
-    OTYPE_CHANNEL       : 5,
-})
-
-
-/***/ }),
-
-/***/ 4265:
-/***/ ((module) => {
-
-const FateTypeVoid = () => {
-    return {name: 'void'}
-}
-
-const FateTypeInt = () => {
-    return {name: 'int'}
-}
-
-const FateTypeBool = () => {
-    return {name: 'bool'}
-}
-
-const FateTypeString = () => {
-    return {name: 'string'}
-}
-
-const FateTypeBits = () => {
-    return {name: 'bits'}
-}
-
-const FateTypeBytes = (size) => {
-    return {name: 'bytes', size}
-}
-
-const FateTypeHash = () => {
-    return {name: 'hash'}
-}
-
-const FateTypeSignature = () => {
-    return {name: 'signature'}
-}
-
-const FateTypeAccountAddress = () => {
-    return {name: 'account_pubkey'}
-}
-
-const FateTypeContractAddress = () => {
-    return {name: 'contract_pubkey'}
-}
-
-const FateTypeChannelAddress = () => {
-    return {name: 'channel'}
-}
-
-const FateTypeOracleAddress = (questionType, answerType) => {
-    return {
-        name: 'oracle_pubkey',
-        questionType,
-        answerType
-    }
-}
-
-const FateTypeOracleQueryAddress = (questionType, answerType) => {
-    return {
-        name: 'oracle_query_id',
-        questionType,
-        answerType
-    }
-}
-
-const FateTypeByteArray = () => {
-    return {name: 'byte_array'}
-}
-
-const FateTypeList = (valuesType) => {
-    return {
-        name: 'list',
-        valuesType,
-    }
-}
-
-const FateTypeTuple = (valueTypes = []) => {
-    return {
-        name: 'tuple',
-        valueTypes
-    }
-}
-
-const FateTypeRecord = (keys, valueTypes) => {
-    return {
-        name: 'record',
-        keys,
-        valueTypes,
-    }
-}
-
-const FateTypeSet = (valuesType) => {
-    return {
-        name: 'set',
-        valuesType,
-    }
-}
-
-const FateTypeMap = (keyType, valueType) => {
-    return {
-        name: 'map',
-        keyType,
-        valueType,
-    }
-}
-
-const FateTypeVariant = (variants) => {
-    return {
-        name: 'variant',
-        variants,
-    }
-}
-
-const FateTypeOption = (valueTypes) => {
-    const variants = [
-        { None: []},
-        { Some: valueTypes }
-    ]
-
-    return FateTypeVariant(variants)
-}
-
-const FateTypeChainTTL = () => {
-    const variants = [
-        {RelativeTTL: [FateTypeInt()]},
-        {FixedTTL: [FateTypeInt()]}
-    ]
-
-    return FateTypeVariant(variants)
-}
-
-const FateTypeChainGAMetaTx = () => {
-    const variants = [
-        {'Chain.GAMetaTx': [FateTypeAccountAddress(), FateTypeInt()]},
-    ]
-
-    return FateTypeVariant(variants)
-}
-
-const FateTypeChainPayingForTx = () => {
-    const variants = [
-        {'Chain.PayingForTx': [FateTypeAccountAddress(), FateTypeInt()]},
-    ]
-
-    return FateTypeVariant(variants)
-}
-
-const FateTypeChainBaseTx = () => {
-    const variants = [
-        {'Chain.SpendTx': [FateTypeAccountAddress(), FateTypeInt(), FateTypeString()]},
-        {'Chain.OracleRegisterTx': []},
-        {'Chain.OracleQueryTx': []},
-        {'Chain.OracleResponseTx': []},
-        {'Chain.OracleExtendTx': []},
-        {'Chain.NamePreclaimTx': []},
-        {'Chain.NameClaimTx': [FateTypeString()]},
-        {'Chain.NameUpdateTx': [FateTypeHash()]},
-        {'Chain.NameRevokeTx': [FateTypeHash()]},
-        {'Chain.NameTransferTx': [FateTypeAccountAddress(), FateTypeHash()]},
-        {'Chain.ChannelCreateTx': [FateTypeAccountAddress()]},
-        {'Chain.ChannelDepositTx': [FateTypeAccountAddress(), FateTypeInt()]},
-        {'Chain.ChannelWithdrawTx': [FateTypeAccountAddress(), FateTypeInt()]},
-        {'Chain.ChannelForceProgressTx': [FateTypeAccountAddress()]},
-        {'Chain.ChannelCloseMutualTx': [FateTypeAccountAddress()]},
-        {'Chain.ChannelCloseSoloTx': [FateTypeAccountAddress()]},
-        {'Chain.ChannelSlashTx': [FateTypeAccountAddress()]},
-        {'Chain.ChannelSettleTx': [FateTypeAccountAddress()]},
-        {'Chain.ChannelSnapshotSoloTx': [FateTypeAccountAddress()]},
-        {'Chain.ContractCreateTx': [FateTypeAccountAddress()]},
-        {'Chain.ContractCallTx': [FateTypeAccountAddress(), FateTypeInt()]},
-        {'Chain.GAAttachTx': []},
-    ]
-
-    return FateTypeVariant(variants)
-}
-
-const FateTypeAENSPointee = () => {
-    const variants = [
-        {'AENS.AccountPt': [FateTypeAccountAddress()]},
-        {'AENS.OraclePt': [FateTypeAccountAddress()]},
-        {'AENS.ContractPt': [FateTypeAccountAddress()]},
-        {'AENS.ChannelPt': [FateTypeAccountAddress()]},
-    ]
-
-    return FateTypeVariant(variants)
-}
-
-const FateTypeAENSName = () => {
-    const variants = [{
-        'AENS.Name': [
-            FateTypeAccountAddress(),
-            FateTypeChainTTL(),
-            FateTypeMap(FateTypeString(), FateTypeAENSPointee())
-        ]
-    }]
-
-    return FateTypeVariant(variants)
-}
-
-const FateTypeEvent = (variantType, topics) => {
-    return {
-        name: 'event',
-        variantType,
-        topics,
-    }
-}
-
-const FateTypeBls12381Fr = () => {
-    return {name: 'bls12_381.fr'}
-}
-
-const FateTypeBls12381Fp = () => {
-    return {name: 'bls12_381.fp'}
-}
-
-const FateTypeCalldata = (functionName, argumentTypes) => {
-    return {
-        name: 'calldata',
-        functionName,
-        argumentTypes,
-    }
-}
-
-const FateTypeVar = (id) => {
-    return {
-        name: 'tvar',
-        id
-    }
-}
-
-const FateTypeAny = () => {
-    return {name: 'any'}
-}
-
-module.exports = {
-    FateTypeVoid,
-    FateTypeInt,
-    FateTypeBool,
-    FateTypeString,
-    FateTypeBits,
-    FateTypeBytes,
-    FateTypeHash,
-    FateTypeSignature,
-    FateTypeAccountAddress,
-    FateTypeContractAddress,
-    FateTypeChannelAddress,
-    FateTypeOracleAddress,
-    FateTypeOracleQueryAddress,
-    FateTypeByteArray,
-    FateTypeList,
-    FateTypeTuple,
-    FateTypeRecord,
-    FateTypeSet,
-    FateTypeMap,
-    FateTypeVariant,
-    FateTypeOption,
-    FateTypeChainTTL,
-    FateTypeChainGAMetaTx,
-    FateTypeChainPayingForTx,
-    FateTypeChainBaseTx,
-    FateTypeAENSPointee,
-    FateTypeAENSName,
-    FateTypeEvent,
-    FateTypeBls12381Fr,
-    FateTypeBls12381Fp,
-    FateTypeCalldata,
-    FateTypeVar,
-    FateTypeAny,
-}
-
-
-/***/ }),
-
-/***/ 880:
-/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
-
-const ApiEncoder = __webpack_require__(7200)
-const {MontBytes2Int} = __webpack_require__(333)
-const {ByteArray2Hex} = __webpack_require__(240)
-
-/**
- * Map the internal representation FATE data structure to Aesophia canonical structures and formats.
- */
-
-class CanonicalMapper {
-    constructor() {
-        this._apiEncoder = new ApiEncoder()
-    }
-
-    toCanonical(data) {
-        return data.accept(this)
-    }
-
-    visitData(acceptor) {
-        return acceptor.valueOf()
-    }
-
-    visitAddress(acceptor) {
-        return this._apiEncoder.encode(acceptor.name, acceptor.value)
-    }
-
-    visitList(acceptor) {
-        return acceptor.items.map(e => e.accept(this))
-    }
-
-    visitSet(acceptor) {
-        return new Set(acceptor.items.map(e => e.accept(this)))
-    }
-
-    visitMap(acceptor) {
-        const map = new Map()
-        for (const [key, value] of acceptor.iterator) {
-            map.set(key.accept(this), value.accept(this))
-        }
-
-        return map
-    }
-
-    visitTuple(acceptor) {
-        return acceptor.prepareItems(e => e.accept(this))
-    }
-
-    visitVariant(acceptor) {
-        const value = acceptor.value.map(e => e.accept(this))
-
-        if (acceptor.variantName === 'None') {
-            return undefined
-        }
-
-        if (acceptor.variantName === 'Some') {
-            return value[0]
-        }
-
-        return {
-            [acceptor.variantName]: value
-        }
-    }
-
-    visitBls12381Fr(acceptor) {
-        return MontBytes2Int(acceptor.valueOf(), 'r')
-    }
-
-    visitBls12381Fp(acceptor) {
-        return MontBytes2Int(acceptor.valueOf(), 'p')
-    }
-
-    visitCalldata(acceptor) {
-        const {functionId, args} = acceptor.valueOf()
-
-        return {
-            functionId: ByteArray2Hex(functionId),
-            args: args.map(e => e.accept(this))
-        }
-    }
-}
-
-module.exports = CanonicalMapper
-
-
-/***/ }),
-
-/***/ 1338:
-/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
-
-const ApiEncoder = __webpack_require__(7200)
-const {Int2MontBytes} = __webpack_require__(333)
-const FateTypeError = __webpack_require__(5110)
-
-/**
- * Map Aesophia canonical structures and formats to internal representation FATE data structures.
- */
-class InternalMapper {
-    constructor() {
-        this._apiEncoder = new ApiEncoder()
-    }
-
-    toInternal(type, value) {
-        switch (type.name) {
-        case 'account_pubkey':
-        case 'contract_pubkey':
-        case 'channel':
-        case 'oracle_pubkey':
-        case 'oracle_query_id':
-            return this.toAddress(type, value)
-        case 'variant':
-            return this.toVariant(type, value)
-        case 'map':
-            return this.toMap(type, value)
-        case 'set':
-            return this.toSet(type, value)
-        case 'record':
-            return this.toRecord(type, value)
-        case 'bls12_381.fr':
-            return this.toBls12381Fr(type, value)
-        case 'bls12_381.fp':
-            return this.toBls12381Fp(type, value)
-        default:
-            return value
-        }
-    }
-
-    toAddress({name, _}, value) {
-        return this._apiEncoder.decodeWithType(value, name)
-    }
-
-    toVariant(type, value) {
-        if (!this.isOptionVariant(type)) {
-            return value
-        }
-
-        if ([undefined, null].includes(value)) {
-            return {None: []}
-        }
-
-        const [variantName] = Object.keys(value)
-        if (['Some', 'None'].includes(variantName)) {
-            return value
-        }
-
-        return {Some: [value]}
-    }
-
-    isOptionVariant({ _name, variants }) {
-        return variants.some(({ None }) => None && None.length === 0)
-            && variants.some(({ Some }) => Some)
-    }
-
-    toMap(type, value) {
-        if (typeof value !== 'object' || value === null) {
-            throw new FateTypeError(
-                'map',
-                `Fate map must be one of: Map, Array, Object; got ${value} instead`
-            )
-        }
-
-        return Array.isArray(value) || value instanceof Map ? value : Object.entries(value)
-    }
-
-    toSet(type, value) {
-        if (value instanceof Set) {
-            return value
-        }
-
-        if (Array.isArray(value)) {
-            return new Set(value)
-        }
-
-        throw new FateTypeError(
-            'set',
-            `Fate set must be a Set or Array, got "${value}" instead`
-        )
-    }
-
-    toRecord(type, record) {
-        return type.keys.reduce((v, name) => ({ ...v, [name]: record[name] }), {})
-    }
-
-    validateBls12381Field(type, value) {
-        if (typeof value !== 'bigint' && !Number.isInteger(value)) {
-            throw new FateTypeError(
-                type.name,
-                `Should be one of: BigInt or Number; got ${value} instead`
-            )
-        }
-    }
-
-    toBls12381Fr(type, value) {
-        this.validateBls12381Field(type, value)
-
-        return Int2MontBytes(value, 'r')
-    }
-
-    toBls12381Fp(type, value) {
-        this.validateBls12381Field(type, value)
-
-        return Int2MontBytes(value, 'p')
-    }
-}
-
-module.exports = InternalMapper
-
-
-/***/ }),
-
-/***/ 7829:
-/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
-
-const TypeFactory = __webpack_require__(2584)
-const FateData = __webpack_require__(9865)
-const BaseSerializer = __webpack_require__(8268)
-const AddressSerializer = __webpack_require__(9135)
-const BitsSerializer = __webpack_require__(1290)
-const BoolSerializer = __webpack_require__(4857)
-const ByteArraySerializer = __webpack_require__(8183)
-const BytesSerializer = __webpack_require__(6651)
-const ChannelSerializer = __webpack_require__(3234)
-const ContractSerializer = __webpack_require__(4150)
-const IntSerializer = __webpack_require__(2086)
-const VoidSerializer = __webpack_require__(34)
-const ListSerializer = __webpack_require__(2137)
-const SetSerializer = __webpack_require__(6210)
-const MapSerializer = __webpack_require__(692)
-const OracleQuerySerializer = __webpack_require__(4266)
-const OracleSerializer = __webpack_require__(1751)
-const StringSerializer = __webpack_require__(6973)
-const TupleSerializer = __webpack_require__(6178)
-const VariantSerializer = __webpack_require__(9503)
-const Bls12381FieldSerializer = __webpack_require__(5547)
-const CalldataSerializer = __webpack_require__(4276)
-const SerializerError = __webpack_require__(9098)
-
-class Serializer extends BaseSerializer {
-    constructor() {
-        super()
-
-        this.typeFactory = new TypeFactory()
-        this._serializers = {
-            'void': new VoidSerializer(),
-            'bool': new BoolSerializer(),
-            'int': new IntSerializer(),
-            'tuple': new TupleSerializer(this),
-            'record': new TupleSerializer(this),
-            'list': new ListSerializer(this),
-            'set': new SetSerializer(this),
-            'map': new MapSerializer(this),
-            'byte_array': new ByteArraySerializer(),
-            'string': new StringSerializer(),
-            'hash': new BytesSerializer(),
-            'signature': new BytesSerializer(),
-            'bits': new BitsSerializer(),
-            'variant': new VariantSerializer(this),
-            'bytes': new BytesSerializer(),
-            'account_pubkey': new AddressSerializer(),
-            'contract_pubkey': new ContractSerializer(),
-            'oracle_pubkey': new OracleSerializer(),
-            'oracle_query_id': new OracleQuerySerializer(),
-            'channel': new ChannelSerializer(),
-            'bls12_381.fr': new Bls12381FieldSerializer(),
-            'bls12_381.fp': new Bls12381FieldSerializer(),
-            'calldata': new CalldataSerializer(this),
-        }
-    }
-
-    _getSerializer(type) {
-        if (!type.hasOwnProperty('name')) {
-            throw new SerializerError('Unsupported type: ' + JSON.stringify(type))
-        }
-
-        const typeName = type.name
-        if (!this._serializers.hasOwnProperty(typeName)) {
-            throw new SerializerError('Unsupported type: ' + JSON.stringify(typeName))
-        }
-
-        return this._serializers[typeName]
-    }
-
-    serialize(data) {
-        if (typeof data !== 'object') {
-            throw new SerializerError('Only object serialization is supported. Got: ' + JSON.stringify(data))
-        }
-
-        if (!(data instanceof FateData)) {
-            throw new SerializerError('Only instances of FateData is supported.')
-        }
-
-        return this._getSerializer(data).serialize(data)
-    }
-
-    deserializeWithType(data, type) {
-        if (!(data instanceof Uint8Array)) {
-            throw new SerializerError('Only instances of Uint8Array is supported.')
-        }
-
-        return this._getSerializer(type).deserialize(data, type)
-    }
-
-    deserialize(data) {
-        if (!(data instanceof Uint8Array)) {
-            throw new SerializerError('Only instances of Uint8Array is supported.')
-        }
-
-        const type = this.typeFactory.createType(data)
-
-        return this.deserializeWithType(data, type)
-    }
-
-    deserializeStream(data, typeInfo) {
-        if (!(data instanceof Uint8Array)) {
-            throw new SerializerError('Only instances of Uint8Array is supported.')
-        }
-
-        let type = typeInfo
-        if (typeof typeInfo === 'undefined') {
-            type = this.typeFactory.createType(data)
-        }
-
-        return this._getSerializer(type).deserializeStream(data, typeInfo)
-    }
-}
-
-module.exports = Serializer
-
-
-/***/ }),
-
-/***/ 9135:
-/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
-
-const RLP = __webpack_require__(3485)
-const FateTag = __webpack_require__(105)
-const BaseSerializer = __webpack_require__(8268)
-const FateAccountAddress = __webpack_require__(539)
-
-class AddressSerializer extends BaseSerializer {
-    serialize(data) {
-        return [
-            FateTag.OBJECT,
-            FateTag.OTYPE_ADDRESS,
-            ...RLP.encode(data.value)
-        ]
-    }
-
-    deserializeStream(data) {
-        const buffer = new Uint8Array(data)
-        const decoded = RLP.decode(buffer.slice(2), true)
-
-        return [
-            new FateAccountAddress(decoded.data),
-            new Uint8Array(decoded.remainder)
-        ]
-    }
-}
-
-module.exports = AddressSerializer
-
-
-/***/ }),
-
-/***/ 8268:
-/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
-
-const SerializerError = __webpack_require__(9098)
-
-class BaseSerializer {
-    constructor(globalSerializer) {
-        this.globalSerializer = globalSerializer
-    }
-
-    serialize(_data) {
-        throw new SerializerError('Not implemented.')
-    }
-
-    deserialize(data, typeInfo) {
-        const [value, _rest] = this.deserializeStream(data, typeInfo)
-
-        return value
-    }
-
-    deserializeStream(_data, _typeInfo) {
-        throw new SerializerError('Not implemented.')
-    }
-}
-
-module.exports = BaseSerializer
-
-
-/***/ }),
-
-/***/ 1290:
-/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
-
-const FateTag = __webpack_require__(105)
-const RLPInt = __webpack_require__(7138)
-const FateBits = __webpack_require__(3422)
-const BaseSerializer = __webpack_require__(8268)
-const abs = __webpack_require__(9475)
-
-class BitsSerializer extends BaseSerializer {
-    serialize(data) {
-        const prefix = data.value >= 0 ? FateTag.POS_BITS : FateTag.NEG_BITS
-
-        return [
-            prefix,
-            ...RLPInt.encode(abs(data.value))
-        ]
-    }
-
-    deserializeStream(data) {
-        const buffer = new Uint8Array(data)
-        const sign = buffer[0] === FateTag.POS_BITS ? 1n : -1n
-        const [i, remainder] = RLPInt.decode(buffer.slice(1))
-
-        return [
-            new FateBits(i * sign),
-            new Uint8Array(remainder)
-        ]
-    }
-}
-
-module.exports = BitsSerializer
-
-
-/***/ }),
-
-/***/ 5547:
-/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
-
-const BaseSerializer = __webpack_require__(8268)
-const BytesSerializer = __webpack_require__(6651)
-const FateBls12381Fr = __webpack_require__(1565)
-const FateBls12381Fp = __webpack_require__(4077)
-
-const bytesSerializer = new BytesSerializer()
-
-const factory = (type, data) => {
-    switch (type.name) {
-    case 'bls12_381.fr':
-        return new FateBls12381Fr(data)
-    case 'bls12_381.fp':
-        return new FateBls12381Fp(data)
-    default:
-        throw new Error(`Unsupported type "${type.name}"`)
-    }
-}
-
-class Bls12381FieldSerializer extends BaseSerializer {
-    serialize(bytes) {
-        return bytesSerializer.serialize(bytes)
-    }
-
-    deserializeStream(data, typeInfo) {
-        const [bytes, rest] = bytesSerializer.deserializeStream(data)
-
-        return [
-            factory(typeInfo, bytes.valueOf()),
-            rest
-        ]
-    }
-}
-
-module.exports = Bls12381FieldSerializer
-
-
-/***/ }),
-
-/***/ 4857:
-/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
-
-const FateTag = __webpack_require__(105)
-const FateBool = __webpack_require__(4476)
-const BaseSerializer = __webpack_require__(8268)
-const FatePrefixError = __webpack_require__(5462)
-
-class BoolSerializer extends BaseSerializer {
-    serialize(data) {
-        return (data.valueOf() === true) ? [FateTag.TRUE] : [FateTag.FALSE]
-    }
-
-    deserializeStream(data) {
-        const buffer = new Uint8Array(data)
-        const prefix = buffer[0]
-        const rest = buffer.slice(1)
-
-        if (prefix === FateTag.TRUE) {
-            return [new FateBool(true), rest]
-        }
-
-        if (prefix === FateTag.FALSE) {
-            return [new FateBool(false), rest]
-        }
-
-        throw new FatePrefixError(prefix)
-    }
-}
-
-module.exports = BoolSerializer
-
-
-/***/ }),
-
-/***/ 8183:
-/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
-
-const FateTag = __webpack_require__(105)
-const BaseSerializer = __webpack_require__(8268)
-const FateByteArray = __webpack_require__(7945)
-const IntSerializer = __webpack_require__(2086)
-
-const intSerializer = new IntSerializer()
-
-class ByteArraySerializer extends BaseSerializer {
-    serialize(data) {
-        if (data.length === 0) {
-            return [FateTag.EMPTY_STRING]
-        }
-
-        if (data.length < 64) {
-            const prefix = (data.length << 2) | FateTag.SHORT_STRING
-
-            return [
-                prefix,
-                ...data.valueOf()
-            ]
-        }
-
-        return [
-            FateTag.LONG_STRING,
-            ...intSerializer.serialize(data.length - 64),
-            ...data.valueOf()
-        ]
-    }
-
-    deserializeStream(stream) {
-        const data = new Uint8Array(stream)
-        const prefix = data[0]
-
-        if (prefix === FateTag.EMPTY_STRING) {
-            return [
-                new FateByteArray(),
-                data.slice(1)
-            ]
-        }
-
-        if (prefix === FateTag.LONG_STRING) {
-            const [fateLen, rest] = intSerializer.deserializeStream(data.slice(1))
-            const len = Number(fateLen.valueOf()) + 64
-
-            return [
-                new FateByteArray(rest.slice(0, len)),
-                rest.slice(len)
-            ]
-        }
-
-        // short string
-        const offset = (prefix >> 2) + 1
-
-        return [
-            new FateByteArray(data.slice(1, offset)),
-            data.slice(offset)
-        ]
-    }
-}
-
-module.exports = ByteArraySerializer
-
-
-/***/ }),
-
-/***/ 6651:
-/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
-
-const FateTag = __webpack_require__(105)
-const ByteArraySerializer = __webpack_require__(8183)
-const FateBytes = __webpack_require__(5779)
-const BaseSerializer = __webpack_require__(8268)
-
-const byteArraySerializer = new ByteArraySerializer()
-
-class BytesSerializer extends BaseSerializer {
-    serialize(bytes) {
-        return [
-            FateTag.OBJECT,
-            FateTag.OTYPE_BYTES,
-            ...byteArraySerializer.serialize(bytes.value)
-        ]
-    }
-
-    deserializeStream(data) {
-        const buffer = new Uint8Array(data)
-        const [bytes, rest] = byteArraySerializer.deserializeStream(buffer.slice(2))
-
-        return [
-            new FateBytes(bytes.valueOf()),
-            rest
-        ]
-    }
-}
-
-module.exports = BytesSerializer
-
-
-/***/ }),
-
-/***/ 4276:
-/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
-
-const FateTuple = __webpack_require__(6878)
-const FateCalldata = __webpack_require__(7255)
-const FateByteArray = __webpack_require__(7945)
-const BaseSerializer = __webpack_require__(8268)
-const {FateTypeTuple, FateTypeByteArray} = __webpack_require__(4265)
-
-class CalldataSerializer extends BaseSerializer {
-    serialize(calldata) {
-        const funcBytes = new FateByteArray(calldata.functionId)
-        const argsTuple = new FateTuple(calldata.argTypes, calldata.args)
-
-        const calldataTuple = new FateTuple(
-            [funcBytes.type, argsTuple.type],
-            [funcBytes, argsTuple]
-        )
-
-        return this.globalSerializer.serialize(calldataTuple)
-    }
-
-    deserialize(data, typeInfo) {
-        const calldataType = FateTypeTuple([
-            FateTypeByteArray(),
-            FateTypeTuple(typeInfo.argumentTypes)
-        ])
-
-        const [calldataTuple,] = this.globalSerializer.deserializeStream(data, calldataType)
-        const [functionId, argsTuple] = calldataTuple.items
-
-        return new FateCalldata(functionId.valueOf(), argsTuple.valueTypes, argsTuple.items)
-    }
-}
-
-module.exports = CalldataSerializer
-
-
-/***/ }),
-
-/***/ 3234:
-/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
-
-const RLP = __webpack_require__(3485)
-const FateTag = __webpack_require__(105)
-const BaseSerializer = __webpack_require__(8268)
-const FateChannelAddress = __webpack_require__(6445)
-
-class ChannelSerializer extends BaseSerializer {
-    serialize(data) {
-        return [
-            FateTag.OBJECT,
-            FateTag.OTYPE_CHANNEL,
-            ...RLP.encode(data.value)
-        ]
-    }
-
-    deserializeStream(data) {
-        const buffer = new Uint8Array(data)
-        const decoded = RLP.decode(buffer.slice(2), true)
-
-        return [
-            new FateChannelAddress(decoded.data),
-            new Uint8Array(decoded.remainder)
-        ]
-    }
-}
-
-module.exports = ChannelSerializer
-
-
-/***/ }),
-
-/***/ 4150:
-/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
-
-const RLP = __webpack_require__(3485)
-const FateTag = __webpack_require__(105)
-const BaseSerializer = __webpack_require__(8268)
-const FateContractAddress = __webpack_require__(8623)
-
-class ContractSerializer extends BaseSerializer {
-    serialize(data) {
-        return [
-            FateTag.OBJECT,
-            FateTag.OTYPE_CONTRACT,
-            ...RLP.encode(data.value)
-        ]
-    }
-
-    deserializeStream(data) {
-        const buffer = new Uint8Array(data)
-        const decoded = RLP.decode(buffer.slice(2), true)
-
-        return [
-            new FateContractAddress(decoded.data),
-            new Uint8Array(decoded.remainder)
-        ]
-    }
-}
-
-module.exports = ContractSerializer
-
-
-/***/ }),
-
-/***/ 2086:
-/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
-
-const FateTag = __webpack_require__(105)
-const RLPInt = __webpack_require__(7138)
-const FateInt = __webpack_require__(3509)
-const BaseSerializer = __webpack_require__(8268)
-const FatePrefixError = __webpack_require__(5462)
-const abs = __webpack_require__(9475)
-
-const SMALL_INT_MASK = 0b00000001
-
-class IntSerializer extends BaseSerializer {
-    serialize(data) {
-        const bigValue = (data instanceof FateInt) ? data.value : BigInt(data)
-        const absVal = abs(bigValue)
-
-        // small integer
-        if (absVal < 64) {
-            const small = Number(absVal)
-            if (bigValue >= 0) {
-                return [(small << 1)]
-            }
-
-            // negative
-            return [(0b10000000 | (small << 1)) & 0b11111110]
-        }
-
-        // large negative integer
-        if (bigValue < 0) {
-            return [
-                FateTag.NEG_BIG_INT,
-                ...RLPInt.encode(absVal - 64n)
-            ]
-        }
-
-        // large positive integer
-        return [
-            FateTag.POS_BIG_INT,
-            ...RLPInt.encode(absVal - 64n)
-        ]
-    }
-
-    deserializeStream(stream) {
-        const data = new Uint8Array(stream)
-        const prefix = data[0]
-
-        // small int
-        if ((prefix & SMALL_INT_MASK) === 0) {
-            // positive
-            if ((prefix & 0b10000000) === 0) {
-                return [
-                    new FateInt(prefix >> 1),
-                    data.slice(1)
-                ]
-            }
-
-            // negative
-            const i = (prefix & 0b01111110) >> 1
-
-            return [
-                new FateInt(-i),
-                data.slice(1)
-            ]
-        }
-
-        if (prefix === FateTag.POS_BIG_INT || prefix === FateTag.NEG_BIG_INT) {
-            const sign = prefix === FateTag.POS_BIG_INT ? 1n : -1n
-            const [i, remainder] = RLPInt.decode(data.slice(1))
-
-            return [
-                new FateInt((i + 64n) * sign),
-                new Uint8Array(remainder)
-            ]
-        }
-
-        throw new FatePrefixError(prefix)
-    }
-}
-
-module.exports = IntSerializer
-
-
-/***/ }),
-
-/***/ 2137:
-/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
-
-const RLPInt = __webpack_require__(7138)
-const FateTag = __webpack_require__(105)
-const FateList = __webpack_require__(1041)
-const BaseSerializer = __webpack_require__(8268)
-
-class ListSerializer extends BaseSerializer {
-    serialize(list) {
-        const serializedElements = list.items.map(e => {
-            return this.globalSerializer.serialize(e)
-        }).flat(Infinity)
-
-        const len = list.items.length
-
-        if (len < 16) {
-            const prefix = (len << 4) | FateTag.SHORT_LIST
-
-            return [
-                prefix,
-                ...serializedElements
-            ]
-        }
-
-        return [
-            FateTag.LONG_LIST,
-            ...RLPInt.encode(len - 16),
-            ...serializedElements
-        ]
-    }
-
-    deserializeStream(data, typeInfo) {
-        const buffer = new Uint8Array(data)
-        const prefix = buffer[0]
-        let len = 0n
-        let rest = buffer.slice(1)
-
-        if (prefix === FateTag.LONG_LIST) {
-            [len, rest] = RLPInt.decode(buffer.slice(1))
-            len += 16n
-        }
-
-        if ((prefix & 0x0F) === FateTag.SHORT_LIST) {
-            len = BigInt((prefix & 0xF0) >> 4)
-        }
-
-        let itemsType
-
-        if (typeof typeInfo !== 'undefined') {
-            itemsType = typeInfo.valuesType
-        }
-
-        let el
-        const elements = []
-
-        for (let i = 0n; i < len; i++) {
-            [el, rest] = this.globalSerializer.deserializeStream(rest, itemsType)
-            elements.push(el)
-        }
-
-        if (len === 0n) {
-            return [new FateList(), rest]
-        }
-
-        if (typeof typeInfo === 'undefined') {
-            itemsType = elements[0].type
-        }
-
-        return [
-            new FateList(itemsType, elements),
-            rest
-        ]
-    }
-}
-
-module.exports = ListSerializer
-
-
-/***/ }),
-
-/***/ 692:
-/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
-
-const FateTag = __webpack_require__(105)
-const RLPInt = __webpack_require__(7138)
-const BaseSerializer = __webpack_require__(8268)
-const FateComparator = __webpack_require__(2689)
-const FateMap = __webpack_require__(8804)
-const FatePrefixError = __webpack_require__(5462)
-
-class MapSerializer extends BaseSerializer {
-    serialize(map) {
-        const len = map.length
-        const cmp = FateComparator(map.keyType)
-
-        const sortedItems = [...map.items]
-        sortedItems.sort((elA, elB) => cmp(elA.key, elB.key))
-
-        const serializedItems = sortedItems.map(i => {
-            return [
-                this.globalSerializer.serialize(i.key),
-                this.globalSerializer.serialize(i.value)
-            ]
-        })
-
-        return [
-            FateTag.MAP,
-            ...RLPInt.encode(len),
-            ...serializedItems.flat(Infinity)
-        ]
-    }
-
-    deserializeStream(data, typeInfo) {
-        const buffer = new Uint8Array(data)
-        const prefix = buffer[0]
-
-        if (prefix !== FateTag.MAP) {
-            throw new FatePrefixError(prefix)
-        }
-
-        const [len, remainder] = RLPInt.decode(buffer.slice(1))
-        let rest = remainder
-
-        if (len === 0n) {
-            return [new FateMap(), rest]
-        }
-
-        let keyType
-        let valueType
-
-        if (typeof typeInfo !== 'undefined') {
-            ({keyType, valueType} = typeInfo)
-        }
-
-        const elements = []
-        for (let i = 0n; i < len; i++) {
-            const [key, keyRest] = this.globalSerializer.deserializeStream(rest, keyType)
-            const [value, valueRest] = this.globalSerializer.deserializeStream(keyRest, valueType)
-
-            elements.push([key, value])
-            rest = valueRest
-        }
-
-        const firstEl = elements[0]
-
-        if (typeof typeInfo === 'undefined') {
-            keyType = firstEl[0].type
-            valueType = firstEl[1].type
-        }
-
-        return [
-            new FateMap(
-                keyType,
-                valueType,
-                elements
-            ),
-            rest
-        ]
-    }
-}
-
-module.exports = MapSerializer
-
-
-/***/ }),
-
-/***/ 4266:
-/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
-
-const RLP = __webpack_require__(3485)
-const FateTag = __webpack_require__(105)
-const BaseSerializer = __webpack_require__(8268)
-const FateOracleQueryAddress = __webpack_require__(5070)
-
-class OracleQuerySerializer extends BaseSerializer {
-    serialize(data) {
-        return [
-            FateTag.OBJECT,
-            FateTag.OTYPE_ORACLE_QUERY,
-            ...RLP.encode(data.value)
-        ]
-    }
-
-    deserializeStream(data) {
-        const buffer = new Uint8Array(data)
-        const decoded = RLP.decode(buffer.slice(2), true)
-
-        return [
-            new FateOracleQueryAddress(decoded.data),
-            new Uint8Array(decoded.remainder)
-        ]
-    }
-}
-
-module.exports = OracleQuerySerializer
-
-
-/***/ }),
-
-/***/ 1751:
-/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
-
-const RLP = __webpack_require__(3485)
-const FateTag = __webpack_require__(105)
-const BaseSerializer = __webpack_require__(8268)
-const FateOracleAddress = __webpack_require__(687)
-
-class OracleSerializer extends BaseSerializer {
-    serialize(data) {
-        return [
-            FateTag.OBJECT,
-            FateTag.OTYPE_ORACLE,
-            ...RLP.encode(data.value)
-        ]
-    }
-
-    deserializeStream(data) {
-        const buffer = new Uint8Array(data)
-        const decoded = RLP.decode(buffer.slice(2), true)
-
-        return [
-            new FateOracleAddress(decoded.data),
-            new Uint8Array(decoded.remainder)
-        ]
-    }
-}
-
-module.exports = OracleSerializer
-
-
-/***/ }),
-
-/***/ 6210:
-/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
-
-const BaseSerializer = __webpack_require__(8268)
-const {FateTypeTuple, FateTypeMap} = __webpack_require__(4265)
-const FateMap = __webpack_require__(8804)
-const FateTuple = __webpack_require__(6878)
-const FateSet = __webpack_require__(2548)
-
-// This serializer takes advantages of the singular tuple optimization directly
-// An alternative implementation would be building the full structure
-// and pass it upstream for optimization.
-// Unbox singleton tuples and records
-// https://github.com/aeternity/aesophia/pull/205
-// https://github.com/aeternity/aesophia/commit/a403a9d227ac56266cf5bb8fbc916f17e6141d15
-
-class SetSerializer extends BaseSerializer {
-    serialize(set) {
-        return this.globalSerializer.serialize(new FateMap(
-            set.itemsType,
-            FateTypeTuple(),
-            set.items.map(i => [i, new FateTuple()])
-        ))
-    }
-
-    deserializeStream(data, typeInfo) {
-        const mapType = FateTypeMap(typeInfo.valuesType, FateTypeTuple())
-        const [map, rest] = this.globalSerializer.deserializeStream(data, mapType)
-
-        return [
-            new FateSet(typeInfo.valuesType, map.keys),
-            rest
-        ]
-    }
-}
-
-module.exports = SetSerializer
-
-
-/***/ }),
-
-/***/ 6973:
-/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
-
-const FateTag = __webpack_require__(105)
-const BaseSerializer = __webpack_require__(8268)
-const ByteArraySerializer = __webpack_require__(8183)
-const FateString = __webpack_require__(6313)
-const FatePrefixError = __webpack_require__(5462)
-
-const byteArraySerializer = new ByteArraySerializer()
-
-class StringSerializer extends BaseSerializer {
-    serialize(value) {
-        const encoder = new TextEncoder()
-        const bytes = encoder.encode(value)
-
-        return byteArraySerializer.serialize(bytes)
-    }
-
-    deserializeStream(data) {
-        const buffer = new Uint8Array(data)
-        const prefix = buffer[0]
-
-        if (
-            (prefix & 0b11) !== FateTag.SHORT_STRING
-            && ![FateTag.EMPTY_STRING, FateTag.LONG_STRING].includes(prefix)
-        ) {
-            throw new FatePrefixError(prefix)
-        }
-
-        const decoder = new TextDecoder()
-        const [bytes, rest] = byteArraySerializer.deserializeStream(buffer)
-
-        return [
-            new FateString(decoder.decode(bytes.valueOf())),
-            rest
-        ]
-    }
-}
-
-module.exports = StringSerializer
-
-
-/***/ }),
-
-/***/ 6178:
-/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
-
-const FateTag = __webpack_require__(105)
-const FateTuple = __webpack_require__(6878)
-const BaseSerializer = __webpack_require__(8268)
-const RLPInt = __webpack_require__(7138)
-
-class TupleSerializer extends BaseSerializer {
-    serialize(tuple) {
-        const len = tuple.size
-        if (len === 0) {
-            return [FateTag.EMPTY_TUPLE]
-        }
-
-        const elements = tuple.items
-            .map(e => this.globalSerializer.serialize(e))
-            .flat(Infinity)
-
-        if (len < 16) {
-            const prefix = (len << 4) | FateTag.SHORT_TUPLE
-
-            return [
-                prefix,
-                ...elements
-            ]
-        }
-
-        return [
-            FateTag.LONG_TUPLE,
-            ...RLPInt.encode(len - 16),
-            ...elements
-        ]
-    }
-
-    deserializeStream(data, typeInfo) {
-        const buffer = new Uint8Array(data)
-        const prefix = buffer[0]
-        let len = 0n
-        let rest = buffer.slice(1)
-
-        if (prefix === FateTag.EMPTY_TUPLE) {
-            return [new FateTuple(), rest]
-        }
-
-        if ((prefix & 0x0F) === FateTag.SHORT_TUPLE) {
-            len = (prefix & 0xF0) >> 4
-        }
-
-        if (prefix === FateTag.LONG_TUPLE) {
-            [len, rest] = RLPInt.decode(buffer.slice(1))
-            len += 16n
-        }
-
-        let valueTypes = []
-        if (typeof typeInfo !== 'undefined') {
-            valueTypes = typeInfo.valueTypes
-        }
-
-        const elements = []
-        let el = null
-        for (let i = 0n; i < len; i++) {
-            [el, rest] = this.globalSerializer.deserializeStream(rest, valueTypes[i])
-            elements.push(el)
-        }
-
-        let type = typeInfo
-        if (typeof typeInfo === 'undefined') {
-            type = elements.map(e => e.type)
-        }
-
-        return [
-            new FateTuple(type, elements),
-            rest
-        ]
-    }
-}
-
-module.exports = TupleSerializer
-
-
-/***/ }),
-
-/***/ 9503:
-/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
-
-const RLP = __webpack_require__(3485)
-const FateTag = __webpack_require__(105)
-const FateTuple = __webpack_require__(6878)
-const FateVariant = __webpack_require__(2457)
-const {FateTypeTuple} = __webpack_require__(4265)
-const BaseSerializer = __webpack_require__(8268)
-
-class VariantSerializer extends BaseSerializer {
-    serialize(variant) {
-        const valueTuple = new FateTuple(variant.valueTypes, variant.value)
-
-        return [
-            FateTag.VARIANT,
-            ...RLP.encode(new Uint8Array(variant.arities)),
-            variant.tag,
-            ...this.globalSerializer.serialize(valueTuple)
-        ]
-    }
-
-    deserializeStream(stream, typeInfo) {
-        const buffer = new Uint8Array(stream)
-        const decoded = RLP.decode(buffer.slice(1), true)
-        const arities = [...decoded.data]
-        const tag = decoded.remainder[0]
-        const data = decoded.remainder.slice(1)
-        let variants = []
-        let valueType
-
-        if (typeof typeInfo !== 'undefined' && typeof typeInfo.variants !== 'undefined') {
-            variants = typeInfo.variants
-            valueType = FateTypeTuple(Object.values(variants[tag])[0])
-        }
-
-        const [els, rest] = this.globalSerializer.deserializeStream(data, valueType)
-
-        return [
-            new FateVariant(arities, tag, els.items, els.valueTypes, variants),
-            rest
-        ]
-    }
-}
-
-module.exports = VariantSerializer
-
-
-/***/ }),
-
-/***/ 34:
-/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
-
-const FateVoid = __webpack_require__(9713)
-const BaseSerializer = __webpack_require__(8268)
-
-class VoidSerializer extends BaseSerializer {
-    serialize() {
-        return ''
-    }
-
-    deserialize() {
-        return new FateVoid()
-    }
-
-    deserializeStream(data) {
-        return [new FateVoid(), data]
-    }
-}
-
-module.exports = VoidSerializer
-
-
-/***/ }),
-
-/***/ 2584:
-/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
-
-const assert = __webpack_require__(4664)
-const FateTag = __webpack_require__(105)
-const FatePrefixError = __webpack_require__(5462)
-const {
-    FateTypeInt,
-    FateTypeBool,
-    FateTypeString,
-    FateTypeBits,
-    FateTypeBytes,
-    FateTypeAccountAddress,
-    FateTypeContractAddress,
-    FateTypeOracleAddress,
-    FateTypeOracleQueryAddress,
-    FateTypeChannelAddress,
-    FateTypeList,
-    FateTypeMap,
-    FateTypeTuple,
-    FateTypeVariant,
-} = __webpack_require__(4265)
-
-const OBJECT_TYPES = {
-    [FateTag.OTYPE_ADDRESS]: FateTypeAccountAddress(),
-    [FateTag.OTYPE_BYTES]: FateTypeBytes(),
-    [FateTag.OTYPE_CONTRACT]: FateTypeContractAddress(),
-    [FateTag.OTYPE_ORACLE]: FateTypeOracleAddress(),
-    [FateTag.OTYPE_ORACLE_QUERY]: FateTypeOracleQueryAddress(),
-    [FateTag.OTYPE_CHANNEL]: FateTypeChannelAddress(),
-}
-
-class TypeFactory {
-    createType(data) {
-        const tag = data[0]
-
-        if (tag === FateTag.TRUE || tag === FateTag.FALSE) {
-            return FateTypeBool()
-        }
-
-        if ((tag & 0x01) === FateTag.SMALL_INT
-            || tag === FateTag.POS_BIG_INT
-            || tag === FateTag.NEG_BIG_INT
-        ) {
-            return FateTypeInt()
-        }
-
-        if ((tag & 0x03) === FateTag.SHORT_STRING
-            || tag === FateTag.LONG_STRING
-            || tag === FateTag.EMPTY_STRING
-        ) {
-            return FateTypeString()
-        }
-
-        if ((tag & 0x0F) === FateTag.SHORT_LIST || tag === FateTag.LONG_LIST) {
-            return FateTypeList()
-        }
-
-        if ((tag & 0x0F) === FateTag.SHORT_TUPLE
-            || tag === FateTag.LONG_TUPLE
-            || tag === FateTag.EMPTY_TUPLE
-        ) {
-            return FateTypeTuple()
-        }
-
-        if (tag === FateTag.MAP || tag === FateTag.EMPTY_MAP) {
-            return FateTypeMap()
-        }
-
-        if (tag === FateTag.POS_BITS || tag === FateTag.NEG_BITS) {
-            return FateTypeBits()
-        }
-
-        if (tag === FateTag.VARIANT) {
-            return FateTypeVariant()
-        }
-
-        if (tag === FateTag.OBJECT) {
-            const obj = data[1]
-            assert(OBJECT_TYPES.hasOwnProperty(obj), `Unsupported object type "${obj}"`)
-
-            return OBJECT_TYPES[obj]
-        }
-
-        throw new FatePrefixError(tag)
-    }
-}
-
-module.exports = TypeFactory
-
-
-/***/ }),
-
-/***/ 539:
-/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
-
-const FateAddress = __webpack_require__(6187)
-
-class FateAccountAddress extends FateAddress {
-    constructor(value) {
-        super(value, 'account_pubkey', 'ak')
-    }
-}
-
-module.exports = FateAccountAddress
-
-
-/***/ }),
-
-/***/ 6187:
-/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
-
-const FateBytes = __webpack_require__(5779)
-
-class FateAddress extends FateBytes {
-    constructor(value, name, prefix) {
-        super(value, 32, name)
-
-        this._prefix = prefix
-    }
-
-    get prefix() {
-        return this._prefix
-    }
-
-    accept(visitor) {
-        return visitor.visitAddress(this)
-    }
-}
-
-module.exports = FateAddress
-
-
-/***/ }),
-
-/***/ 3422:
-/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
-
-const FateData = __webpack_require__(9865)
-
-class FateBits extends FateData {
-    constructor(value) {
-        super('bits')
-
-        this._value = BigInt(value)
-    }
-
-    get value() {
-        return this._value
-    }
-
-    valueOf() {
-        return this._value
-    }
-}
-
-module.exports = FateBits
-
-
-/***/ }),
-
-/***/ 7430:
-/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
-
-const FateData = __webpack_require__(9865)
-const FateTypeError = __webpack_require__(5110)
-
-class FateBls12381Field extends FateData {
-    constructor(value, size, name) {
-        super(name)
-
-        if (!Array.isArray(value) && !ArrayBuffer.isView(value)) {
-            throw new FateTypeError(
-                name,
-                `Should be one of: Array or ArrayBuffer; got ${value} instead`
-            )
-        }
-
-        const buff = new Uint8Array(value)
-
-        if (buff.byteLength !== size) {
-            throw new FateTypeError(
-                name,
-                `Invalid length: got ${buff.byteLength} bytes instead of ${size} bytes`
-            )
-        }
-
-        this._value = buff
-        this._size = size
-    }
-
-    get value() {
-        return this._value
-    }
-
-    get size() {
-        return this._size
-    }
-
-    valueOf() {
-        return this._value
-    }
-}
-
-module.exports = FateBls12381Field
-
-
-/***/ }),
-
-/***/ 4077:
-/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
-
-const FateBls12381Field = __webpack_require__(7430)
-const {FateTypeBls12381Fp} = __webpack_require__(4265)
-
-const SIZE = 48
-const NAME = 'bls12_381.fp'
-
-class FateBls12381Fp extends FateBls12381Field {
-    constructor(value) {
-        super(value, SIZE, NAME)
-    }
-
-    get type() {
-        return FateTypeBls12381Fp()
-    }
-
-    accept(visitor) {
-        return visitor.visitBls12381Fp(this)
-    }
-}
-
-module.exports = FateBls12381Fp
-
-
-/***/ }),
-
-/***/ 1565:
-/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
-
-const FateBls12381Field = __webpack_require__(7430)
-const {FateTypeBls12381Fr} = __webpack_require__(4265)
-
-const SIZE = 32
-const NAME = 'bls12_381.fr'
-
-class FateBls12381Fr extends FateBls12381Field {
-    constructor(value) {
-        super(value, SIZE, NAME)
-    }
-
-    get type() {
-        return FateTypeBls12381Fr()
-    }
-
-    accept(visitor) {
-        return visitor.visitBls12381Fr(this)
-    }
-}
-
-module.exports = FateBls12381Fr
-
-
-/***/ }),
-
-/***/ 4476:
-/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
-
-const FateData = __webpack_require__(9865)
-const {FateTypeBool} = __webpack_require__(4265)
-
-class FateBool extends FateData {
-    constructor(value) {
-        super('bool')
-
-        this._value = !!value
-    }
-
-    get value() {
-        return this._value
-    }
-
-    get type() {
-        return FateTypeBool()
-    }
-
-    valueOf() {
-        return this._value
-    }
-}
-
-module.exports = FateBool
-
-
-/***/ }),
-
-/***/ 7945:
-/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
-
-const FateData = __webpack_require__(9865)
-const {FateTypeByteArray} = __webpack_require__(4265)
-
-class FateByteArray extends FateData {
-    constructor(value = []) {
-        super('byte_array')
-
-        this._value = new Uint8Array(value)
-    }
-
-    get length() {
-        return this._value.length
-    }
-
-    get type() {
-        return FateTypeByteArray()
-    }
-
-    valueOf() {
-        return this._value
-    }
-}
-
-module.exports = FateByteArray
-
-
-/***/ }),
-
-/***/ 5779:
-/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
-
-const FateData = __webpack_require__(9865)
-const {Int2ByteArray} = __webpack_require__(240)
-const HexStringToByteArray = __webpack_require__(381)
-const FateTypeError = __webpack_require__(5110)
-
-const toByteArray = (value, size = 0) => {
-    if (Array.isArray(value) || ArrayBuffer.isView(value)) {
-        return new Uint8Array(value)
-    }
-
-    if (typeof value === 'string') {
-        return HexStringToByteArray(value)
-    }
-
-    if (typeof value !== 'bigint' && !Number.isInteger(value)) {
-        throw new FateTypeError(
-            'byte_array',
-            `Should be one of: Array, ArrayBuffer, hex string, Number, BigInt; got ${value} instead`
-        )
-    }
-
-    const bytes = Int2ByteArray(value)
-    if (bytes.length >= size) {
-        return bytes
-    }
-
-    // pad the byte array with 0 significant bytes, because int representation lost
-    const fixedSize = new Uint8Array(size)
-    fixedSize.set(bytes, size - bytes.length)
-
-    return fixedSize
-}
-
-class FateBytes extends FateData {
-    constructor(value, size, name = 'bytes') {
-        super(name)
-
-        this._value = toByteArray(value, size)
-
-        if (size && this._value.byteLength !== size) {
-            throw new FateTypeError(
-                name,
-                `Invalid length: got ${this._value.byteLength} bytes instead of ${size} bytes`
-            )
-        }
-
-        this._size = size
-    }
-
-    get value() {
-        return this._value
-    }
-
-    get size() {
-        return this._size
-    }
-
-    valueOf() {
-        return this._value
-    }
-}
-
-module.exports = FateBytes
-
-
-/***/ }),
-
-/***/ 7255:
-/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
-
-const FateData = __webpack_require__(9865)
-
-class FateCalldata extends FateData {
-    constructor(functionId, argTypes, argsData) {
-        super('calldata')
-
-        this._functionId = new Uint8Array(functionId)
-        this._argTypes = argTypes
-        this._args = argsData
-    }
-
-    get functionId() {
-        return this._functionId
-    }
-
-    get argTypes() {
-        return this._argTypes
-    }
-
-    get args() {
-        return this._args
-    }
-
-    valueOf() {
-        return {
-            functionId: this._functionId,
-            args: this._args
-        }
-    }
-
-    accept(visitor) {
-        return visitor.visitCalldata(this)
-    }
-}
-
-module.exports = FateCalldata
-
-
-/***/ }),
-
-/***/ 6445:
-/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
-
-const FateAddress = __webpack_require__(6187)
-
-class FateChannelAddress extends FateAddress {
-    constructor(value) {
-        super(value, 'channel', 'ch')
-    }
-}
-
-module.exports = FateChannelAddress
-
-
-/***/ }),
-
-/***/ 8623:
-/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
-
-const FateAddress = __webpack_require__(6187)
-
-class FateContractAddress extends FateAddress {
-    constructor(value) {
-        super(value, 'contract_pubkey', 'ct')
-    }
-}
-
-module.exports = FateContractAddress
-
-
-/***/ }),
-
-/***/ 9865:
-/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
-
-const InternalError = __webpack_require__(2966)
-
-class FateData {
-    constructor(name) {
-        this.name = name
-    }
-
-    valueOf() {
-        throw new InternalError('Not implemented.')
-    }
-
-    accept(visitor) {
-        return visitor.visitData(this)
-    }
-}
-
-module.exports = FateData
-
-
-/***/ }),
-
-/***/ 7772:
-/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
-
-const FateBytes = __webpack_require__(5779)
-
-class FateHash extends FateBytes {
-    constructor(value) {
-        super(value, 32, 'hash')
-    }
-}
-
-module.exports = FateHash
-
-
-/***/ }),
-
-/***/ 3509:
-/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
-
-const FateData = __webpack_require__(9865)
-const {FateTypeInt} = __webpack_require__(4265)
-
-class FateInt extends FateData {
-    constructor(value) {
-        super('int')
-
-        this._value = BigInt(value)
-    }
-
-    get value() {
-        return this._value
-    }
-
-    get type() {
-        return FateTypeInt()
-    }
-
-    valueOf() {
-        return this._value
-    }
-}
-
-module.exports = FateInt
-
-
-/***/ }),
-
-/***/ 1041:
-/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
-
-const FateData = __webpack_require__(9865)
-const {FateTypeList} = __webpack_require__(4265)
-
-class FateList extends FateData {
-    constructor(itemsType, items = []) {
-        super('list')
-
-        this._itemsType = itemsType
-        this.items = Array.from(items)
-    }
-
-    get itemsType() {
-        return this._itemsType
-    }
-
-    get type() {
-        return FateTypeList(this.itemsType)
-    }
-
-    get length() {
-        return this.items.length
-    }
-
-    valueOf() {
-        return this.items.map(e => e.valueOf())
-    }
-
-    accept(visitor) {
-        return visitor.visitList(this)
-    }
-}
-
-module.exports = FateList
-
-
-/***/ }),
-
-/***/ 8804:
-/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
-
-const FateData = __webpack_require__(9865)
-const {FateTypeMap} = __webpack_require__(4265)
-
-const arrayToItem = (item) => {
-    const [key, value] = item
-    return {key, value}
-}
-
-class FateMap extends FateData {
-    constructor(keyType, valueType, items = []) {
-        super('map')
-
-        this._keyType = keyType
-        this._valueType = valueType
-        this._type = FateTypeMap(keyType, valueType)
-        this._value = new Map(items)
-    }
-
-    get items() {
-        return [...this._value.entries()].map(arrayToItem)
-    }
-
-    get keyType() {
-        return this._keyType
-    }
-
-    get valueType() {
-        return this._valueType
-    }
-
-    get type() {
-        return this._type
-    }
-
-    get length() {
-        return this._value.size
-    }
-
-    get iterator() {
-        return this._value[Symbol.iterator]()
-    }
-
-    get keys() {
-        return this._value.keys()
-    }
-
-    valueOf() {
-        const map = new Map()
-        for (const [key, value] of this.iterator) {
-            map.set(key.valueOf(), value.valueOf())
-        }
-
-        return map
-    }
-
-    accept(visitor) {
-        return visitor.visitMap(this)
-    }
-}
-
-module.exports = FateMap
-
-
-/***/ }),
-
-/***/ 687:
-/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
-
-const FateAddress = __webpack_require__(6187)
-
-class FateOracleAddress extends FateAddress {
-    constructor(value) {
-        super(value, 'oracle_pubkey', 'ok')
-    }
-}
-
-module.exports = FateOracleAddress
-
-
-/***/ }),
-
-/***/ 5070:
-/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
-
-const FateAddress = __webpack_require__(6187)
-
-class FateOracleQueryAddress extends FateAddress {
-    constructor(value) {
-        super(value, 'oracle_query_id', 'oq')
-    }
-}
-
-module.exports = FateOracleQueryAddress
-
-
-/***/ }),
-
-/***/ 2548:
-/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
-
-const FateData = __webpack_require__(9865)
-const {FateTypeSet} = __webpack_require__(4265)
-
-class FateSet extends FateData {
-    constructor(itemsType, items = []) {
-        super('set')
-
-        this._itemsType = itemsType
-        this._items = new Set(items)
-    }
-
-    get items() {
-        return Array.from(this._items.values())
-    }
-
-    get itemsType() {
-        return this._itemsType
-    }
-
-    get type() {
-        return FateTypeSet(this.itemsType)
-    }
-
-    get length() {
-        return this._items.size
-    }
-
-    valueOf() {
-        return new Set(this.items.map(e => e.valueOf()))
-    }
-
-    accept(visitor) {
-        return visitor.visitSet(this)
-    }
-}
-
-module.exports = FateSet
-
-
-/***/ }),
-
-/***/ 3607:
-/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
-
-const FateBytes = __webpack_require__(5779)
-
-class FateSignature extends FateBytes {
-    constructor(value) {
-        super(value, 64, 'signature')
-    }
-}
-
-module.exports = FateSignature
-
-
-/***/ }),
-
-/***/ 6313:
-/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
-
-const FateData = __webpack_require__(9865)
-const {FateTypeString} = __webpack_require__(4265)
-
-const toString = (data) => {
-    if (data instanceof Uint8Array) {
-        const decoder = new TextDecoder()
-        return decoder.decode(data)
-    }
-
-    return data.toString()
-}
-
-class FateString extends FateData {
-    constructor(value) {
-        super('string')
-
-        this._value = toString(value)
-    }
-
-    get type() {
-        return FateTypeString()
-    }
-
-    toString() {
-        return this._value
-    }
-
-    valueOf() {
-        return this._value
-    }
-}
-
-module.exports = FateString
-
-
-/***/ }),
-
-/***/ 6878:
-/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
-
-const FateData = __webpack_require__(9865)
-const {FateTypeTuple} = __webpack_require__(4265)
-
-const zipObject = (keys, values) => {
-    const reducer = (acc, k, i) => {
-        acc[k] = values[i]
-        return acc
-    }
-
-    return keys.reduce(reducer, {})
-}
-
-class FateTuple extends FateData {
-    constructor(valueTypes = [], items = []) {
-        super('tuple')
-
-        this._valueTypes = (valueTypes.hasOwnProperty('valueTypes')) ? valueTypes.valueTypes : valueTypes
-        this._type = Array.isArray(valueTypes) ? FateTypeTuple(valueTypes) : valueTypes
-        this._items = Array.from(items)
-    }
-
-    get valueTypes() {
-        return this._valueTypes
-    }
-
-    get type() {
-        return this._type
-    }
-
-    get size() {
-        return this._items.length
-    }
-
-    get items() {
-        return this._items
-    }
-
-    valueOf() {
-        return this.prepareItems(e => e.valueOf())
-    }
-
-    prepareItems(callback) {
-        const items = this._items.map(callback)
-
-        if (this._type.name === 'record') {
-            return zipObject(this._type.keys, items)
-        }
-
-        return items
-    }
-
-    accept(visitor) {
-        return visitor.visitTuple(this)
-    }
-}
-
-module.exports = FateTuple
-
-
-/***/ }),
-
-/***/ 2457:
-/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
-
-const FateData = __webpack_require__(9865)
-const {FateTypeVariant, FateTypeTuple, FateTypeInt} = __webpack_require__(4265)
-
-class FateVariant extends FateData {
-    constructor(arities, tag, value = [], valueTypes = [], variants = []) {
-        super('variant')
-
-        this.arities = Array.from(arities)
-        this._tag = tag
-
-        this._value = value
-        this._valueTypes = valueTypes
-
-        this._type = FateTypeVariant(variants)
-    }
-
-    get valueTypes() {
-        return this._valueTypes
-    }
-
-    get type() {
-        return this._type
-    }
-
-    get tag() {
-        return this._tag
-    }
-
-    get value() {
-        return this._value
-    }
-
-    get aritiesType() {
-        return FateTypeInt()
-    }
-
-    get variantType() {
-        return FateTypeTuple(this._valueTypes)
-    }
-
-    get variants() {
-        return this._type.variants
-    }
-
-    get variantName() {
-        if (this.variants.length === 0) {
-            return this.tag
-        }
-
-        const variant = this.variants[this.tag]
-
-        return Object.keys(variant)[0]
-    }
-
-    valueOf() {
-        if (this.variants.length === 0) {
-            return this
-        }
-
-        const value = this._value.map(e => e.valueOf())
-
-        return {
-            [this.variantName]: value
-        }
-    }
-
-    accept(visitor) {
-        return visitor.visitVariant(this)
-    }
-}
-
-module.exports = FateVariant
-
-
-/***/ }),
-
-/***/ 9713:
-/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
-
-const FateData = __webpack_require__(9865)
-const {FateTypeVoid} = __webpack_require__(4265)
-
-class FateVoid extends FateData {
-    constructor() {
-        super('void')
-
-        this._value = undefined
-    }
-
-    get value() {
-        return this._value
-    }
-
-    get type() {
-        return FateTypeVoid()
-    }
-
-    valueOf() {
-        return this._value
-    }
-}
-
-module.exports = FateVoid
-
-
-/***/ }),
-
-/***/ 333:
-/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
-
-const {Int2ByteArray, ByteArray2IntBE} = __webpack_require__(240)
-
-const CURVES = {
-    r: {
-        R: 1n << 256n,
-        N: 0x73eda753299d7d483339d80809a1d80553bda402fffe5bfeffffffff00000001n,
-    },
-    p: {
-        R: 1n << 384n,
-        /* eslint-disable-next-line max-len */
-        N: 0x1a0111ea397fe69a4b1ba7b6434bacd764774b84f38512bf6730d2a0f6b0f6241eabfffeb153ffffb9feffffffffaaabn,
-    }
-}
-
-const xgcd = (a, b) => {
-    if (b === 0n) {
-        return [1n, 0n, a]
-    }
-
-    const [x, y, d] = xgcd(b, a % b)
-
-    return [y, x - y * (a / b), d]
-}
-
-const invmod = (a, n) => {
-    const [X, _Y, _D] = xgcd(a, n)
-
-    // To ensure positive result
-    return (X + n) % n
-}
-
-// Scalar(a) = aR mod N
-const Int2MontBytes = (value, curveType) => {
-    const curve = CURVES[curveType]
-    const a = BigInt(value)
-    const m = (a * curve.R) % curve.N
-
-    return Int2ByteArray(m)
-}
-
-// a = ã · R^−1 mod N
-const MontBytes2Int = (value, curveType) => {
-    const curve = CURVES[curveType]
-    const a = ByteArray2IntBE(value)
-    const Rinv = invmod(curve.R, curve.N)
-
-    return (a * Rinv) % curve.N
-}
-
-module.exports = {
-    Int2MontBytes,
-    MontBytes2Int,
-}
-
-
-/***/ }),
-
-/***/ 381:
-/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
-
-const FormatError = __webpack_require__(722)
-
-// TODO consider using Buffer.from(<string>, 'hex') instead
-// TODO get rid of this ?
-// Int2ByteArray(BigInt('0x' + hex.join('')))
-const HexStringToByteArray = (str) => {
-    const match = str.match(/^(0x)?([a-f0-9]*)$/i)
-    if (!match) {
-        throw new FormatError(`Invalid hex string: ${str}`)
-    }
-
-    return new Uint8Array(match[2]
-        .split(/(.{1,2})/)
-        .filter(el => el)
-        .map(el => parseInt(el, 16)))
-}
-
-module.exports = HexStringToByteArray
-
-
-/***/ }),
-
-/***/ 240:
-/***/ ((module) => {
-
-const Int2ByteArray = (value) => {
-    const bigInt = BigInt(value)
-
-    if (bigInt < 256n) {
-        return new Uint8Array([Number(bigInt)])
-    }
-
-    return new Uint8Array([
-        ...Int2ByteArray(bigInt >> 8n),
-        Number(bigInt & 0xffn)
-    ])
-}
-
-const ByteArrayToHexArray = (data) => {
-    return [...data].map(x => x.toString(16).padStart(2, '0'))
-}
-
-const ByteArray2Int = (data) => {
-    const hex = ByteArrayToHexArray(data)
-
-    return BigInt('0x' + hex.join(''))
-}
-
-const ByteArray2IntBE = (data) => {
-    const hex = ByteArrayToHexArray(data).reverse()
-
-    return BigInt('0x' + hex.join(''))
-}
-
-const ByteArray2Hex = (data) => {
-    return ByteArrayToHexArray(data).join('')
-}
-
-module.exports = {
-    Int2ByteArray,
-    ByteArray2Int,
-    ByteArray2IntBE,
-    ByteArray2Hex,
-}
-
-
-/***/ }),
-
-/***/ 7138:
-/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
-
-const RLP = __webpack_require__(3485)
-const {Int2ByteArray, ByteArray2Int } = __webpack_require__(240)
-
-module.exports = {
-    encode(value) {
-        return new Uint8Array(RLP.encode(Int2ByteArray(value)))
-    },
-    decode(buffer) {
-        const decoded = RLP.decode(buffer, true)
-        return [ByteArray2Int(decoded.data), decoded.remainder]
-    }
-}
-
-
-/***/ }),
-
-/***/ 9475:
-/***/ ((module) => {
-
-const abs = (val) => {
-    return val > 0 ? val : val * -1n
-}
-
-module.exports = abs
-
-
-/***/ }),
-
-/***/ 4664:
-/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
-
-const InternalError = __webpack_require__(2966)
-
-const assert = (condition, message) => {
-    if (!condition) {
-        throw new InternalError(message)
-    }
-}
-
-module.exports = assert
-
-
-/***/ }),
-
-/***/ 2727:
-/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
-
-const bs58 = __webpack_require__(3783)
-const { addChecksum, getPayload } = __webpack_require__(8638)
-
-/**
- * Base58check encode given `input`
- * @param {Buffer} input - Data to encode
- * @return {String} Base58check encoded data
- */
-const encode = (input) => {
-    return bs58.encode(addChecksum(input))
-}
-
-/**
- * Base58check decode given `str`
- * @param {String} str - Data to decode
- * @return {Uint8Array} Base58check decoded data
- */
-const decode = (str) => {
-    return getPayload(bs58.decode(str))
-}
-
-module.exports = {
-    encode,
-    decode
-}
-
-
-/***/ }),
-
-/***/ 8638:
-/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
-
-const Sha256 = __webpack_require__(7499)
-const { Buffer } = __webpack_require__(9509)
-const FormatError = __webpack_require__(722)
-
-const sha256hash = (input) => {
-    return new Sha256().update(input).digest()
-}
-
-const checkSumFn = (payload) => {
-    return sha256hash(sha256hash(payload)).slice(0, 4)
-}
-
-const addChecksum = (payload) => {
-    const buffer = Buffer.from(payload)
-    const checksum = checkSumFn(payload)
-    return Buffer.concat([buffer, checksum], buffer.length + 4)
-}
-
-const getPayload = (payloadWithChecksumData) => {
-    const payloadWithChecksum = Buffer.from(payloadWithChecksumData)
-    const payload = payloadWithChecksum.slice(0, -4)
-    const checksum = payloadWithChecksum.slice(-4)
-    const newChecksum = checkSumFn(payload)
-
-    if (!checksum.equals(newChecksum)) {
-        throw new FormatError('Invalid checksum')
-    }
-
-    return new Uint8Array(payload)
-}
-
-/**
- * Base64check encode given `input`
- * @param {String|Uint8Array} input - Data to encode
- * @return {String} Base64check encoded data
- */
-const encode = (input) => {
-    return addChecksum(input).toString('base64')
-}
-
-/**
- * Base64check decode given `str`
- * @param {String} str - Data to decode
- * @return {Uint8Array} Base64check decoded data
- */
-const decode = (str) => {
-    const data = Buffer.from(str, 'base64')
-
-    return getPayload(data)
-}
-
-module.exports = {
-    addChecksum,
-    getPayload,
-    encode,
-    decode
-}
-
-
-/***/ }),
-
-/***/ 2665:
-/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
-
-const blake = __webpack_require__(8442)
-
-const HASH_BYTES = 32
-
-const hash = (name) => {
-    return Array.from(blake.blake2b(name, null, HASH_BYTES))
-}
-
-const symbolIdentifier = (funName) => {
-    // First 4 bytes of 32 bytes blake hash
-    return hash(funName).slice(0, 4)
-}
-
-module.exports = {
-    hash,
-    symbolIdentifier
-}
-
-
-/***/ }),
-
-/***/ 5675:
-/***/ ((module) => {
-
-module.exports = (arr, ...arrs) => {
-    return arr.map((val, i) => arrs.reduce((a, curr) => [...a, curr[i]], [val]))
-}
-
-
-/***/ }),
-
 /***/ 8442:
 /***/ ((module, __unused_webpack_exports, __webpack_require__) => {
 
@@ -11508,7 +7227,7 @@ function verifyMessage(message, signature, address) {
 /**
  * Check key pair for validity
  *
- * Sign a message, and then verifying that signature
+ * Signs a message, and then verifies that signature
  * @param privateKey - Private key to verify
  * @param publicKey - Public key to verify as hex string
  * @returns Valid?
@@ -11595,6 +7314,7 @@ let VmVersion = /*#__PURE__*/function (VmVersion) {
   VmVersion[VmVersion["Fate"] = 5] = "Fate";
   VmVersion[VmVersion["SophiaImprovementsLima"] = 6] = "SophiaImprovementsLima";
   VmVersion[VmVersion["Fate2"] = 7] = "Fate2";
+  VmVersion[VmVersion["Fate3"] = 8] = "Fate3";
   return VmVersion;
 }({});
 
@@ -11694,7 +7414,7 @@ const ProtocolToVmAbi = {
   },
   [ConsensusProtocolVersion.Ceres]: {
     'contract-create': {
-      vmVersion: [VmVersion.Fate2],
+      vmVersion: [VmVersion.Fate3],
       abiVersion: [AbiVersion.Fate]
     },
     'contract-call': {
@@ -12055,7 +7775,7 @@ function isAuctionName(name) {
 
 /* harmony default export */ const u_int = ({
   serialize(value) {
-    if (+value < 0) throw new ArgumentError('value', 'greater or equal to 0', value);
+    if (Number(value) < 0) throw new ArgumentError('value', 'greater or equal to 0', value);
     return toBytes(value, true);
   },
   deserialize(value) {
@@ -12315,7 +8035,7 @@ function calculateMinFee(rebuildTx, unpackTx, buildTx) {
     const value = new (external_bignumber_js_default())(_value !== null && _value !== void 0 ? _value : minFee);
     if (minFee.gt(value)) {
       if (_pickBiggerFee === true) return minFee.toFixed();
-      throw new IllegalArgumentError(`Fee ${value.toString()} must be bigger then ${minFee}`);
+      throw new IllegalArgumentError(`Fee ${value.toString()} must be bigger than ${minFee}`);
     }
     return value.toFixed();
   }
@@ -12530,7 +8250,7 @@ function calculateGasLimitMax(gasMax, rebuildTx, unpackTx, buildTx) {
   ...coin_amount,
   serializeAettos(value = MIN_GAS_PRICE.toString()) {
     if (+value < MIN_GAS_PRICE) {
-      throw new IllegalArgumentError(`Gas price ${value.toString()} must be bigger then ${MIN_GAS_PRICE}`);
+      throw new IllegalArgumentError(`Gas price ${value.toString()} must be bigger than ${MIN_GAS_PRICE}`);
     }
     return value;
   }
@@ -13519,10 +9239,10 @@ const genRequestQueuesPolicy = () => {
         request.headers.delete('__queue');
         const getResponse = async () => next(request);
         if (key == null) return getResponse();
-        const req = ((_requestQueues$get = requestQueues.get(key)) !== null && _requestQueues$get !== void 0 ? _requestQueues$get : Promise.resolve()).then(getResponse, getResponse);
-        // TODO: remove after fixing https://github.com/aeternity/aeternity/issues/3803
+        const req = ((_requestQueues$get = requestQueues.get(key)) !== null && _requestQueues$get !== void 0 ? _requestQueues$get : Promise.resolve()).then(getResponse);
+        // TODO: remove pause after fixing https://github.com/aeternity/aeternity/issues/3803
         // gap to ensure that node won't reject the nonce
-        requestQueues.set(key, req.then(async () => pause(750)));
+        requestQueues.set(key, req.then(async () => pause(750), () => {}));
         return req;
       }
     },
@@ -13607,7 +9327,7 @@ const genRetryOnFailurePolicy = (retryCount, retryOverallDelay) => ({
   policy: {
     name: 'retry-on-failure',
     async sendRequest(request, next) {
-      const statusesToNotRetry = [200, 400, 403];
+      const statusesToNotRetry = [200, 400, 403, 500];
       const intervals = new Array(retryCount).fill(0).map((_, idx) => ((idx + 1) / retryCount) ** 2);
       const intervalSum = intervals.reduce((a, b) => a + b);
       const intervalsInMs = intervals.map(el => el / intervalSum * retryOverallDelay);
@@ -19088,6 +14808,8 @@ function Node_classPrivateMethodGet(receiver, privateSet, fn) { if (!privateSet.
 
 
 
+
+
 const bigIntPropertyNames = ['balance', 'queryFee', 'fee', 'amount', 'nameFee', 'channelAmount', 'initiatorAmount', 'responderAmount', 'channelReserve', 'initiatorAmountFinal', 'responderAmountFinal', 'gasPrice', 'deposit'];
 const numberPropertyNames = ['time', 'gas', 'gasUsed', 'nameSalt', 'nonce', 'nextNonce', 'height', 'blockHeight', 'topBlockHeight', 'ttl', 'nameTtl', 'clientTtl', 'inbound', 'outbound', 'peerCount', 'pendingTransactionsCount', 'effectiveAtHeight', 'version', 'solutions', 'round'];
 var _mapData = /*#__PURE__*/new WeakSet();
@@ -19137,7 +14859,7 @@ class Node_Node extends NodeTransformed {
   /**
    * @param url - Url for node API
    * @param options - Options
-   * @param options.ignoreVersion - Don't check node version
+   * @param options.ignoreVersion - Don't ensure that the node is supported
    * @param options.retryCount - Amount of extra requests to do in case of failure
    * @param options.retryOverallDelay - Time in ms to wait between all retries
    */
@@ -19180,7 +14902,7 @@ class Node_Node extends NodeTransformed {
   }
   async getNodeInfo() {
     const {
-      nodeVersion: version,
+      nodeVersion,
       networkId: nodeNetworkId,
       protocols,
       topBlockHeight
@@ -19191,10 +14913,17 @@ class Node_Node extends NodeTransformed {
       effectiveAtHeight: -1,
       version: 0
     }).version;
+    if (ConsensusProtocolVersion[consensusProtocolVersion] == null) {
+      const version = consensusProtocolVersion.toString();
+      const versions = Object.values(ConsensusProtocolVersion).filter(el => typeof el === 'number').map(el => +el);
+      const geVersion = Math.min(...versions).toString();
+      const ltVersion = (Math.max(...versions) + 1).toString();
+      throw new UnsupportedVersionError('consensus protocol', version, geVersion, ltVersion);
+    }
     return {
       url: this.$host,
       nodeNetworkId,
-      version,
+      version: nodeVersion,
       consensusProtocolVersion
     };
   }
@@ -19324,22 +15053,12 @@ class AccountBase {
    * Account address
    */
 }
-// EXTERNAL MODULE: ./node_modules/@aeternity/aepp-calldata/src/ContractByteArrayEncoder.js
-var ContractByteArrayEncoder = __webpack_require__(8323);
-var ContractByteArrayEncoder_default = /*#__PURE__*/__webpack_require__.n(ContractByteArrayEncoder);
-// EXTERNAL MODULE: ./node_modules/@aeternity/aepp-calldata/src/AciTypeResolver.js
-var AciTypeResolver = __webpack_require__(6477);
-var AciTypeResolver_default = /*#__PURE__*/__webpack_require__.n(AciTypeResolver);
+// EXTERNAL MODULE: external "@aeternity/aepp-calldata"
+var aepp_calldata_ = __webpack_require__(7946);
 // EXTERNAL MODULE: external "canonicalize"
 var external_canonicalize_ = __webpack_require__(6667);
 var external_canonicalize_default = /*#__PURE__*/__webpack_require__.n(external_canonicalize_);
 ;// CONCATENATED MODULE: ./src/utils/typed-data.ts
-// js extension is required for mjs build
-// @ts-expect-error see https://github.com/aeternity/aepp-calldata-js/issues/216
-// eslint-disable-next-line import/extensions
-
-// @ts-expect-error see https://github.com/aeternity/aepp-calldata-js/issues/216
-// eslint-disable-next-line import/extensions
 
 
 
@@ -19356,22 +15075,6 @@ function hashJson(data) {
 
 // TODO: move this type to calldata library https://github.com/aeternity/aepp-calldata-js/issues/215
 // based on https://github.com/aeternity/aepp-calldata-js/blob/82b5a98f9b308482627da8d7484d213e9cf87151/src/AciTypeResolver.js#L129
-// TODO: replace with api on calldata side https://github.com/aeternity/aepp-calldata-js/issues/216
-function encodeFateValue(value, aci) {
-  const contractByteArrayEncoder = new (ContractByteArrayEncoder_default())();
-  const aciTypeResolver = new (AciTypeResolver_default())([]);
-  aciTypeResolver.isCustomType = () => false;
-  return contractByteArrayEncoder.encode(aciTypeResolver.resolveType(aci), value);
-}
-
-// TODO: replace with api on calldata side https://github.com/aeternity/aepp-calldata-js/issues/216
-function decodeFateValue(value, aci) {
-  const contractByteArrayEncoder = new (ContractByteArrayEncoder_default())();
-  const aciTypeResolver = new (AciTypeResolver_default())([]);
-  aciTypeResolver.isCustomType = () => false;
-  return contractByteArrayEncoder.decodeWithType(value, aciTypeResolver.resolveType(aci));
-}
-
 /**
  * Hashes domain object, can be used to inline domain hash to contract source code
  */
@@ -19399,7 +15102,9 @@ function hashDomain(domain) {
       }
     }]
   };
-  return hash(decode(encodeFateValue(domain, domainAci)));
+  const domainType = new aepp_calldata_.TypeResolver().resolveType(domainAci, {});
+  const fateValue = new aepp_calldata_.ContractByteArrayEncoder().encodeWithType(domain, domainType);
+  return hash(decode(fateValue));
 }
 function hashTypedData(data, aci, domain) {
   return hash(concatBuffers([messagePrefixLength, new Uint8Array([0]), hashDomain(domain), hashJson(aci), hash(decode(data))]));
@@ -20980,8 +16685,6 @@ async function aensBid(name, nameFee, options) {
     nameFee
   });
 }
-// EXTERNAL MODULE: external "@aeternity/aepp-calldata"
-var aepp_calldata_ = __webpack_require__(7946);
 ;// CONCATENATED MODULE: ./src/contract/Contract.ts
 
 
@@ -21004,6 +16707,7 @@ function Contract_classPrivateMethodGet(receiver, privateSet, fn) { if (!private
 
 
 
+
 var _getCallResult = /*#__PURE__*/new WeakSet();
 var _sendAndProcess = /*#__PURE__*/new WeakSet();
 var _getFunctionAci = /*#__PURE__*/new WeakSet();
@@ -21023,7 +16727,7 @@ var _aciContract = /*#__PURE__*/new WeakMap();
  * const staticCallResult = await contractIns.$call('setState', [123], { callStatic: true })
  * ```
  * Also you can call contract like: `await contractIns.setState(123, options)`
- * Then sdk decide to make on-chain or static call(dry-run API) transaction based on function is
+ * Then sdk decide to make on-chain or static call (dry-run API) transaction based on function is
  * stateful or not
  */
 class Contract {
@@ -21111,7 +16815,6 @@ class Contract {
       code: this.$options.bytecode,
       ownerId
     });
-    this.$options.address = buildContractIdByContractTx(tx);
     const {
       hash,
       ...other
@@ -21119,6 +16822,7 @@ class Contract {
       ...opt,
       onAccount: opt.onAccount
     });
+    this.$options.address = buildContractIdByContractTx(tx);
     return {
       ...other,
       ...(((_other$result = other.result) === null || _other$result === void 0 ? void 0 : _other$result.log) != null && {
@@ -21160,7 +16864,7 @@ class Contract {
     } = opt;
     if (fn == null) throw new MissingFunctionNameError();
     if (fn === 'init' && callStatic !== true) throw new InvalidMethodInvocationError('"init" can be called only via dryRun');
-    if (fn !== 'init' && opt.amount != null && +opt.amount > 0 && !fnAci.payable) {
+    if (fn !== 'init' && opt.amount != null && Number(opt.amount) > 0 && !fnAci.payable) {
       throw new NotPayableFunctionError(opt.amount, fn);
     }
     let callerId;
@@ -21174,12 +16878,21 @@ class Contract {
     }
     const callData = this._calldata.encode(this._name, fn, params);
     if (callStatic === true) {
-      if (opt.nonce == null && top != null) {
-        const topKey = typeof top === 'number' ? 'height' : 'hash';
-        opt.nonce = (await getAccount(callerId, {
-          [topKey]: top,
+      if (opt.nonce == null) {
+        const topOption = top != null && {
+          [typeof top === 'number' ? 'height' : 'hash']: top
+        };
+        const account = await getAccount(callerId, {
+          ...topOption,
           onNode
-        })).nonce + 1;
+        }).catch(error => {
+          if (!isAccountNotFoundError(error)) throw error;
+          return {
+            kind: 'basic',
+            nonce: 0
+          };
+        });
+        opt.nonce = account.kind === 'generalized' ? 0 : account.nonce + 1;
       }
       const txOpt = {
         ...opt,
@@ -32072,7 +27785,7 @@ class Middleware_Middleware extends MiddlewareTransformed {
   /**
    * @param url - Url for middleware API
    * @param options - Options
-   * @param options.ignoreVersion - Don't check node version
+   * @param options.ignoreVersion - Don't ensure that the middleware is supported
    * @param options.retryCount - Amount of extra requests to do in case of failure
    * @param options.retryOverallDelay - Time in ms to wait between all retries
    */
@@ -32287,12 +28000,17 @@ class BrowserWindowMessageConnection extends BrowserConnection {
     const wallet = {
       info: params,
       getConnection() {
-        const isExtension = params.type === 'extension';
         return new BrowserWindowMessageConnection({
-          sendDirection: isExtension ? MESSAGE_DIRECTION.to_waellet : undefined,
-          receiveDirection: isExtension ? MESSAGE_DIRECTION.to_aepp : undefined,
           target: source,
-          origin: isExtension ? window.origin : params.origin
+          ...(params.type === 'extension' ? {
+            sendDirection: MESSAGE_DIRECTION.to_waellet,
+            receiveDirection: MESSAGE_DIRECTION.to_aepp,
+            ...(window.origin !== 'null' && {
+              origin: window.origin
+            })
+          } : {
+            origin: params.origin
+          })
         });
       }
     };
@@ -32361,11 +28079,11 @@ class BrowserRuntimeConnection extends BrowserConnection {
 
 
 
+
 /**
  * @category exception
  * @deprecated this exception is not thrown anymore
  */
-// eslint-disable-next-line import/prefer-default-export
 class RpcBroadcastError extends RpcError {
   constructor(data) {
     super('Broadcast failed');
@@ -32380,6 +28098,22 @@ class RpcBroadcastError extends RpcError {
  */
 defineProperty_default()(RpcBroadcastError, "code", 3);
 const NAME_BID_MAX_LENGTH = 12; // # this is the max length for a domain to be part of a bid
+
+/**
+ * @deprecated use ContractByteArrayEncoder:encodeWithType from \@aeternity/aepp-calldata
+ */
+function encodeFateValue(value, aci) {
+  const valueType = new aepp_calldata_.TypeResolver().resolveType(aci, {});
+  return new aepp_calldata_.ContractByteArrayEncoder().encodeWithType(value, valueType);
+}
+
+/**
+ * @deprecated use ContractByteArrayEncoder:decodeWithType from \@aeternity/aepp-calldata
+ */
+function decodeFateValue(value, aci) {
+  const valueType = new aepp_calldata_.TypeResolver().resolveType(aci, {});
+  return new aepp_calldata_.ContractByteArrayEncoder().decodeWithType(value, valueType);
+}
 ;// CONCATENATED MODULE: ./src/index-browser.ts
 
 
@@ -32461,13 +28195,18 @@ const getPackagePath = () => {
 };
 
 /**
- * A wrapper around aesophia_cli, available only in Node.js
- * Assumes that `escript` is available in PATH.
+ * A wrapper around aesophia_cli, available only in Node.js.
+ * Requires Erlang installed, assumes that `escript` is available in PATH.
  */
 var _path = /*#__PURE__*/new WeakMap();
 var _ensureCompatibleVersion = /*#__PURE__*/new WeakMap();
 var _run = /*#__PURE__*/new WeakSet();
 class CompilerCli extends CompilerBase {
+  /**
+   * @param compilerPath - A path to aesophia_cli binary, by default uses the integrated one
+   * @param options - Options
+   * @param options.ignoreVersion - Don't ensure that the compiler is supported
+   */
   constructor(compilerPath = (0,external_path_namespaceObject.resolve)(getPackagePath(), './bin/aesophia_cli'), {
     ignoreVersion
   } = {}) {