diff --git a/packages/bizinikiwi-bindings/LICENSE b/packages/bizinikiwi-bindings/LICENSE new file mode 100644 index 0000000..e7c9b1a --- /dev/null +++ b/packages/bizinikiwi-bindings/LICENSE @@ -0,0 +1,21 @@ +MIT License + +Copyright (c) 2023 Josep M Sobrepere + +Permission is hereby granted, free of charge, to any person obtaining a copy +of this software and associated documentation files (the "Software"), to deal +in the Software without restriction, including without limitation the rights +to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +copies of the Software, and to permit persons to whom the Software is +furnished to do so, subject to the following conditions: + +The above copyright notice and this permission notice shall be included in all +copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +SOFTWARE. diff --git a/packages/bizinikiwi-bindings/README.md b/packages/bizinikiwi-bindings/README.md new file mode 100644 index 0000000..6272526 --- /dev/null +++ b/packages/bizinikiwi-bindings/README.md @@ -0,0 +1 @@ +# @polkadot-api/substrate-bindings diff --git a/packages/bizinikiwi-bindings/dist/esm/codecs/blockHeader.mjs b/packages/bizinikiwi-bindings/dist/esm/codecs/blockHeader.mjs new file mode 100644 index 0000000..0cd6cfb --- /dev/null +++ b/packages/bizinikiwi-bindings/dist/esm/codecs/blockHeader.mjs @@ -0,0 +1,45 @@ +import { enhanceCodec, Bytes, _void } from 'scale-ts'; +import '../utils/ss58-util.mjs'; +import './scale/Binary.mjs'; +import './scale/bitSequence.mjs'; +import './scale/char.mjs'; +import { compactNumber } from './scale/compact.mjs'; +import { Hex } from './scale/Hex.mjs'; +import './scale/fixed-str.mjs'; +import { Variant } from './scale/Variant.mjs'; +import './scale/ethAccount.mjs'; +import { Struct, Vector } from './scale/shaped.mjs'; +import './scale/BitSeq.mjs'; + +const textEncoder$1 = new TextEncoder(); +const textDecoder = new TextDecoder(); +const fourChars = enhanceCodec( + Bytes(4), + textEncoder$1.encode.bind(textEncoder$1), + textDecoder.decode.bind(textDecoder) +); +const diggestVal = Struct({ + engine: fourChars, + payload: Hex() +}); +const diggest = Variant( + { + other: Bytes(), + consensus: diggestVal, + seal: diggestVal, + preRuntime: diggestVal, + runtimeUpdated: _void + }, + [0, 4, 5, 6, 8] +); +const hex32$1 = Hex(32); +const blockHeader = Struct({ + parentHash: hex32$1, + number: compactNumber, + stateRoot: hex32$1, + extrinsicRoot: hex32$1, + digests: Vector(diggest) +}); + +export { blockHeader }; +//# sourceMappingURL=blockHeader.mjs.map diff --git a/packages/bizinikiwi-bindings/dist/esm/codecs/blockHeader.mjs.map b/packages/bizinikiwi-bindings/dist/esm/codecs/blockHeader.mjs.map new file mode 100644 index 0000000..f90ba8b --- /dev/null +++ b/packages/bizinikiwi-bindings/dist/esm/codecs/blockHeader.mjs.map @@ -0,0 +1 @@ +{"version":3,"file":"blockHeader.mjs","sources":["../../../src/codecs/blockHeader.ts"],"sourcesContent":["import {\n Bytes,\n CodecType,\n Struct,\n Vector,\n _void,\n enhanceCodec,\n Hex,\n Variant,\n compactNumber,\n} from \"./scale\"\n\nconst textEncoder = new TextEncoder()\nconst textDecoder = new TextDecoder()\n\nconst fourChars = enhanceCodec(\n Bytes(4),\n textEncoder.encode.bind(textEncoder),\n textDecoder.decode.bind(textDecoder),\n)\n\nconst diggestVal = Struct({\n engine: fourChars,\n payload: Hex(),\n})\n\nconst diggest = Variant(\n {\n other: Bytes(),\n consensus: diggestVal,\n seal: diggestVal,\n preRuntime: diggestVal,\n runtimeUpdated: _void,\n },\n [0, 4, 5, 6, 8],\n)\n\nconst hex32 = Hex(32)\nexport const blockHeader = Struct({\n parentHash: hex32,\n number: compactNumber,\n stateRoot: hex32,\n extrinsicRoot: hex32,\n digests: Vector(diggest),\n})\n\nexport type BlockHeader = CodecType\n"],"names":["textEncoder","hex32"],"mappings":";;;;;;;;;;;;;AAYA,MAAMA,aAAA,GAAc,IAAI,WAAA,EAAY;AACpC,MAAM,WAAA,GAAc,IAAI,WAAA,EAAY;AAEpC,MAAM,SAAA,GAAY,YAAA;AAAA,EAChB,MAAM,CAAC,CAAA;AAAA,EACPA,aAAA,CAAY,MAAA,CAAO,IAAA,CAAKA,aAAW,CAAA;AAAA,EACnC,WAAA,CAAY,MAAA,CAAO,IAAA,CAAK,WAAW;AACrC,CAAA;AAEA,MAAM,aAAa,MAAA,CAAO;AAAA,EACxB,MAAA,EAAQ,SAAA;AAAA,EACR,SAAS,GAAA;AACX,CAAC,CAAA;AAED,MAAM,OAAA,GAAU,OAAA;AAAA,EACd;AAAA,IACE,OAAO,KAAA,EAAM;AAAA,IACb,SAAA,EAAW,UAAA;AAAA,IACX,IAAA,EAAM,UAAA;AAAA,IACN,UAAA,EAAY,UAAA;AAAA,IACZ,cAAA,EAAgB;AAAA,GAClB;AAAA,EACA,CAAC,CAAA,EAAG,CAAA,EAAG,CAAA,EAAG,GAAG,CAAC;AAChB,CAAA;AAEA,MAAMC,OAAA,GAAQ,IAAI,EAAE,CAAA;AACb,MAAM,cAAc,MAAA,CAAO;AAAA,EAChC,UAAA,EAAYA,OAAA;AAAA,EACZ,MAAA,EAAQ,aAAA;AAAA,EACR,SAAA,EAAWA,OAAA;AAAA,EACX,aAAA,EAAeA,OAAA;AAAA,EACf,OAAA,EAAS,OAAO,OAAO;AACzB,CAAC;;;;"} \ No newline at end of file diff --git a/packages/bizinikiwi-bindings/dist/esm/codecs/metadata/deprecation.mjs b/packages/bizinikiwi-bindings/dist/esm/codecs/metadata/deprecation.mjs new file mode 100644 index 0000000..74c12ca --- /dev/null +++ b/packages/bizinikiwi-bindings/dist/esm/codecs/metadata/deprecation.mjs @@ -0,0 +1,28 @@ +import { Enum, Struct, _void, Option, str, Vector, u8 } from 'scale-ts'; + +const itemDeprecation = Enum({ + NotDeprecated: _void, + DeprecatedWithoutNote: _void, + Deprecated: Struct({ + note: str, + since: Option(str) + }) +}); +const variantDeprecation = Vector( + Struct({ + index: u8, + deprecation: Enum( + { + DeprecatedWithoutNote: _void, + Deprecated: Struct({ + note: str, + since: Option(str) + }) + }, + [1, 2] + ) + }) +); + +export { itemDeprecation, variantDeprecation }; +//# sourceMappingURL=deprecation.mjs.map diff --git a/packages/bizinikiwi-bindings/dist/esm/codecs/metadata/deprecation.mjs.map b/packages/bizinikiwi-bindings/dist/esm/codecs/metadata/deprecation.mjs.map new file mode 100644 index 0000000..1bb9be9 --- /dev/null +++ b/packages/bizinikiwi-bindings/dist/esm/codecs/metadata/deprecation.mjs.map @@ -0,0 +1 @@ +{"version":3,"file":"deprecation.mjs","sources":["../../../../src/codecs/metadata/deprecation.ts"],"sourcesContent":["import { _void, Enum, Option, str, Struct, u8, Vector } from \"scale-ts\"\n\nexport const itemDeprecation = Enum({\n NotDeprecated: _void,\n DeprecatedWithoutNote: _void,\n Deprecated: Struct({\n note: str,\n since: Option(str),\n }),\n})\n\nexport const variantDeprecation = Vector(\n Struct({\n index: u8,\n deprecation: Enum(\n {\n DeprecatedWithoutNote: _void,\n Deprecated: Struct({\n note: str,\n since: Option(str),\n }),\n },\n [1, 2],\n ),\n }),\n)\n"],"names":[],"mappings":";;AAEO,MAAM,kBAAkB,IAAA,CAAK;AAAA,EAClC,aAAA,EAAe,KAAA;AAAA,EACf,qBAAA,EAAuB,KAAA;AAAA,EACvB,YAAY,MAAA,CAAO;AAAA,IACjB,IAAA,EAAM,GAAA;AAAA,IACN,KAAA,EAAO,OAAO,GAAG;AAAA,GAClB;AACH,CAAC;AAEM,MAAM,kBAAA,GAAqB,MAAA;AAAA,EAChC,MAAA,CAAO;AAAA,IACL,KAAA,EAAO,EAAA;AAAA,IACP,WAAA,EAAa,IAAA;AAAA,MACX;AAAA,QACE,qBAAA,EAAuB,KAAA;AAAA,QACvB,YAAY,MAAA,CAAO;AAAA,UACjB,IAAA,EAAM,GAAA;AAAA,UACN,KAAA,EAAO,OAAO,GAAG;AAAA,SAClB;AAAA,OACH;AAAA,MACA,CAAC,GAAG,CAAC;AAAA;AACP,GACD;AACH;;;;"} \ No newline at end of file diff --git a/packages/bizinikiwi-bindings/dist/esm/codecs/metadata/docs.mjs b/packages/bizinikiwi-bindings/dist/esm/codecs/metadata/docs.mjs new file mode 100644 index 0000000..55cb995 --- /dev/null +++ b/packages/bizinikiwi-bindings/dist/esm/codecs/metadata/docs.mjs @@ -0,0 +1,6 @@ +import { Vector, str } from 'scale-ts'; + +const docs = Vector(str); + +export { docs }; +//# sourceMappingURL=docs.mjs.map diff --git a/packages/bizinikiwi-bindings/dist/esm/codecs/metadata/docs.mjs.map b/packages/bizinikiwi-bindings/dist/esm/codecs/metadata/docs.mjs.map new file mode 100644 index 0000000..e4e939e --- /dev/null +++ b/packages/bizinikiwi-bindings/dist/esm/codecs/metadata/docs.mjs.map @@ -0,0 +1 @@ +{"version":3,"file":"docs.mjs","sources":["../../../../src/codecs/metadata/docs.ts"],"sourcesContent":["import { Vector, str } from \"scale-ts\"\n\nexport const docs = Vector(str)\n"],"names":[],"mappings":";;AAEO,MAAM,IAAA,GAAO,OAAO,GAAG;;;;"} \ No newline at end of file diff --git a/packages/bizinikiwi-bindings/dist/esm/codecs/metadata/lookup.mjs b/packages/bizinikiwi-bindings/dist/esm/codecs/metadata/lookup.mjs new file mode 100644 index 0000000..a17220d --- /dev/null +++ b/packages/bizinikiwi-bindings/dist/esm/codecs/metadata/lookup.mjs @@ -0,0 +1,72 @@ +import { compactNumber } from '../scale/compact.mjs'; +import { Option, str, Enum, _void, Vector, Struct, u32, u8 } from 'scale-ts'; +import { docs } from './docs.mjs'; + +const oStr = Option(str); +const primitive = Enum({ + bool: _void, + char: _void, + str: _void, + u8: _void, + u16: _void, + u32: _void, + u64: _void, + u128: _void, + u256: _void, + i8: _void, + i16: _void, + i32: _void, + i64: _void, + i128: _void, + i256: _void +}); +const fields = Vector( + Struct({ + name: oStr, + type: compactNumber, + typeName: oStr, + docs + }) +); +const arr = Struct({ + len: u32, + type: compactNumber +}); +const bitSequence = Struct({ + bitStoreType: compactNumber, + bitOrderType: compactNumber +}); +const variant = Vector( + Struct({ + name: str, + fields, + index: u8, + docs + }) +); +const def = Enum({ + composite: fields, + variant, + sequence: compactNumber, + array: arr, + tuple: Vector(compactNumber), + primitive, + compact: compactNumber, + bitSequence +}); +const param = Struct({ + name: str, + type: Option(compactNumber) +}); +const params = Vector(param); +const entry = Struct({ + id: compactNumber, + path: docs, + params, + def, + docs +}); +const lookup = Vector(entry); + +export { lookup }; +//# sourceMappingURL=lookup.mjs.map diff --git a/packages/bizinikiwi-bindings/dist/esm/codecs/metadata/lookup.mjs.map b/packages/bizinikiwi-bindings/dist/esm/codecs/metadata/lookup.mjs.map new file mode 100644 index 0000000..2486617 --- /dev/null +++ b/packages/bizinikiwi-bindings/dist/esm/codecs/metadata/lookup.mjs.map @@ -0,0 +1 @@ +{"version":3,"file":"lookup.mjs","sources":["../../../../src/codecs/metadata/lookup.ts"],"sourcesContent":["import { compactNumber } from \"../scale/compact\"\nimport {\n CodecType,\n Enum,\n Option,\n Struct,\n Vector,\n _void,\n str,\n u32,\n u8,\n} from \"scale-ts\"\nimport { docs } from \"./docs\"\n\nconst oStr = Option(str)\n\nconst primitive = Enum({\n bool: _void,\n char: _void,\n str: _void,\n u8: _void,\n u16: _void,\n u32: _void,\n u64: _void,\n u128: _void,\n u256: _void,\n i8: _void,\n i16: _void,\n i32: _void,\n i64: _void,\n i128: _void,\n i256: _void,\n})\n\nconst fields = Vector(\n Struct({\n name: oStr,\n type: compactNumber,\n typeName: oStr,\n docs,\n }),\n)\n\nconst arr = Struct({\n len: u32,\n type: compactNumber,\n})\n\nconst bitSequence = Struct({\n bitStoreType: compactNumber,\n bitOrderType: compactNumber,\n})\n\nconst variant = Vector(\n Struct({\n name: str,\n fields,\n index: u8,\n docs,\n }),\n)\n\nconst def = Enum({\n composite: fields,\n variant,\n sequence: compactNumber,\n array: arr,\n tuple: Vector(compactNumber),\n primitive,\n compact: compactNumber,\n bitSequence,\n})\n\nconst param = Struct({\n name: str,\n type: Option(compactNumber),\n})\nconst params = Vector(param)\n\nconst entry = Struct({\n id: compactNumber,\n path: docs,\n params,\n def,\n docs,\n})\n\nexport const lookup = Vector(entry)\nexport type V14Lookup = CodecType\n"],"names":[],"mappings":";;;;AAcA,MAAM,IAAA,GAAO,OAAO,GAAG,CAAA;AAEvB,MAAM,YAAY,IAAA,CAAK;AAAA,EACrB,IAAA,EAAM,KAAA;AAAA,EACN,IAAA,EAAM,KAAA;AAAA,EACN,GAAA,EAAK,KAAA;AAAA,EACL,EAAA,EAAI,KAAA;AAAA,EACJ,GAAA,EAAK,KAAA;AAAA,EACL,GAAA,EAAK,KAAA;AAAA,EACL,GAAA,EAAK,KAAA;AAAA,EACL,IAAA,EAAM,KAAA;AAAA,EACN,IAAA,EAAM,KAAA;AAAA,EACN,EAAA,EAAI,KAAA;AAAA,EACJ,GAAA,EAAK,KAAA;AAAA,EACL,GAAA,EAAK,KAAA;AAAA,EACL,GAAA,EAAK,KAAA;AAAA,EACL,IAAA,EAAM,KAAA;AAAA,EACN,IAAA,EAAM;AACR,CAAC,CAAA;AAED,MAAM,MAAA,GAAS,MAAA;AAAA,EACb,MAAA,CAAO;AAAA,IACL,IAAA,EAAM,IAAA;AAAA,IACN,IAAA,EAAM,aAAA;AAAA,IACN,QAAA,EAAU,IAAA;AAAA,IACV;AAAA,GACD;AACH,CAAA;AAEA,MAAM,MAAM,MAAA,CAAO;AAAA,EACjB,GAAA,EAAK,GAAA;AAAA,EACL,IAAA,EAAM;AACR,CAAC,CAAA;AAED,MAAM,cAAc,MAAA,CAAO;AAAA,EACzB,YAAA,EAAc,aAAA;AAAA,EACd,YAAA,EAAc;AAChB,CAAC,CAAA;AAED,MAAM,OAAA,GAAU,MAAA;AAAA,EACd,MAAA,CAAO;AAAA,IACL,IAAA,EAAM,GAAA;AAAA,IACN,MAAA;AAAA,IACA,KAAA,EAAO,EAAA;AAAA,IACP;AAAA,GACD;AACH,CAAA;AAEA,MAAM,MAAM,IAAA,CAAK;AAAA,EACf,SAAA,EAAW,MAAA;AAAA,EACX,OAAA;AAAA,EACA,QAAA,EAAU,aAAA;AAAA,EACV,KAAA,EAAO,GAAA;AAAA,EACP,KAAA,EAAO,OAAO,aAAa,CAAA;AAAA,EAC3B,SAAA;AAAA,EACA,OAAA,EAAS,aAAA;AAAA,EACT;AACF,CAAC,CAAA;AAED,MAAM,QAAQ,MAAA,CAAO;AAAA,EACnB,IAAA,EAAM,GAAA;AAAA,EACN,IAAA,EAAM,OAAO,aAAa;AAC5B,CAAC,CAAA;AACD,MAAM,MAAA,GAAS,OAAO,KAAK,CAAA;AAE3B,MAAM,QAAQ,MAAA,CAAO;AAAA,EACnB,EAAA,EAAI,aAAA;AAAA,EACJ,IAAA,EAAM,IAAA;AAAA,EACN,MAAA;AAAA,EACA,GAAA;AAAA,EACA;AACF,CAAC,CAAA;AAEM,MAAM,MAAA,GAAS,OAAO,KAAK;;;;"} \ No newline at end of file diff --git a/packages/bizinikiwi-bindings/dist/esm/codecs/metadata/metadata.mjs b/packages/bizinikiwi-bindings/dist/esm/codecs/metadata/metadata.mjs new file mode 100644 index 0000000..96b16e9 --- /dev/null +++ b/packages/bizinikiwi-bindings/dist/esm/codecs/metadata/metadata.mjs @@ -0,0 +1,59 @@ +import { createCodec, Struct, Enum, u32, Bytes, Option, Tuple, compact } from 'scale-ts'; +import { v14 } from './v14.mjs'; +import { v15 } from './v15.mjs'; +import { v16 } from './v16.mjs'; + +const unsupportedFn = () => { + throw new Error("Unsupported metadata version!"); +}; +const unsupported = createCodec( + unsupportedFn, + unsupportedFn +); +const metadata = Struct({ + magicNumber: u32, + metadata: Enum({ + v0: unsupported, + v1: unsupported, + v2: unsupported, + v3: unsupported, + v4: unsupported, + v5: unsupported, + v6: unsupported, + v7: unsupported, + v8: unsupported, + v9: unsupported, + v10: unsupported, + v11: unsupported, + v12: unsupported, + v13: unsupported, + v14, + v15, + v16 + }) +}); +const opaqueBytes = Bytes(); +const optionOpaque = Option(opaqueBytes); +const opaqueOpaqueBytes = Tuple(compact, opaqueBytes); +const decAnyMetadata = (input) => { + try { + return metadata.dec(input); + } catch (_) { + } + try { + return metadata.dec(optionOpaque.dec(input)); + } catch (_) { + } + try { + return metadata.dec(opaqueBytes.dec(input)); + } catch (_) { + } + try { + return metadata.dec(opaqueOpaqueBytes.dec(input)[1]); + } catch (_) { + } + throw null; +}; + +export { decAnyMetadata, metadata }; +//# sourceMappingURL=metadata.mjs.map diff --git a/packages/bizinikiwi-bindings/dist/esm/codecs/metadata/metadata.mjs.map b/packages/bizinikiwi-bindings/dist/esm/codecs/metadata/metadata.mjs.map new file mode 100644 index 0000000..bee5490 --- /dev/null +++ b/packages/bizinikiwi-bindings/dist/esm/codecs/metadata/metadata.mjs.map @@ -0,0 +1 @@ +{"version":3,"file":"metadata.mjs","sources":["../../../../src/codecs/metadata/metadata.ts"],"sourcesContent":["import {\n Bytes,\n type Codec,\n type CodecType,\n Enum,\n Option,\n Struct,\n Tuple,\n compact,\n createCodec,\n u32,\n} from \"scale-ts\"\nimport type { HexString } from \"../scale\"\nimport { v14 } from \"./v14\"\nimport { v15 } from \"./v15\"\nimport { v16 } from \"./v16\"\n\nconst unsupportedFn = () => {\n throw new Error(\"Unsupported metadata version!\")\n}\n\nconst unsupported = createCodec(\n unsupportedFn,\n unsupportedFn,\n) as unknown as Codec\n\nexport const metadata = Struct({\n magicNumber: u32,\n metadata: Enum({\n v0: unsupported,\n v1: unsupported,\n v2: unsupported,\n v3: unsupported,\n v4: unsupported,\n v5: unsupported,\n v6: unsupported,\n v7: unsupported,\n v8: unsupported,\n v9: unsupported,\n v10: unsupported,\n v11: unsupported,\n v12: unsupported,\n v13: unsupported,\n v14,\n v15,\n v16,\n }),\n})\nexport type Metadata = CodecType\n\nconst opaqueBytes = Bytes()\nconst optionOpaque = Option(opaqueBytes)\nconst opaqueOpaqueBytes = Tuple(compact, opaqueBytes)\n\nexport const decAnyMetadata = (\n input: Uint8Array | HexString,\n): CodecType => {\n try {\n return metadata.dec(input)\n } catch (_) {}\n\n // comes from metadata.metadata_at_version\n try {\n return metadata.dec(optionOpaque.dec(input)!)\n } catch (_) {}\n\n // comes from state.getMetadata\n try {\n return metadata.dec(opaqueBytes.dec(input))\n } catch (_) {}\n\n // comes from metadata.metadata\n try {\n return metadata.dec(opaqueOpaqueBytes.dec(input)[1])\n } catch (_) {}\n\n throw null\n}\n"],"names":[],"mappings":";;;;;AAiBA,MAAM,gBAAgB,MAAM;AAC1B,EAAA,MAAM,IAAI,MAAM,+BAA+B,CAAA;AACjD,CAAA;AAEA,MAAM,WAAA,GAAc,WAAA;AAAA,EAClB,aAAA;AAAA,EACA;AACF,CAAA;AAEO,MAAM,WAAW,MAAA,CAAO;AAAA,EAC7B,WAAA,EAAa,GAAA;AAAA,EACb,UAAU,IAAA,CAAK;AAAA,IACb,EAAA,EAAI,WAAA;AAAA,IACJ,EAAA,EAAI,WAAA;AAAA,IACJ,EAAA,EAAI,WAAA;AAAA,IACJ,EAAA,EAAI,WAAA;AAAA,IACJ,EAAA,EAAI,WAAA;AAAA,IACJ,EAAA,EAAI,WAAA;AAAA,IACJ,EAAA,EAAI,WAAA;AAAA,IACJ,EAAA,EAAI,WAAA;AAAA,IACJ,EAAA,EAAI,WAAA;AAAA,IACJ,EAAA,EAAI,WAAA;AAAA,IACJ,GAAA,EAAK,WAAA;AAAA,IACL,GAAA,EAAK,WAAA;AAAA,IACL,GAAA,EAAK,WAAA;AAAA,IACL,GAAA,EAAK,WAAA;AAAA,IACL,GAAA;AAAA,IACA,GAAA;AAAA,IACA;AAAA,GACD;AACH,CAAC;AAGD,MAAM,cAAc,KAAA,EAAM;AAC1B,MAAM,YAAA,GAAe,OAAO,WAAW,CAAA;AACvC,MAAM,iBAAA,GAAoB,KAAA,CAAM,OAAA,EAAS,WAAW,CAAA;AAE7C,MAAM,cAAA,GAAiB,CAC5B,KAAA,KAC+B;AAC/B,EAAA,IAAI;AACF,IAAA,OAAO,QAAA,CAAS,IAAI,KAAK,CAAA;AAAA,EAC3B,SAAS,CAAA,EAAG;AAAA,EAAC;AAGb,EAAA,IAAI;AACF,IAAA,OAAO,QAAA,CAAS,GAAA,CAAI,YAAA,CAAa,GAAA,CAAI,KAAK,CAAE,CAAA;AAAA,EAC9C,SAAS,CAAA,EAAG;AAAA,EAAC;AAGb,EAAA,IAAI;AACF,IAAA,OAAO,QAAA,CAAS,GAAA,CAAI,WAAA,CAAY,GAAA,CAAI,KAAK,CAAC,CAAA;AAAA,EAC5C,SAAS,CAAA,EAAG;AAAA,EAAC;AAGb,EAAA,IAAI;AACF,IAAA,OAAO,SAAS,GAAA,CAAI,iBAAA,CAAkB,IAAI,KAAK,CAAA,CAAE,CAAC,CAAC,CAAA;AAAA,EACrD,SAAS,CAAA,EAAG;AAAA,EAAC;AAEb,EAAA,MAAM,IAAA;AACR;;;;"} \ No newline at end of file diff --git a/packages/bizinikiwi-bindings/dist/esm/codecs/metadata/pallets.mjs b/packages/bizinikiwi-bindings/dist/esm/codecs/metadata/pallets.mjs new file mode 100644 index 0000000..0ef0b82 --- /dev/null +++ b/packages/bizinikiwi-bindings/dist/esm/codecs/metadata/pallets.mjs @@ -0,0 +1,110 @@ +import { Enum, _void, Vector, Struct, Option, str, u8 } from 'scale-ts'; +import '../../utils/ss58-util.mjs'; +import '../scale/Binary.mjs'; +import '../scale/bitSequence.mjs'; +import '../scale/char.mjs'; +import { compactNumber } from '../scale/compact.mjs'; +import { Hex } from '../scale/Hex.mjs'; +import '../scale/fixed-str.mjs'; +import '../scale/Variant.mjs'; +import '../scale/ethAccount.mjs'; +import '../scale/shaped.mjs'; +import '../scale/BitSeq.mjs'; +import { docs } from './docs.mjs'; +import { variantDeprecation, itemDeprecation } from './deprecation.mjs'; +import { viewFunction } from './runtime-api.mjs'; + +const hashType = Enum({ + Blake2128: _void, + Blake2256: _void, + Blake2128Concat: _void, + Twox128: _void, + Twox256: _void, + Twox64Concat: _void, + Identity: _void +}); +const hashers$1 = Vector(hashType); +const storageMap = Struct({ + hashers: hashers$1, + key: compactNumber, + value: compactNumber +}); +const storageItem = { + name: str, + modifier: u8, + type: Enum({ + plain: compactNumber, + map: storageMap + }), + fallback: Hex(), + docs +}; +const enumRefV14 = Option(compactNumber); +const v14Pallet = { + name: str, + storage: Option( + Struct({ + prefix: str, + items: Vector(Struct(storageItem)) + }) + ), + calls: enumRefV14, + events: enumRefV14, + constants: Vector( + Struct({ + name: str, + type: compactNumber, + value: Hex(), + docs + }) + ), + errors: enumRefV14, + index: u8 +}; +const v15Pallet = { + ...v14Pallet, + docs +}; +const enumRef = Option( + Struct({ type: compactNumber, deprecationInfo: variantDeprecation }) +); +const v16Pallet = { + name: str, + storage: Option( + Struct({ + prefix: str, + items: Vector( + Struct({ + ...storageItem, + deprecationInfo: itemDeprecation + }) + ) + }) + ), + calls: enumRef, + events: enumRef, + constants: Vector( + Struct({ + name: str, + type: compactNumber, + value: Hex(), + docs, + deprecationInfo: itemDeprecation + }) + ), + errors: enumRef, + associatedTypes: Vector( + Struct({ + name: str, + type: compactNumber, + docs + }) + ), + viewFns: Vector(viewFunction), + index: u8, + docs, + deprecationInfo: itemDeprecation +}; + +export { storageMap, v14Pallet, v15Pallet, v16Pallet }; +//# sourceMappingURL=pallets.mjs.map diff --git a/packages/bizinikiwi-bindings/dist/esm/codecs/metadata/pallets.mjs.map b/packages/bizinikiwi-bindings/dist/esm/codecs/metadata/pallets.mjs.map new file mode 100644 index 0000000..31d48c2 --- /dev/null +++ b/packages/bizinikiwi-bindings/dist/esm/codecs/metadata/pallets.mjs.map @@ -0,0 +1 @@ +{"version":3,"file":"pallets.mjs","sources":["../../../../src/codecs/metadata/pallets.ts"],"sourcesContent":["import { Hex, compactNumber } from \"@/codecs/scale\"\nimport { Struct, Option, Vector, u8, str, Enum, _void } from \"scale-ts\"\nimport { docs } from \"./docs\"\nimport { itemDeprecation, variantDeprecation } from \"./deprecation\"\nimport { viewFunction } from \"./runtime-api\"\n\nconst hashType = Enum({\n Blake2128: _void,\n Blake2256: _void,\n Blake2128Concat: _void,\n Twox128: _void,\n Twox256: _void,\n Twox64Concat: _void,\n Identity: _void,\n})\n\nconst hashers = Vector(hashType)\n\nexport const storageMap = Struct({\n hashers,\n key: compactNumber,\n value: compactNumber,\n})\n\nconst storageItem = {\n name: str,\n modifier: u8,\n type: Enum({\n plain: compactNumber,\n map: storageMap,\n }),\n fallback: Hex(),\n docs,\n}\n\nconst enumRefV14 = Option(compactNumber)\n\nexport const v14Pallet = {\n name: str,\n storage: Option(\n Struct({\n prefix: str,\n items: Vector(Struct(storageItem)),\n }),\n ),\n calls: enumRefV14,\n events: enumRefV14,\n constants: Vector(\n Struct({\n name: str,\n type: compactNumber,\n value: Hex(),\n docs,\n }),\n ),\n errors: enumRefV14,\n index: u8,\n}\n\nexport const v15Pallet = {\n ...v14Pallet,\n docs,\n}\n\nconst enumRef = Option(\n Struct({ type: compactNumber, deprecationInfo: variantDeprecation }),\n)\n\nexport const v16Pallet = {\n name: str,\n storage: Option(\n Struct({\n prefix: str,\n items: Vector(\n Struct({\n ...storageItem,\n deprecationInfo: itemDeprecation,\n }),\n ),\n }),\n ),\n calls: enumRef,\n events: enumRef,\n constants: Vector(\n Struct({\n name: str,\n type: compactNumber,\n value: Hex(),\n docs,\n deprecationInfo: itemDeprecation,\n }),\n ),\n errors: enumRef,\n associatedTypes: Vector(\n Struct({\n name: str,\n type: compactNumber,\n docs,\n }),\n ),\n viewFns: Vector(viewFunction),\n index: u8,\n docs,\n deprecationInfo: itemDeprecation,\n}\n"],"names":["hashers"],"mappings":";;;;;;;;;;;;;;;;AAMA,MAAM,WAAW,IAAA,CAAK;AAAA,EACpB,SAAA,EAAW,KAAA;AAAA,EACX,SAAA,EAAW,KAAA;AAAA,EACX,eAAA,EAAiB,KAAA;AAAA,EACjB,OAAA,EAAS,KAAA;AAAA,EACT,OAAA,EAAS,KAAA;AAAA,EACT,YAAA,EAAc,KAAA;AAAA,EACd,QAAA,EAAU;AACZ,CAAC,CAAA;AAED,MAAMA,SAAA,GAAU,OAAO,QAAQ,CAAA;AAExB,MAAM,aAAa,MAAA,CAAO;AAAA,WAC/BA,SAAA;AAAA,EACA,GAAA,EAAK,aAAA;AAAA,EACL,KAAA,EAAO;AACT,CAAC;AAED,MAAM,WAAA,GAAc;AAAA,EAClB,IAAA,EAAM,GAAA;AAAA,EACN,QAAA,EAAU,EAAA;AAAA,EACV,MAAM,IAAA,CAAK;AAAA,IACT,KAAA,EAAO,aAAA;AAAA,IACP,GAAA,EAAK;AAAA,GACN,CAAA;AAAA,EACD,UAAU,GAAA,EAAI;AAAA,EACd;AACF,CAAA;AAEA,MAAM,UAAA,GAAa,OAAO,aAAa,CAAA;AAEhC,MAAM,SAAA,GAAY;AAAA,EACvB,IAAA,EAAM,GAAA;AAAA,EACN,OAAA,EAAS,MAAA;AAAA,IACP,MAAA,CAAO;AAAA,MACL,MAAA,EAAQ,GAAA;AAAA,MACR,KAAA,EAAO,MAAA,CAAO,MAAA,CAAO,WAAW,CAAC;AAAA,KAClC;AAAA,GACH;AAAA,EACA,KAAA,EAAO,UAAA;AAAA,EACP,MAAA,EAAQ,UAAA;AAAA,EACR,SAAA,EAAW,MAAA;AAAA,IACT,MAAA,CAAO;AAAA,MACL,IAAA,EAAM,GAAA;AAAA,MACN,IAAA,EAAM,aAAA;AAAA,MACN,OAAO,GAAA,EAAI;AAAA,MACX;AAAA,KACD;AAAA,GACH;AAAA,EACA,MAAA,EAAQ,UAAA;AAAA,EACR,KAAA,EAAO;AACT;AAEO,MAAM,SAAA,GAAY;AAAA,EACvB,GAAG,SAAA;AAAA,EACH;AACF;AAEA,MAAM,OAAA,GAAU,MAAA;AAAA,EACd,OAAO,EAAE,IAAA,EAAM,aAAA,EAAe,eAAA,EAAiB,oBAAoB;AACrE,CAAA;AAEO,MAAM,SAAA,GAAY;AAAA,EACvB,IAAA,EAAM,GAAA;AAAA,EACN,OAAA,EAAS,MAAA;AAAA,IACP,MAAA,CAAO;AAAA,MACL,MAAA,EAAQ,GAAA;AAAA,MACR,KAAA,EAAO,MAAA;AAAA,QACL,MAAA,CAAO;AAAA,UACL,GAAG,WAAA;AAAA,UACH,eAAA,EAAiB;AAAA,SAClB;AAAA;AACH,KACD;AAAA,GACH;AAAA,EACA,KAAA,EAAO,OAAA;AAAA,EACP,MAAA,EAAQ,OAAA;AAAA,EACR,SAAA,EAAW,MAAA;AAAA,IACT,MAAA,CAAO;AAAA,MACL,IAAA,EAAM,GAAA;AAAA,MACN,IAAA,EAAM,aAAA;AAAA,MACN,OAAO,GAAA,EAAI;AAAA,MACX,IAAA;AAAA,MACA,eAAA,EAAiB;AAAA,KAClB;AAAA,GACH;AAAA,EACA,MAAA,EAAQ,OAAA;AAAA,EACR,eAAA,EAAiB,MAAA;AAAA,IACf,MAAA,CAAO;AAAA,MACL,IAAA,EAAM,GAAA;AAAA,MACN,IAAA,EAAM,aAAA;AAAA,MACN;AAAA,KACD;AAAA,GACH;AAAA,EACA,OAAA,EAAS,OAAO,YAAY,CAAA;AAAA,EAC5B,KAAA,EAAO,EAAA;AAAA,EACP,IAAA;AAAA,EACA,eAAA,EAAiB;AACnB;;;;"} \ No newline at end of file diff --git a/packages/bizinikiwi-bindings/dist/esm/codecs/metadata/runtime-api.mjs b/packages/bizinikiwi-bindings/dist/esm/codecs/metadata/runtime-api.mjs new file mode 100644 index 0000000..189ba9d --- /dev/null +++ b/packages/bizinikiwi-bindings/dist/esm/codecs/metadata/runtime-api.mjs @@ -0,0 +1,48 @@ +import { Vector, Struct, str } from 'scale-ts'; +import { docs } from './docs.mjs'; +import '../../utils/ss58-util.mjs'; +import '../scale/Binary.mjs'; +import '../scale/bitSequence.mjs'; +import '../scale/char.mjs'; +import { compactNumber } from '../scale/compact.mjs'; +import { Hex } from '../scale/Hex.mjs'; +import '../scale/fixed-str.mjs'; +import '../scale/Variant.mjs'; +import '../scale/ethAccount.mjs'; +import '../scale/shaped.mjs'; +import '../scale/BitSeq.mjs'; +import { itemDeprecation } from './deprecation.mjs'; + +const runtimeApiMethod = { + name: str, + inputs: Vector( + Struct({ + name: str, + type: compactNumber + }) + ), + output: compactNumber, + docs +}; +const runtimeApiV15 = Struct({ + name: str, + methods: Vector(Struct(runtimeApiMethod)), + docs +}); +const runtimeApi = Struct({ + name: str, + methods: Vector( + Struct({ ...runtimeApiMethod, deprecationInfo: itemDeprecation }) + ), + docs, + version: compactNumber, + deprecationInfo: itemDeprecation +}); +const viewFunction = Struct({ + id: Hex(32), + ...runtimeApiMethod, + deprecationInfo: itemDeprecation +}); + +export { runtimeApi, runtimeApiMethod, runtimeApiV15, viewFunction }; +//# sourceMappingURL=runtime-api.mjs.map diff --git a/packages/bizinikiwi-bindings/dist/esm/codecs/metadata/runtime-api.mjs.map b/packages/bizinikiwi-bindings/dist/esm/codecs/metadata/runtime-api.mjs.map new file mode 100644 index 0000000..e5149dd --- /dev/null +++ b/packages/bizinikiwi-bindings/dist/esm/codecs/metadata/runtime-api.mjs.map @@ -0,0 +1 @@ +{"version":3,"file":"runtime-api.mjs","sources":["../../../../src/codecs/metadata/runtime-api.ts"],"sourcesContent":["import { Struct, Vector, str } from \"scale-ts\"\nimport { docs } from \"./docs\"\nimport { compactNumber, Hex, compactNumber as ty } from \"../scale\"\nimport { itemDeprecation } from \"./deprecation\"\n\nexport const runtimeApiMethod = {\n name: str,\n inputs: Vector(\n Struct({\n name: str,\n type: ty,\n }),\n ),\n output: ty,\n docs,\n}\n\nexport const runtimeApiV15 = Struct({\n name: str,\n methods: Vector(Struct(runtimeApiMethod)),\n docs,\n})\n\nexport const runtimeApi = Struct({\n name: str,\n methods: Vector(\n Struct({ ...runtimeApiMethod, deprecationInfo: itemDeprecation }),\n ),\n docs,\n version: compactNumber,\n deprecationInfo: itemDeprecation,\n})\n\nexport const viewFunction = Struct({\n id: Hex(32),\n ...runtimeApiMethod,\n deprecationInfo: itemDeprecation,\n})\n"],"names":["ty"],"mappings":";;;;;;;;;;;;;;;AAKO,MAAM,gBAAA,GAAmB;AAAA,EAC9B,IAAA,EAAM,GAAA;AAAA,EACN,MAAA,EAAQ,MAAA;AAAA,IACN,MAAA,CAAO;AAAA,MACL,IAAA,EAAM,GAAA;AAAA,MACN,IAAA,EAAMA;AAAA,KACP;AAAA,GACH;AAAA,EACA,MAAA,EAAQA,aAAA;AAAA,EACR;AACF;AAEO,MAAM,gBAAgB,MAAA,CAAO;AAAA,EAClC,IAAA,EAAM,GAAA;AAAA,EACN,OAAA,EAAS,MAAA,CAAO,MAAA,CAAO,gBAAgB,CAAC,CAAA;AAAA,EACxC;AACF,CAAC;AAEM,MAAM,aAAa,MAAA,CAAO;AAAA,EAC/B,IAAA,EAAM,GAAA;AAAA,EACN,OAAA,EAAS,MAAA;AAAA,IACP,OAAO,EAAE,GAAG,gBAAA,EAAkB,eAAA,EAAiB,iBAAiB;AAAA,GAClE;AAAA,EACA,IAAA;AAAA,EACA,OAAA,EAAS,aAAA;AAAA,EACT,eAAA,EAAiB;AACnB,CAAC;AAEM,MAAM,eAAe,MAAA,CAAO;AAAA,EACjC,EAAA,EAAI,IAAI,EAAE,CAAA;AAAA,EACV,GAAG,gBAAA;AAAA,EACH,eAAA,EAAiB;AACnB,CAAC;;;;"} \ No newline at end of file diff --git a/packages/bizinikiwi-bindings/dist/esm/codecs/metadata/unified.mjs b/packages/bizinikiwi-bindings/dist/esm/codecs/metadata/unified.mjs new file mode 100644 index 0000000..1760487 --- /dev/null +++ b/packages/bizinikiwi-bindings/dist/esm/codecs/metadata/unified.mjs @@ -0,0 +1,48 @@ +const unifyMetadata = (metadata) => { + if ("magicNumber" in metadata) metadata = metadata.metadata; + if ("tag" in metadata) { + if (metadata.tag !== "v14" && metadata.tag !== "v15" && metadata.tag !== "v16") + throw new Error("Only metadata 14, 15, and 16 are supported"); + metadata = metadata.value; + } + if ("signedExtensionsByVersion" in metadata.extrinsic) { + return { version: 16, ...metadata }; + } + if ("custom" in metadata) { + const { lookup: lookup2, extrinsic: extrinsic2, custom, apis, pallets: pallets2, outerEnums } = metadata; + return { + version: 15, + lookup: lookup2, + pallets: pallets2.map((p) => ({ + ...p, + calls: p.calls != null ? { type: p.calls } : void 0, + events: p.events != null ? { type: p.events } : void 0, + errors: p.errors != null ? { type: p.errors } : void 0, + viewFns: [], + associatedTypes: [] + })), + extrinsic: { ...extrinsic2, version: [extrinsic2.version] }, + apis, + outerEnums, + custom + }; + } + const { lookup, extrinsic, pallets } = metadata; + return { + version: 14, + lookup, + pallets: pallets.map((p) => ({ + ...p, + calls: p.calls != null ? { type: p.calls } : void 0, + events: p.events != null ? { type: p.events } : void 0, + errors: p.errors != null ? { type: p.errors } : void 0, + viewFns: [], + associatedTypes: [] + })), + extrinsic: { ...extrinsic, version: [extrinsic.version] }, + apis: [] + }; +}; + +export { unifyMetadata }; +//# sourceMappingURL=unified.mjs.map diff --git a/packages/bizinikiwi-bindings/dist/esm/codecs/metadata/unified.mjs.map b/packages/bizinikiwi-bindings/dist/esm/codecs/metadata/unified.mjs.map new file mode 100644 index 0000000..65bfbd1 --- /dev/null +++ b/packages/bizinikiwi-bindings/dist/esm/codecs/metadata/unified.mjs.map @@ -0,0 +1 @@ +{"version":3,"file":"unified.mjs","sources":["../../../../src/codecs/metadata/unified.ts"],"sourcesContent":["import { CodecType } from \"scale-ts\"\nimport { V14Lookup } from \"./lookup\"\nimport { storageMap } from \"./pallets\"\nimport { HexString } from \"../scale\"\nimport { itemDeprecation, variantDeprecation } from \"./deprecation\"\nimport { viewFunction } from \"./runtime-api\"\nimport { V14 } from \"./v14\"\nimport { V16 } from \"./v16\"\nimport { V15 } from \"./v15\"\nimport { Metadata } from \"./metadata\"\n\ntype EnumRef =\n | ({\n type: number\n } & (T extends 16\n ? { deprecationInfo: CodecType }\n : {}))\n | undefined\n\ntype DeprecationInfo = T extends 16\n ? { deprecationInfo: CodecType }\n : {}\n\nexport type UnifiedMetadata = {\n version: T\n lookup: V14Lookup\n pallets: Array<\n {\n name: string\n storage:\n | {\n prefix: string\n items: Array<\n {\n name: string\n modifier: number\n type:\n | { tag: \"plain\"; value: number }\n | { tag: \"map\"; value: CodecType }\n fallback: HexString\n docs: string[]\n } & DeprecationInfo\n >\n }\n | undefined\n calls: EnumRef\n events: EnumRef\n constants: Array<\n {\n name: string\n type: number\n value: HexString\n docs: string[]\n } & DeprecationInfo\n >\n errors: EnumRef\n associatedTypes: Array<{\n name: string\n type: number\n docs: string[]\n }>\n viewFns: Array>\n index: number\n docs: string[]\n } & DeprecationInfo\n >\n extrinsic: {\n version: number[]\n signedExtensions: Array<{\n identifier: string\n type: number\n additionalSigned: number\n }>\n } & (T extends 14\n ? {\n type: number\n }\n : { address: number; call: number; signature: number }) &\n (T extends 16\n ? { signedExtensionsByVersion: Array<[number, number[]]> }\n : {})\n apis: Array<\n {\n name: string\n methods: Array<\n {\n name: string\n inputs: Array<{ name: string; type: number }>\n output: number\n docs: string[]\n } & DeprecationInfo\n >\n docs: string[]\n } & (T extends 16 ? { version: number } : {}) &\n DeprecationInfo\n >\n} & (T extends 14\n ? {}\n : {\n outerEnums: { call: number; event: number; error: number }\n custom: Array<[string, { type: number; value: HexString }]>\n })\n\nexport const unifyMetadata = (\n metadata: Metadata | Metadata[\"metadata\"] | V14 | V15 | V16,\n): UnifiedMetadata => {\n // complete metadata\n if (\"magicNumber\" in metadata) metadata = metadata.metadata\n if (\"tag\" in metadata) {\n if (\n metadata.tag !== \"v14\" &&\n metadata.tag !== \"v15\" &&\n metadata.tag !== \"v16\"\n )\n throw new Error(\"Only metadata 14, 15, and 16 are supported\")\n metadata = metadata.value\n }\n\n // v16\n if (\"signedExtensionsByVersion\" in metadata.extrinsic) {\n return { version: 16, ...(metadata as V16) }\n }\n // v15\n if (\"custom\" in metadata) {\n const { lookup, extrinsic, custom, apis, pallets, outerEnums } =\n metadata as V15\n\n return {\n version: 15,\n lookup,\n pallets: pallets.map((p): UnifiedMetadata<15>[\"pallets\"][number] => ({\n ...p,\n calls: p.calls != null ? { type: p.calls } : undefined,\n events: p.events != null ? { type: p.events } : undefined,\n errors: p.errors != null ? { type: p.errors } : undefined,\n viewFns: [],\n associatedTypes: [],\n })),\n extrinsic: { ...extrinsic, version: [extrinsic.version] },\n apis,\n outerEnums,\n custom,\n }\n }\n // fallback, v14\n const { lookup, extrinsic, pallets } = metadata as V14\n return {\n version: 14,\n lookup,\n pallets: pallets.map((p): UnifiedMetadata<14>[\"pallets\"][number] => ({\n ...p,\n calls: p.calls != null ? { type: p.calls } : undefined,\n events: p.events != null ? { type: p.events } : undefined,\n errors: p.errors != null ? { type: p.errors } : undefined,\n viewFns: [],\n associatedTypes: [],\n })),\n extrinsic: { ...extrinsic, version: [extrinsic.version] },\n apis: [],\n }\n}\n"],"names":["lookup","extrinsic","pallets"],"mappings":"AAuGO,MAAM,aAAA,GAAgB,CAC3B,QAAA,KACoB;AAEpB,EAAA,IAAI,aAAA,IAAiB,QAAA,EAAU,QAAA,GAAW,QAAA,CAAS,QAAA;AACnD,EAAA,IAAI,SAAS,QAAA,EAAU;AACrB,IAAA,IACE,SAAS,GAAA,KAAQ,KAAA,IACjB,SAAS,GAAA,KAAQ,KAAA,IACjB,SAAS,GAAA,KAAQ,KAAA;AAEjB,MAAA,MAAM,IAAI,MAAM,4CAA4C,CAAA;AAC9D,IAAA,QAAA,GAAW,QAAA,CAAS,KAAA;AAAA,EACtB;AAGA,EAAA,IAAI,2BAAA,IAA+B,SAAS,SAAA,EAAW;AACrD,IAAA,OAAO,EAAE,OAAA,EAAS,EAAA,EAAI,GAAI,QAAA,EAAiB;AAAA,EAC7C;AAEA,EAAA,IAAI,YAAY,QAAA,EAAU;AACxB,IAAA,MAAM,EAAE,MAAA,EAAAA,OAAAA,EAAQ,SAAA,EAAAC,UAAAA,EAAW,QAAQ,IAAA,EAAM,OAAA,EAAAC,QAAAA,EAAS,UAAA,EAAW,GAC3D,QAAA;AAEF,IAAA,OAAO;AAAA,MACL,OAAA,EAAS,EAAA;AAAA,MACT,MAAA,EAAAF,OAAAA;AAAA,MACA,OAAA,EAASE,QAAAA,CAAQ,GAAA,CAAI,CAAC,CAAA,MAA+C;AAAA,QACnE,GAAG,CAAA;AAAA,QACH,KAAA,EAAO,EAAE,KAAA,IAAS,IAAA,GAAO,EAAE,IAAA,EAAM,CAAA,CAAE,OAAM,GAAI,MAAA;AAAA,QAC7C,MAAA,EAAQ,EAAE,MAAA,IAAU,IAAA,GAAO,EAAE,IAAA,EAAM,CAAA,CAAE,QAAO,GAAI,MAAA;AAAA,QAChD,MAAA,EAAQ,EAAE,MAAA,IAAU,IAAA,GAAO,EAAE,IAAA,EAAM,CAAA,CAAE,QAAO,GAAI,MAAA;AAAA,QAChD,SAAS,EAAC;AAAA,QACV,iBAAiB;AAAC,OACpB,CAAE,CAAA;AAAA,MACF,SAAA,EAAW,EAAE,GAAGD,UAAAA,EAAW,SAAS,CAACA,UAAAA,CAAU,OAAO,CAAA,EAAE;AAAA,MACxD,IAAA;AAAA,MACA,UAAA;AAAA,MACA;AAAA,KACF;AAAA,EACF;AAEA,EAAA,MAAM,EAAE,MAAA,EAAQ,SAAA,EAAW,OAAA,EAAQ,GAAI,QAAA;AACvC,EAAA,OAAO;AAAA,IACL,OAAA,EAAS,EAAA;AAAA,IACT,MAAA;AAAA,IACA,OAAA,EAAS,OAAA,CAAQ,GAAA,CAAI,CAAC,CAAA,MAA+C;AAAA,MACnE,GAAG,CAAA;AAAA,MACH,KAAA,EAAO,EAAE,KAAA,IAAS,IAAA,GAAO,EAAE,IAAA,EAAM,CAAA,CAAE,OAAM,GAAI,MAAA;AAAA,MAC7C,MAAA,EAAQ,EAAE,MAAA,IAAU,IAAA,GAAO,EAAE,IAAA,EAAM,CAAA,CAAE,QAAO,GAAI,MAAA;AAAA,MAChD,MAAA,EAAQ,EAAE,MAAA,IAAU,IAAA,GAAO,EAAE,IAAA,EAAM,CAAA,CAAE,QAAO,GAAI,MAAA;AAAA,MAChD,SAAS,EAAC;AAAA,MACV,iBAAiB;AAAC,KACpB,CAAE,CAAA;AAAA,IACF,SAAA,EAAW,EAAE,GAAG,SAAA,EAAW,SAAS,CAAC,SAAA,CAAU,OAAO,CAAA,EAAE;AAAA,IACxD,MAAM;AAAC,GACT;AACF;;;;"} \ No newline at end of file diff --git a/packages/bizinikiwi-bindings/dist/esm/codecs/metadata/v14.mjs b/packages/bizinikiwi-bindings/dist/esm/codecs/metadata/v14.mjs new file mode 100644 index 0000000..6294cc9 --- /dev/null +++ b/packages/bizinikiwi-bindings/dist/esm/codecs/metadata/v14.mjs @@ -0,0 +1,41 @@ +import { Struct, Vector, u8, str, createCodec } from 'scale-ts'; +import { lookup } from './lookup.mjs'; +import '../../utils/ss58-util.mjs'; +import '../scale/Binary.mjs'; +import '../scale/bitSequence.mjs'; +import '../scale/char.mjs'; +import { compactNumber } from '../scale/compact.mjs'; +import '../scale/Hex.mjs'; +import '../scale/fixed-str.mjs'; +import '../scale/Variant.mjs'; +import '../scale/ethAccount.mjs'; +import '../scale/shaped.mjs'; +import '../scale/BitSeq.mjs'; +import { v14Pallet } from './pallets.mjs'; + +const empty = new Uint8Array(); +const Always = (value) => createCodec( + () => empty, + () => value +); +const extrinsic$2 = Struct({ + type: compactNumber, + version: u8, + signedExtensions: Vector( + Struct({ + identifier: str, + type: compactNumber, + additionalSigned: compactNumber + }) + ) +}); +const v14 = Struct({ + lookup, + pallets: Vector(Struct({ ...v14Pallet, docs: Always([]) })), + extrinsic: extrinsic$2, + type: compactNumber, + apis: Always([]) +}); + +export { v14 }; +//# sourceMappingURL=v14.mjs.map diff --git a/packages/bizinikiwi-bindings/dist/esm/codecs/metadata/v14.mjs.map b/packages/bizinikiwi-bindings/dist/esm/codecs/metadata/v14.mjs.map new file mode 100644 index 0000000..44ea96f --- /dev/null +++ b/packages/bizinikiwi-bindings/dist/esm/codecs/metadata/v14.mjs.map @@ -0,0 +1 @@ +{"version":3,"file":"v14.mjs","sources":["../../../../src/codecs/metadata/v14.ts"],"sourcesContent":["import { CodecType, Struct, Vector, createCodec, str, u8 } from \"scale-ts\"\nimport { lookup } from \"./lookup\"\nimport { compactNumber } from \"../scale\"\nimport { v14Pallet } from \"./pallets\"\nimport { runtimeApi } from \"./runtime-api\"\n\nconst empty = new Uint8Array()\nconst Always = (value: T) =>\n createCodec(\n () => empty,\n () => value,\n )\n\nconst extrinsic = Struct({\n type: compactNumber,\n version: u8,\n signedExtensions: Vector(\n Struct({\n identifier: str,\n type: compactNumber,\n additionalSigned: compactNumber,\n }),\n ),\n})\n\nexport const v14 = Struct({\n lookup,\n pallets: Vector(Struct({ ...v14Pallet, docs: Always([] as string[]) })),\n extrinsic,\n type: compactNumber,\n apis: Always([] as Array>),\n})\nexport type V14 = CodecType\n"],"names":["extrinsic"],"mappings":";;;;;;;;;;;;;;;AAMA,MAAM,KAAA,GAAQ,IAAI,UAAA,EAAW;AAC7B,MAAM,MAAA,GAAS,CAAI,KAAA,KACjB,WAAA;AAAA,EACE,MAAM,KAAA;AAAA,EACN,MAAM;AACR,CAAA;AAEF,MAAMA,cAAY,MAAA,CAAO;AAAA,EACvB,IAAA,EAAM,aAAA;AAAA,EACN,OAAA,EAAS,EAAA;AAAA,EACT,gBAAA,EAAkB,MAAA;AAAA,IAChB,MAAA,CAAO;AAAA,MACL,UAAA,EAAY,GAAA;AAAA,MACZ,IAAA,EAAM,aAAA;AAAA,MACN,gBAAA,EAAkB;AAAA,KACnB;AAAA;AAEL,CAAC,CAAA;AAEM,MAAM,MAAM,MAAA,CAAO;AAAA,EACxB,MAAA;AAAA,EACA,OAAA,EAAS,MAAA,CAAO,MAAA,CAAO,EAAE,GAAG,SAAA,EAAW,IAAA,EAAM,MAAA,CAAO,EAAc,CAAA,EAAG,CAAC,CAAA;AAAA,aACtEA,WAAA;AAAA,EACA,IAAA,EAAM,aAAA;AAAA,EACN,IAAA,EAAM,MAAA,CAAO,EAAyC;AACxD,CAAC;;;;"} \ No newline at end of file diff --git a/packages/bizinikiwi-bindings/dist/esm/codecs/metadata/v15.mjs b/packages/bizinikiwi-bindings/dist/esm/codecs/metadata/v15.mjs new file mode 100644 index 0000000..1fb555c --- /dev/null +++ b/packages/bizinikiwi-bindings/dist/esm/codecs/metadata/v15.mjs @@ -0,0 +1,46 @@ +import { Struct, Vector, u8, str, Tuple } from 'scale-ts'; +import { lookup } from './lookup.mjs'; +import { v15Pallet } from './pallets.mjs'; +import '../../utils/ss58-util.mjs'; +import '../scale/Binary.mjs'; +import '../scale/bitSequence.mjs'; +import '../scale/char.mjs'; +import { compactNumber } from '../scale/compact.mjs'; +import { Hex } from '../scale/Hex.mjs'; +import '../scale/fixed-str.mjs'; +import '../scale/Variant.mjs'; +import '../scale/ethAccount.mjs'; +import '../scale/shaped.mjs'; +import '../scale/BitSeq.mjs'; +import { runtimeApiV15 } from './runtime-api.mjs'; + +const extrinsic$1 = Struct({ + version: u8, + address: compactNumber, + call: compactNumber, + signature: compactNumber, + extra: compactNumber, + signedExtensions: Vector( + Struct({ + identifier: str, + type: compactNumber, + additionalSigned: compactNumber + }) + ) +}); +const v15 = Struct({ + lookup, + pallets: Vector(Struct(v15Pallet)), + extrinsic: extrinsic$1, + type: compactNumber, + apis: Vector(runtimeApiV15), + outerEnums: Struct({ + call: compactNumber, + event: compactNumber, + error: compactNumber + }), + custom: Vector(Tuple(str, Struct({ type: compactNumber, value: Hex() }))) +}); + +export { v15 }; +//# sourceMappingURL=v15.mjs.map diff --git a/packages/bizinikiwi-bindings/dist/esm/codecs/metadata/v15.mjs.map b/packages/bizinikiwi-bindings/dist/esm/codecs/metadata/v15.mjs.map new file mode 100644 index 0000000..725964a --- /dev/null +++ b/packages/bizinikiwi-bindings/dist/esm/codecs/metadata/v15.mjs.map @@ -0,0 +1 @@ +{"version":3,"file":"v15.mjs","sources":["../../../../src/codecs/metadata/v15.ts"],"sourcesContent":["import { CodecType, Struct, Tuple, Vector, str, u8 } from \"scale-ts\"\nimport { lookup } from \"./lookup\"\nimport { v15Pallet } from \"./pallets\"\nimport { Hex, compactNumber as ty } from \"../scale\"\nimport { runtimeApiV15 } from \"./runtime-api\"\n\nconst extrinsic = Struct({\n version: u8,\n address: ty,\n call: ty,\n signature: ty,\n extra: ty,\n signedExtensions: Vector(\n Struct({\n identifier: str,\n type: ty,\n additionalSigned: ty,\n }),\n ),\n})\n\nexport const v15 = Struct({\n lookup,\n pallets: Vector(Struct(v15Pallet)),\n extrinsic,\n type: ty,\n apis: Vector(runtimeApiV15),\n outerEnums: Struct({\n call: ty,\n event: ty,\n error: ty,\n }),\n custom: Vector(Tuple(str, Struct({ type: ty, value: Hex() }))),\n})\nexport type V15 = CodecType\n"],"names":["extrinsic","ty"],"mappings":";;;;;;;;;;;;;;;;AAMA,MAAMA,cAAY,MAAA,CAAO;AAAA,EACvB,OAAA,EAAS,EAAA;AAAA,EACT,OAAA,EAASC,aAAA;AAAA,EACT,IAAA,EAAMA,aAAA;AAAA,EACN,SAAA,EAAWA,aAAA;AAAA,EACX,KAAA,EAAOA,aAAA;AAAA,EACP,gBAAA,EAAkB,MAAA;AAAA,IAChB,MAAA,CAAO;AAAA,MACL,UAAA,EAAY,GAAA;AAAA,MACZ,IAAA,EAAMA,aAAA;AAAA,MACN,gBAAA,EAAkBA;AAAA,KACnB;AAAA;AAEL,CAAC,CAAA;AAEM,MAAM,MAAM,MAAA,CAAO;AAAA,EACxB,MAAA;AAAA,EACA,OAAA,EAAS,MAAA,CAAO,MAAA,CAAO,SAAS,CAAC,CAAA;AAAA,aACjCD,WAAA;AAAA,EACA,IAAA,EAAMC,aAAA;AAAA,EACN,IAAA,EAAM,OAAO,aAAa,CAAA;AAAA,EAC1B,YAAY,MAAA,CAAO;AAAA,IACjB,IAAA,EAAMA,aAAA;AAAA,IACN,KAAA,EAAOA,aAAA;AAAA,IACP,KAAA,EAAOA;AAAA,GACR,CAAA;AAAA,EACD,MAAA,EAAQ,MAAA,CAAO,KAAA,CAAM,GAAA,EAAK,MAAA,CAAO,EAAE,IAAA,EAAMA,aAAA,EAAI,KAAA,EAAO,GAAA,EAAI,EAAG,CAAC,CAAC;AAC/D,CAAC;;;;"} \ No newline at end of file diff --git a/packages/bizinikiwi-bindings/dist/esm/codecs/metadata/v16.mjs b/packages/bizinikiwi-bindings/dist/esm/codecs/metadata/v16.mjs new file mode 100644 index 0000000..4b957e3 --- /dev/null +++ b/packages/bizinikiwi-bindings/dist/esm/codecs/metadata/v16.mjs @@ -0,0 +1,45 @@ +import { Struct, Vector, str, Tuple, u8 } from 'scale-ts'; +import { lookup } from './lookup.mjs'; +import { v16Pallet } from './pallets.mjs'; +import '../../utils/ss58-util.mjs'; +import '../scale/Binary.mjs'; +import '../scale/bitSequence.mjs'; +import '../scale/char.mjs'; +import { compactNumber } from '../scale/compact.mjs'; +import { Hex } from '../scale/Hex.mjs'; +import '../scale/fixed-str.mjs'; +import '../scale/Variant.mjs'; +import '../scale/ethAccount.mjs'; +import '../scale/shaped.mjs'; +import '../scale/BitSeq.mjs'; +import { runtimeApi } from './runtime-api.mjs'; + +const extrinsic = Struct({ + version: Vector(u8), + address: compactNumber, + call: compactNumber, + signature: compactNumber, + signedExtensionsByVersion: Vector(Tuple(u8, Vector(compactNumber))), + signedExtensions: Vector( + Struct({ + identifier: str, + type: compactNumber, + additionalSigned: compactNumber + }) + ) +}); +const v16 = Struct({ + lookup, + pallets: Vector(Struct(v16Pallet)), + extrinsic, + apis: Vector(runtimeApi), + outerEnums: Struct({ + call: compactNumber, + event: compactNumber, + error: compactNumber + }), + custom: Vector(Tuple(str, Struct({ type: compactNumber, value: Hex() }))) +}); + +export { v16 }; +//# sourceMappingURL=v16.mjs.map diff --git a/packages/bizinikiwi-bindings/dist/esm/codecs/metadata/v16.mjs.map b/packages/bizinikiwi-bindings/dist/esm/codecs/metadata/v16.mjs.map new file mode 100644 index 0000000..e72721f --- /dev/null +++ b/packages/bizinikiwi-bindings/dist/esm/codecs/metadata/v16.mjs.map @@ -0,0 +1 @@ +{"version":3,"file":"v16.mjs","sources":["../../../../src/codecs/metadata/v16.ts"],"sourcesContent":["import { CodecType, Struct, Tuple, Vector, str, u8 } from \"scale-ts\"\nimport { lookup } from \"./lookup\"\nimport { v16Pallet } from \"./pallets\"\nimport { compactNumber, Hex, compactNumber as ty } from \"../scale\"\nimport { runtimeApi } from \"./runtime-api\"\n\nconst extrinsic = Struct({\n version: Vector(u8),\n address: ty,\n call: ty,\n signature: ty,\n signedExtensionsByVersion: Vector(Tuple(u8, Vector(compactNumber))),\n signedExtensions: Vector(\n Struct({\n identifier: str,\n type: ty,\n additionalSigned: ty,\n }),\n ),\n})\n\nexport const v16 = Struct({\n lookup,\n pallets: Vector(Struct(v16Pallet)),\n extrinsic,\n apis: Vector(runtimeApi),\n outerEnums: Struct({\n call: ty,\n event: ty,\n error: ty,\n }),\n custom: Vector(Tuple(str, Struct({ type: ty, value: Hex() }))),\n})\nexport type V16 = CodecType\n"],"names":["ty"],"mappings":";;;;;;;;;;;;;;;;AAMA,MAAM,YAAY,MAAA,CAAO;AAAA,EACvB,OAAA,EAAS,OAAO,EAAE,CAAA;AAAA,EAClB,OAAA,EAASA,aAAA;AAAA,EACT,IAAA,EAAMA,aAAA;AAAA,EACN,SAAA,EAAWA,aAAA;AAAA,EACX,2BAA2B,MAAA,CAAO,KAAA,CAAM,IAAI,MAAA,CAAO,aAAa,CAAC,CAAC,CAAA;AAAA,EAClE,gBAAA,EAAkB,MAAA;AAAA,IAChB,MAAA,CAAO;AAAA,MACL,UAAA,EAAY,GAAA;AAAA,MACZ,IAAA,EAAMA,aAAA;AAAA,MACN,gBAAA,EAAkBA;AAAA,KACnB;AAAA;AAEL,CAAC,CAAA;AAEM,MAAM,MAAM,MAAA,CAAO;AAAA,EACxB,MAAA;AAAA,EACA,OAAA,EAAS,MAAA,CAAO,MAAA,CAAO,SAAS,CAAC,CAAA;AAAA,EACjC,SAAA;AAAA,EACA,IAAA,EAAM,OAAO,UAAU,CAAA;AAAA,EACvB,YAAY,MAAA,CAAO;AAAA,IACjB,IAAA,EAAMA,aAAA;AAAA,IACN,KAAA,EAAOA,aAAA;AAAA,IACP,KAAA,EAAOA;AAAA,GACR,CAAA;AAAA,EACD,MAAA,EAAQ,MAAA,CAAO,KAAA,CAAM,GAAA,EAAK,MAAA,CAAO,EAAE,IAAA,EAAMA,aAAA,EAAI,KAAA,EAAO,GAAA,EAAI,EAAG,CAAC,CAAC;AAC/D,CAAC;;;;"} \ No newline at end of file diff --git a/packages/bizinikiwi-bindings/dist/esm/codecs/scale/AccountId.mjs b/packages/bizinikiwi-bindings/dist/esm/codecs/scale/AccountId.mjs new file mode 100644 index 0000000..0b62958 --- /dev/null +++ b/packages/bizinikiwi-bindings/dist/esm/codecs/scale/AccountId.mjs @@ -0,0 +1,21 @@ +import { enhanceCodec, Bytes } from 'scale-ts'; +import { fromBufferToBase58, getSs58AddressInfo } from '../../utils/ss58-util.mjs'; + +function fromBase58ToBuffer(nBytes, _ss58Format) { + return (address) => { + const info = getSs58AddressInfo(address); + if (!info.isValid) throw new Error("Invalid checksum"); + const { publicKey } = info; + if (publicKey.length !== nBytes) + throw new Error("Invalid public key length"); + return publicKey; + }; +} +const AccountId = (ss58Format = 42, nBytes = 32) => enhanceCodec( + Bytes(nBytes), + fromBase58ToBuffer(nBytes), + fromBufferToBase58(ss58Format) +); + +export { AccountId }; +//# sourceMappingURL=AccountId.mjs.map diff --git a/packages/bizinikiwi-bindings/dist/esm/codecs/scale/AccountId.mjs.map b/packages/bizinikiwi-bindings/dist/esm/codecs/scale/AccountId.mjs.map new file mode 100644 index 0000000..29f3676 --- /dev/null +++ b/packages/bizinikiwi-bindings/dist/esm/codecs/scale/AccountId.mjs.map @@ -0,0 +1 @@ +{"version":3,"file":"AccountId.mjs","sources":["../../../../src/codecs/scale/AccountId.ts"],"sourcesContent":["import { Bytes, enhanceCodec } from \"scale-ts\"\nimport {\n getSs58AddressInfo,\n SS58String,\n fromBufferToBase58,\n} from \"@/utils/ss58-util\"\n\nfunction fromBase58ToBuffer(nBytes: number, _ss58Format: number) {\n return (address: SS58String) => {\n const info = getSs58AddressInfo(address)\n if (!info.isValid) throw new Error(\"Invalid checksum\")\n const { publicKey } = info\n if (publicKey.length !== nBytes)\n throw new Error(\"Invalid public key length\")\n\n return publicKey\n }\n}\n\nexport const AccountId = (ss58Format: number = 42, nBytes: 32 | 33 = 32) =>\n enhanceCodec(\n Bytes(nBytes),\n fromBase58ToBuffer(nBytes, ss58Format),\n fromBufferToBase58(ss58Format),\n )\n"],"names":[],"mappings":";;;AAOA,SAAS,kBAAA,CAAmB,QAAgB,WAAA,EAAqB;AAC/D,EAAA,OAAO,CAAC,OAAA,KAAwB;AAC9B,IAAA,MAAM,IAAA,GAAO,mBAAmB,OAAO,CAAA;AACvC,IAAA,IAAI,CAAC,IAAA,CAAK,OAAA,EAAS,MAAM,IAAI,MAAM,kBAAkB,CAAA;AACrD,IAAA,MAAM,EAAE,WAAU,GAAI,IAAA;AACtB,IAAA,IAAI,UAAU,MAAA,KAAW,MAAA;AACvB,MAAA,MAAM,IAAI,MAAM,2BAA2B,CAAA;AAE7C,IAAA,OAAO,SAAA;AAAA,EACT,CAAA;AACF;AAEO,MAAM,SAAA,GAAY,CAAC,UAAA,GAAqB,EAAA,EAAI,SAAkB,EAAA,KACnE,YAAA;AAAA,EACE,MAAM,MAAM,CAAA;AAAA,EACZ,kBAAA,CAAmB,MAAkB,CAAA;AAAA,EACrC,mBAAmB,UAAU;AAC/B;;;;"} \ No newline at end of file diff --git a/packages/bizinikiwi-bindings/dist/esm/codecs/scale/Binary.mjs b/packages/bizinikiwi-bindings/dist/esm/codecs/scale/Binary.mjs new file mode 100644 index 0000000..fe65988 --- /dev/null +++ b/packages/bizinikiwi-bindings/dist/esm/codecs/scale/Binary.mjs @@ -0,0 +1,94 @@ +import { Tuple, compact, Bytes, createCodec } from 'scale-ts'; +import { fromHex, toHex, mergeUint8 } from '@pezkuwi/papi-utils'; +import { AccountId } from './AccountId.mjs'; + +var __defProp = Object.defineProperty; +var __typeError = (msg) => { + throw TypeError(msg); +}; +var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value; +var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value); +var __accessCheck = (obj, member, msg) => member.has(obj) || __typeError("Cannot " + msg); +var __privateGet = (obj, member, getter) => (__accessCheck(obj, member, "read from private field"), getter ? getter.call(obj) : member.get(obj)); +var __privateAdd = (obj, member, value) => member.has(obj) ? __typeError("Cannot add the same private member more than once") : member instanceof WeakSet ? member.add(obj) : member.set(obj, value); +var __privateSet = (obj, member, value, setter) => (__accessCheck(obj, member, "write to private field"), member.set(obj, value), value); +var _bytes, _opaqueBytes, _hex, _opaqueHex, _str; +const textEncoder$3 = new TextEncoder(); +const textDecoder$2 = new TextDecoder(); +const opaqueBytesDec = Tuple(compact, Bytes(Infinity))[1]; +class Binary { + constructor(data, opaque = false) { + __privateAdd(this, _bytes); + __privateAdd(this, _opaqueBytes, null); + __privateAdd(this, _hex, null); + __privateAdd(this, _opaqueHex, null); + __privateAdd(this, _str, null); + __publicField(this, "asText", () => __privateGet(this, _str) ?? __privateSet(this, _str, textDecoder$2.decode(__privateGet(this, _bytes)))); + __publicField(this, "asHex", () => __privateGet(this, _hex) ?? __privateSet(this, _hex, toHex(__privateGet(this, _bytes)))); + __publicField(this, "asOpaqueHex", () => __privateGet(this, _opaqueHex) ?? __privateSet(this, _opaqueHex, toHex(this.asOpaqueBytes()))); + __publicField(this, "asBytes", () => __privateGet(this, _bytes)); + __publicField(this, "asOpaqueBytes", () => __privateGet(this, _opaqueBytes) ?? __privateSet(this, _opaqueBytes, mergeUint8([ + compact[0](__privateGet(this, _bytes).length), + __privateGet(this, _bytes) + ]))); + if (opaque) { + try { + const [len, bytes] = opaqueBytesDec(data); + if (len === bytes.length) { + __privateSet(this, _bytes, bytes); + __privateSet(this, _opaqueBytes, data); + return; + } + } catch (_) { + } + throw new Error("Invalid opaque bytes"); + } else __privateSet(this, _bytes, data); + } + static fromText(input) { + return new this(textEncoder$3.encode(input)); + } + static fromHex(input) { + return new this(fromHex(input)); + } + static fromOpaqueHex(input) { + return new this(fromHex(input), true); + } + static fromBytes(input) { + return new this(input); + } + static fromOpaqueBytes(input) { + return new this(input, true); + } +} +_bytes = new WeakMap(); +_opaqueBytes = new WeakMap(); +_hex = new WeakMap(); +_opaqueHex = new WeakMap(); +_str = new WeakMap(); +const [accountIdEncoder] = AccountId(); +class FixedSizeBinary extends Binary { + constructor(data) { + super(data); + } + static fromArray(input) { + return new this(new Uint8Array(input)); + } + static fromAccountId32(input) { + return new this(accountIdEncoder(input)); + } +} +const enc$2 = (nBytes) => { + const _enc = Bytes.enc(nBytes); + return (value) => _enc(value.asBytes()); +}; +const dec$2 = (nBytes) => { + const _dec = Bytes.dec(nBytes); + const Bin2 = nBytes == null ? Binary : FixedSizeBinary; + return (value) => Bin2.fromBytes(_dec(value)); +}; +const Bin = (nBytes) => createCodec(enc$2(nBytes), dec$2(nBytes)); +Bin.enc = enc$2; +Bin.dec = dec$2; + +export { Bin, Binary, FixedSizeBinary }; +//# sourceMappingURL=Binary.mjs.map diff --git a/packages/bizinikiwi-bindings/dist/esm/codecs/scale/Binary.mjs.map b/packages/bizinikiwi-bindings/dist/esm/codecs/scale/Binary.mjs.map new file mode 100644 index 0000000..0c66733 --- /dev/null +++ b/packages/bizinikiwi-bindings/dist/esm/codecs/scale/Binary.mjs.map @@ -0,0 +1 @@ +{"version":3,"file":"Binary.mjs","sources":["../../../../src/codecs/scale/Binary.ts"],"sourcesContent":["import {\n Bytes,\n Codec,\n Decoder,\n Encoder,\n Tuple,\n compact,\n createCodec,\n} from \"scale-ts\"\nimport { fromHex, mergeUint8, toHex } from \"@pezkuwi/papi-utils\"\nimport type { HexString } from \"./Hex\"\nimport { SS58String } from \"@/utils\"\nimport { AccountId } from \"./AccountId\"\n\nconst textEncoder = new TextEncoder()\nconst textDecoder = new TextDecoder()\nconst opaqueBytesDec = Tuple(compact, Bytes(Infinity))[1]\n\nexport class Binary {\n #bytes: Uint8Array\n #opaqueBytes: Uint8Array | null = null\n #hex: HexString | null = null\n #opaqueHex: HexString | null = null\n #str: string | null = null\n\n constructor(data: Uint8Array, opaque = false) {\n if (opaque) {\n try {\n const [len, bytes] = opaqueBytesDec(data)\n if (len === bytes.length) {\n this.#bytes = bytes\n this.#opaqueBytes = data\n return\n }\n } catch (_) {}\n throw new Error(\"Invalid opaque bytes\")\n } else this.#bytes = data\n }\n\n asText = () => (this.#str ??= textDecoder.decode(this.#bytes))\n\n asHex = () => (this.#hex ??= toHex(this.#bytes)) as `0x${string}`\n asOpaqueHex = () =>\n (this.#opaqueHex ??= toHex(this.asOpaqueBytes())) as `0x${string}`\n\n asBytes = () => this.#bytes\n asOpaqueBytes = () =>\n (this.#opaqueBytes ??= mergeUint8([\n compact[0](this.#bytes.length),\n this.#bytes,\n ]))\n\n static fromText(input: string): Binary {\n return new this(textEncoder.encode(input))\n }\n\n static fromHex(input: HexString): Binary {\n return new this(fromHex(input))\n }\n static fromOpaqueHex(input: HexString): Binary {\n return new this(fromHex(input), true)\n }\n\n static fromBytes(input: Uint8Array): Binary {\n return new this(input)\n }\n static fromOpaqueBytes(input: Uint8Array): Binary {\n return new this(input, true)\n }\n}\n\nconst [accountIdEncoder] = AccountId()\nexport class FixedSizeBinary<_L extends number> extends Binary {\n constructor(data: Uint8Array) {\n super(data)\n }\n\n static fromArray & { length: L }>(\n input: I,\n ) {\n return new this(new Uint8Array(input))\n }\n\n static fromAccountId32(\n input: L extends 32 ? SS58String : never,\n ) {\n return new this(accountIdEncoder(input))\n }\n}\n\nconst enc = (nBytes?: number): Encoder => {\n const _enc = Bytes.enc(nBytes)\n return (value) => _enc(value.asBytes())\n}\n\nconst dec = (nBytes?: number): Decoder => {\n const _dec = Bytes.dec(nBytes)\n const Bin = nBytes == null ? Binary : FixedSizeBinary\n return (value) => Bin.fromBytes(_dec(value))\n}\n\nexport const Bin = (nBytes?: number): Codec =>\n createCodec(enc(nBytes), dec(nBytes))\n\nBin.enc = enc\nBin.dec = dec\n"],"names":["textEncoder","textDecoder","enc","dec","Bin"],"mappings":"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"} \ No newline at end of file diff --git a/packages/bizinikiwi-bindings/dist/esm/codecs/scale/BitSeq.mjs b/packages/bizinikiwi-bindings/dist/esm/codecs/scale/BitSeq.mjs new file mode 100644 index 0000000..f725d03 --- /dev/null +++ b/packages/bizinikiwi-bindings/dist/esm/codecs/scale/BitSeq.mjs @@ -0,0 +1,37 @@ +import { createCodec, createDecoder, Bytes } from 'scale-ts'; +import { compactNumber } from './compact.mjs'; +import { mergeUint8 } from '@pezkuwi/papi-utils'; + +const dec = (isLsb = true) => createDecoder((data) => { + const bitsLen = compactNumber.dec(data); + const bytesLen = Math.ceil(bitsLen / 8); + const bytes = Bytes(bytesLen).dec(data); + const result = new Array(bitsLen); + let resultIdx = 0; + bytes.forEach((val) => { + for (let i = 0; i < 8 && resultIdx < bitsLen; i++) { + const actualIdx = isLsb ? i : 7 - i; + result[resultIdx++] = val >> actualIdx & 1; + } + }); + return result; +}); +const enc = (isLsb = true) => (input) => { + const lenEncoded = compactNumber.enc(input.length); + const nBytes = Math.ceil(input.length / 8); + const bytes = new Uint8Array(nBytes); + for (let byteIdx = 0; byteIdx < nBytes; byteIdx++) { + let inputIdx = byteIdx * 8; + let byte = 0; + for (let i = 0; i < 8 && inputIdx < input.length; i++, inputIdx++) + byte |= input[inputIdx] << (isLsb ? i : 7 - i); + bytes[byteIdx] = byte; + } + return mergeUint8([lenEncoded, bytes]); +}; +const BitSeq = (isLsb) => createCodec(enc(isLsb), dec(isLsb)); +BitSeq.enc = enc; +BitSeq.dec = dec; + +export { BitSeq }; +//# sourceMappingURL=BitSeq.mjs.map diff --git a/packages/bizinikiwi-bindings/dist/esm/codecs/scale/BitSeq.mjs.map b/packages/bizinikiwi-bindings/dist/esm/codecs/scale/BitSeq.mjs.map new file mode 100644 index 0000000..f39fcf3 --- /dev/null +++ b/packages/bizinikiwi-bindings/dist/esm/codecs/scale/BitSeq.mjs.map @@ -0,0 +1 @@ +{"version":3,"file":"BitSeq.mjs","sources":["../../../../src/codecs/scale/BitSeq.ts"],"sourcesContent":["import {\n Bytes,\n Codec,\n Decoder,\n Encoder,\n createCodec,\n createDecoder,\n} from \"scale-ts\"\nimport { compactNumber } from \"./compact\"\nimport { mergeUint8 } from \"@pezkuwi/papi-utils\"\n\nexport type BitSeq = Array<0 | 1>\n\nconst dec: (isLsb?: boolean) => Decoder = (isLsb = true) =>\n createDecoder((data) => {\n const bitsLen = compactNumber.dec(data)\n const bytesLen = Math.ceil(bitsLen / 8)\n const bytes = Bytes(bytesLen).dec(data)\n\n const result = new Array<0 | 1>(bitsLen)\n let resultIdx = 0\n bytes.forEach((val) => {\n for (let i = 0; i < 8 && resultIdx < bitsLen; i++) {\n const actualIdx = isLsb ? i : 7 - i\n result[resultIdx++] = ((val >> actualIdx) & 1) as 1 | 0\n }\n })\n return result\n })\n\nconst enc: (isLsb?: boolean) => Encoder =\n (isLsb = true) =>\n (input) => {\n const lenEncoded = compactNumber.enc(input.length)\n const nBytes = Math.ceil(input.length / 8)\n\n const bytes = new Uint8Array(nBytes)\n for (let byteIdx = 0; byteIdx < nBytes; byteIdx++) {\n let inputIdx = byteIdx * 8\n let byte = 0\n for (let i = 0; i < 8 && inputIdx < input.length; i++, inputIdx++)\n byte |= input[inputIdx] << (isLsb ? i : 7 - i)\n bytes[byteIdx] = byte\n }\n\n return mergeUint8([lenEncoded, bytes])\n }\n\nexport const BitSeq = (isLsb?: boolean): Codec =>\n createCodec(enc(isLsb), dec(isLsb))\n\nBitSeq.enc = enc\nBitSeq.dec = dec\n"],"names":[],"mappings":";;;;AAaA,MAAM,MAA4C,CAAC,KAAA,GAAQ,IAAA,KACzD,aAAA,CAAc,CAAC,IAAA,KAAS;AACtB,EAAA,MAAM,OAAA,GAAU,aAAA,CAAc,GAAA,CAAI,IAAI,CAAA;AACtC,EAAA,MAAM,QAAA,GAAW,IAAA,CAAK,IAAA,CAAK,OAAA,GAAU,CAAC,CAAA;AACtC,EAAA,MAAM,KAAA,GAAQ,KAAA,CAAM,QAAQ,CAAA,CAAE,IAAI,IAAI,CAAA;AAEtC,EAAA,MAAM,MAAA,GAAS,IAAI,KAAA,CAAa,OAAO,CAAA;AACvC,EAAA,IAAI,SAAA,GAAY,CAAA;AAChB,EAAA,KAAA,CAAM,OAAA,CAAQ,CAAC,GAAA,KAAQ;AACrB,IAAA,KAAA,IAAS,IAAI,CAAA,EAAG,CAAA,GAAI,CAAA,IAAK,SAAA,GAAY,SAAS,CAAA,EAAA,EAAK;AACjD,MAAA,MAAM,SAAA,GAAY,KAAA,GAAQ,CAAA,GAAI,CAAA,GAAI,CAAA;AAClC,MAAA,MAAA,CAAO,SAAA,EAAW,CAAA,GAAM,GAAA,IAAO,SAAA,GAAa,CAAA;AAAA,IAC9C;AAAA,EACF,CAAC,CAAA;AACD,EAAA,OAAO,MAAA;AACT,CAAC,CAAA;AAEH,MAAM,GAAA,GACJ,CAAC,KAAA,GAAQ,IAAA,KACT,CAAC,KAAA,KAAU;AACT,EAAA,MAAM,UAAA,GAAa,aAAA,CAAc,GAAA,CAAI,KAAA,CAAM,MAAM,CAAA;AACjD,EAAA,MAAM,MAAA,GAAS,IAAA,CAAK,IAAA,CAAK,KAAA,CAAM,SAAS,CAAC,CAAA;AAEzC,EAAA,MAAM,KAAA,GAAQ,IAAI,UAAA,CAAW,MAAM,CAAA;AACnC,EAAA,KAAA,IAAS,OAAA,GAAU,CAAA,EAAG,OAAA,GAAU,MAAA,EAAQ,OAAA,EAAA,EAAW;AACjD,IAAA,IAAI,WAAW,OAAA,GAAU,CAAA;AACzB,IAAA,IAAI,IAAA,GAAO,CAAA;AACX,IAAA,KAAA,IAAS,IAAI,CAAA,EAAG,CAAA,GAAI,KAAK,QAAA,GAAW,KAAA,CAAM,QAAQ,CAAA,EAAA,EAAK,QAAA,EAAA;AACrD,MAAA,IAAA,IAAQ,KAAA,CAAM,QAAQ,CAAA,KAAM,KAAA,GAAQ,IAAI,CAAA,GAAI,CAAA,CAAA;AAC9C,IAAA,KAAA,CAAM,OAAO,CAAA,GAAI,IAAA;AAAA,EACnB;AAEA,EAAA,OAAO,UAAA,CAAW,CAAC,UAAA,EAAY,KAAK,CAAC,CAAA;AACvC,CAAA;AAEK,MAAM,MAAA,GAAS,CAAC,KAAA,KACrB,WAAA,CAAY,IAAI,KAAK,CAAA,EAAG,GAAA,CAAI,KAAK,CAAC;AAEpC,MAAA,CAAO,GAAA,GAAM,GAAA;AACb,MAAA,CAAO,GAAA,GAAM,GAAA;;;;"} \ No newline at end of file diff --git a/packages/bizinikiwi-bindings/dist/esm/codecs/scale/Hex.mjs b/packages/bizinikiwi-bindings/dist/esm/codecs/scale/Hex.mjs new file mode 100644 index 0000000..20bb08e --- /dev/null +++ b/packages/bizinikiwi-bindings/dist/esm/codecs/scale/Hex.mjs @@ -0,0 +1,17 @@ +import { fromHex, toHex } from '@pezkuwi/papi-utils'; +import { createCodec, Bytes } from 'scale-ts'; + +const enc$1 = (nBytes) => { + const _enc = Bytes.enc(nBytes); + return (value) => _enc(fromHex(value)); +}; +const dec$1 = (nBytes) => { + const _dec = Bytes.dec(nBytes); + return (value) => toHex(_dec(value)); +}; +const Hex = (nBytes) => createCodec(enc$1(nBytes), dec$1(nBytes)); +Hex.enc = enc$1; +Hex.dec = dec$1; + +export { Hex }; +//# sourceMappingURL=Hex.mjs.map diff --git a/packages/bizinikiwi-bindings/dist/esm/codecs/scale/Hex.mjs.map b/packages/bizinikiwi-bindings/dist/esm/codecs/scale/Hex.mjs.map new file mode 100644 index 0000000..762447b --- /dev/null +++ b/packages/bizinikiwi-bindings/dist/esm/codecs/scale/Hex.mjs.map @@ -0,0 +1 @@ +{"version":3,"file":"Hex.mjs","sources":["../../../../src/codecs/scale/Hex.ts"],"sourcesContent":["import { fromHex, toHex } from \"@pezkuwi/papi-utils\"\nimport { Bytes, Codec, Decoder, Encoder, createCodec } from \"scale-ts\"\n\nexport type HexString = string & { __hexString?: unknown }\n\nconst enc = (nBytes?: number): Encoder => {\n const _enc = Bytes.enc(nBytes)\n return (value: string) => _enc(fromHex(value))\n}\n\nconst dec = (nBytes?: number): Decoder => {\n const _dec = Bytes.dec(nBytes)\n return (value) => toHex(_dec(value)) as HexString\n}\n\nexport const Hex = (nBytes?: number): Codec =>\n createCodec(enc(nBytes), dec(nBytes))\n\nHex.enc = enc\nHex.dec = dec\n"],"names":["enc","dec"],"mappings":";;;AAKA,MAAMA,KAAA,GAAM,CAAC,MAAA,KAAwC;AACnD,EAAA,MAAM,IAAA,GAAO,KAAA,CAAM,GAAA,CAAI,MAAM,CAAA;AAC7B,EAAA,OAAO,CAAC,KAAA,KAAkB,IAAA,CAAK,OAAA,CAAQ,KAAK,CAAC,CAAA;AAC/C,CAAA;AAEA,MAAMC,KAAA,GAAM,CAAC,MAAA,KAAwC;AACnD,EAAA,MAAM,IAAA,GAAO,KAAA,CAAM,GAAA,CAAI,MAAM,CAAA;AAC7B,EAAA,OAAO,CAAC,KAAA,KAAU,KAAA,CAAM,IAAA,CAAK,KAAK,CAAC,CAAA;AACrC,CAAA;AAEO,MAAM,GAAA,GAAM,CAAC,MAAA,KAClB,WAAA,CAAYD,MAAI,MAAM,CAAA,EAAGC,KAAA,CAAI,MAAM,CAAC;AAEtC,GAAA,CAAI,GAAA,GAAMD,KAAA;AACV,GAAA,CAAI,GAAA,GAAMC,KAAA;;;;"} \ No newline at end of file diff --git a/packages/bizinikiwi-bindings/dist/esm/codecs/scale/Self.mjs b/packages/bizinikiwi-bindings/dist/esm/codecs/scale/Self.mjs new file mode 100644 index 0000000..cff94e8 --- /dev/null +++ b/packages/bizinikiwi-bindings/dist/esm/codecs/scale/Self.mjs @@ -0,0 +1,26 @@ +import { createCodec } from 'scale-ts'; + +const selfEncoder = (value) => { + let cache = (x) => { + const encoder = value(); + cache = encoder; + return encoder(x); + }; + return (x) => cache(x); +}; +const selfDecoder = (value) => { + let cache = (x) => { + const decoder = value(); + const result = decoder; + cache = decoder; + return result(x); + }; + return (x) => cache(x); +}; +const Self = (value) => createCodec( + selfEncoder(() => value().enc), + selfDecoder(() => value().dec) +); + +export { Self, selfDecoder, selfEncoder }; +//# sourceMappingURL=Self.mjs.map diff --git a/packages/bizinikiwi-bindings/dist/esm/codecs/scale/Self.mjs.map b/packages/bizinikiwi-bindings/dist/esm/codecs/scale/Self.mjs.map new file mode 100644 index 0000000..db78eda --- /dev/null +++ b/packages/bizinikiwi-bindings/dist/esm/codecs/scale/Self.mjs.map @@ -0,0 +1 @@ +{"version":3,"file":"Self.mjs","sources":["../../../../src/codecs/scale/Self.ts"],"sourcesContent":["import { Codec, Decoder, Encoder, createCodec, _void } from \"scale-ts\"\n\nexport const selfEncoder = (value: () => Encoder): Encoder => {\n let cache: Encoder = (x) => {\n const encoder = value()\n cache = encoder\n return encoder(x)\n }\n\n return (x) => cache(x)\n}\n\nexport const selfDecoder = (value: () => Decoder): Decoder => {\n let cache: Decoder = (x) => {\n const decoder = value()\n const result = decoder\n cache = decoder\n return result(x)\n }\n\n return (x) => cache(x)\n}\n\nexport const Self = (value: () => Codec): Codec =>\n createCodec(\n selfEncoder(() => value().enc),\n selfDecoder(() => value().dec),\n )\n"],"names":[],"mappings":";;AAEO,MAAM,WAAA,GAAc,CAAI,KAAA,KAAwC;AACrE,EAAA,IAAI,KAAA,GAAoB,CAAC,CAAA,KAAM;AAC7B,IAAA,MAAM,UAAU,KAAA,EAAM;AACtB,IAAA,KAAA,GAAQ,OAAA;AACR,IAAA,OAAO,QAAQ,CAAC,CAAA;AAAA,EAClB,CAAA;AAEA,EAAA,OAAO,CAAC,CAAA,KAAM,KAAA,CAAM,CAAC,CAAA;AACvB;AAEO,MAAM,WAAA,GAAc,CAAI,KAAA,KAAwC;AACrE,EAAA,IAAI,KAAA,GAAoB,CAAC,CAAA,KAAM;AAC7B,IAAA,MAAM,UAAU,KAAA,EAAM;AACtB,IAAA,MAAM,MAAA,GAAS,OAAA;AACf,IAAA,KAAA,GAAQ,OAAA;AACR,IAAA,OAAO,OAAO,CAAC,CAAA;AAAA,EACjB,CAAA;AAEA,EAAA,OAAO,CAAC,CAAA,KAAM,KAAA,CAAM,CAAC,CAAA;AACvB;AAEO,MAAM,IAAA,GAAO,CAAI,KAAA,KACtB,WAAA;AAAA,EACE,WAAA,CAAY,MAAM,KAAA,EAAM,CAAE,GAAG,CAAA;AAAA,EAC7B,WAAA,CAAY,MAAM,KAAA,EAAM,CAAE,GAAG;AAC/B;;;;"} \ No newline at end of file diff --git a/packages/bizinikiwi-bindings/dist/esm/codecs/scale/Variant.mjs b/packages/bizinikiwi-bindings/dist/esm/codecs/scale/Variant.mjs new file mode 100644 index 0000000..1ce9e93 --- /dev/null +++ b/packages/bizinikiwi-bindings/dist/esm/codecs/scale/Variant.mjs @@ -0,0 +1,37 @@ +import { createCodec, Enum } from 'scale-ts'; +import { mapObject } from '@pezkuwi/papi-utils'; +import { Enum as Enum$1 } from '../../types/enum.mjs'; +import { withInner } from './with-inner.mjs'; + +const VariantEnc = (...args) => { + const enc = Enum.enc(...args); + return withInner((v) => enc({ tag: v.type, value: v.value }), args[0]); +}; +const VariantDec = (...args) => { + const dec = Enum.dec(...args); + return withInner((v) => { + const { tag, value } = dec(v); + return Enum$1(tag, value); + }, args[0]); +}; +const Variant = (inner, ...args) => withInner( + createCodec( + VariantEnc( + mapObject(inner, ([encoder]) => encoder), + ...args + ), + VariantDec( + mapObject(inner, ([, decoder]) => decoder), + ...args + ) + ), + inner +); +Variant.enc = VariantEnc; +Variant.dec = VariantDec; +const ScaleEnum = (inner, ...args) => withInner(Enum(inner, ...args), inner); +ScaleEnum.enc = (inner, ...rest) => withInner(Enum.enc(inner, ...rest), inner); +ScaleEnum.dec = (inner, ...rest) => withInner(Enum.dec(inner, ...rest), inner); + +export { ScaleEnum, Variant }; +//# sourceMappingURL=Variant.mjs.map diff --git a/packages/bizinikiwi-bindings/dist/esm/codecs/scale/Variant.mjs.map b/packages/bizinikiwi-bindings/dist/esm/codecs/scale/Variant.mjs.map new file mode 100644 index 0000000..2ff0b72 --- /dev/null +++ b/packages/bizinikiwi-bindings/dist/esm/codecs/scale/Variant.mjs.map @@ -0,0 +1 @@ +{"version":3,"file":"Variant.mjs","sources":["../../../../src/codecs/scale/Variant.ts"],"sourcesContent":["import {\n Codec,\n CodecType,\n Decoder,\n DecoderType,\n Encoder,\n EncoderType,\n Enum as OEnum,\n StringRecord,\n createCodec,\n} from \"scale-ts\"\nimport { mapObject } from \"@pezkuwi/papi-utils\"\nimport { Enum } from \"@/types/enum\"\nimport { withInner } from \"./with-inner\"\n\ntype Tuple = readonly [T, ...T[]] & { length: N }\n\ntype Push = [...T, V]\n\ntype UnionToIntersection = (U extends any ? (k: U) => void : never) extends (\n k: infer I,\n) => void\n ? I\n : never\n\ntype LastOf =\n UnionToIntersection T : never> extends () => infer R\n ? R\n : never\n\ntype TuplifyUnion<\n T,\n L = LastOf,\n N = [T] extends [never] ? true : false,\n> = true extends N ? [] : Push>, L>\n\ntype RestrictedLenTuple> = Tuple<\n T,\n TuplifyUnion extends Tuple ? V : 0\n>\n\nconst VariantEnc: >>(\n inner: O,\n x?: RestrictedLenTuple | undefined,\n) => Encoder<\n Enum<{\n [K in keyof O]: EncoderType\n }>\n> & { inner: O } = (...args) => {\n const enc = OEnum.enc(...(args as [any, any]))\n return withInner((v: any) => enc({ tag: v.type, value: v.value }), args[0])\n}\n\nconst VariantDec: >>(\n inner: O,\n x?: RestrictedLenTuple | undefined,\n) => Decoder<\n Enum<{\n [K in keyof O]: DecoderType\n }>\n> & { inner: O } = (...args) => {\n const dec = OEnum.dec(...(args as [any]))\n return withInner((v: any) => {\n const { tag, value } = dec(v)\n return Enum(tag as any, value as any) as any\n }, args[0])\n}\n\nexport const Variant: {\n >>(\n inner: O,\n indexes?: RestrictedLenTuple | undefined,\n ): Codec<\n Enum<{\n [K in keyof O]: CodecType\n }>\n > & { inner: O }\n enc: >>(\n inner: O_1,\n x?: RestrictedLenTuple | undefined,\n ) => Encoder<\n Enum<{\n [K in keyof O_1]: EncoderType\n }>\n > & { inner: O_1 }\n dec: >>(\n inner: O_2,\n x?: RestrictedLenTuple | undefined,\n ) => Decoder<\n Enum<{\n [K in keyof O_2]: DecoderType\n }>\n > & { inner: O_2 }\n} = (inner, ...args) =>\n withInner(\n createCodec(\n VariantEnc(\n mapObject(inner, ([encoder]) => encoder) as any,\n ...(args as any[]),\n ),\n VariantDec(\n mapObject(inner, ([, decoder]) => decoder) as any,\n ...(args as any[]),\n ) as any,\n ),\n inner,\n ) as any\nVariant.enc = VariantEnc\nVariant.dec = VariantDec\n\nexport const ScaleEnum: {\n >>(\n inner: O,\n indexes?: RestrictedLenTuple | undefined,\n ): Codec<\n {\n [K in keyof O]: {\n tag: K\n value: CodecType\n }\n }[keyof O]\n > & { inner: O }\n enc: >>(\n inner: O_1,\n x?: RestrictedLenTuple | undefined,\n ) => Encoder<\n {\n [K_1 in keyof O_1]: {\n tag: K_1\n value: EncoderType\n }\n }[keyof O_1]\n > & { inner: O_1 }\n dec: >>(\n inner: O_2,\n x?: RestrictedLenTuple | undefined,\n ) => Decoder<\n {\n [K_2 in keyof O_2]: {\n tag: K_2\n value: DecoderType\n }\n }[keyof O_2]\n > & { inner: O_2 }\n} = (inner, ...args) => withInner(OEnum(inner, ...(args as any[])), inner)\nScaleEnum.enc = (inner, ...rest) =>\n withInner(OEnum.enc(inner, ...(rest as any[])), inner)\nScaleEnum.dec = (inner, ...rest) =>\n withInner(OEnum.dec(inner, ...(rest as any[])), inner)\n"],"names":["OEnum","Enum"],"mappings":";;;;;AAyCA,MAAM,UAAA,GAOa,IAAI,IAAA,KAAS;AAC9B,EAAA,MAAM,GAAA,GAAMA,IAAA,CAAM,GAAA,CAAI,GAAI,IAAmB,CAAA;AAC7C,EAAA,OAAO,SAAA,CAAU,CAAC,CAAA,KAAW,GAAA,CAAI,EAAE,GAAA,EAAK,CAAA,CAAE,IAAA,EAAM,KAAA,EAAO,EAAE,KAAA,EAAO,CAAA,EAAG,IAAA,CAAK,CAAC,CAAC,CAAA;AAC5E,CAAA;AAEA,MAAM,UAAA,GAOa,IAAI,IAAA,KAAS;AAC9B,EAAA,MAAM,GAAA,GAAMA,IAAA,CAAM,GAAA,CAAI,GAAI,IAAc,CAAA;AACxC,EAAA,OAAO,SAAA,CAAU,CAAC,CAAA,KAAW;AAC3B,IAAA,MAAM,EAAE,GAAA,EAAK,KAAA,EAAM,GAAI,IAAI,CAAC,CAAA;AAC5B,IAAA,OAAOC,MAAA,CAAK,KAAY,KAAY,CAAA;AAAA,EACtC,CAAA,EAAG,IAAA,CAAK,CAAC,CAAC,CAAA;AACZ,CAAA;AAEO,MAAM,OAAA,GAyBT,CAAC,KAAA,EAAA,GAAU,IAAA,KACb,SAAA;AAAA,EACE,WAAA;AAAA,IACE,UAAA;AAAA,MACE,UAAU,KAAA,EAAO,CAAC,CAAC,OAAO,MAAM,OAAO,CAAA;AAAA,MACvC,GAAI;AAAA,KACN;AAAA,IACA,UAAA;AAAA,MACE,UAAU,KAAA,EAAO,CAAC,GAAG,OAAO,MAAM,OAAO,CAAA;AAAA,MACzC,GAAI;AAAA;AACN,GACF;AAAA,EACA;AACF;AACF,OAAA,CAAQ,GAAA,GAAM,UAAA;AACd,OAAA,CAAQ,GAAA,GAAM,UAAA;AAEP,MAAM,SAAA,GAkCT,CAAC,KAAA,EAAA,GAAU,IAAA,KAAS,SAAA,CAAUD,KAAM,KAAA,EAAO,GAAI,IAAc,CAAA,EAAG,KAAK;AACzE,SAAA,CAAU,GAAA,GAAM,CAAC,KAAA,EAAA,GAAU,IAAA,KACzB,SAAA,CAAUA,IAAA,CAAM,GAAA,CAAI,KAAA,EAAO,GAAI,IAAc,CAAA,EAAG,KAAK,CAAA;AACvD,SAAA,CAAU,GAAA,GAAM,CAAC,KAAA,EAAA,GAAU,IAAA,KACzB,SAAA,CAAUA,IAAA,CAAM,GAAA,CAAI,KAAA,EAAO,GAAI,IAAc,CAAA,EAAG,KAAK,CAAA;;;;"} \ No newline at end of file diff --git a/packages/bizinikiwi-bindings/dist/esm/codecs/scale/bitSequence.mjs b/packages/bizinikiwi-bindings/dist/esm/codecs/scale/bitSequence.mjs new file mode 100644 index 0000000..19e693b --- /dev/null +++ b/packages/bizinikiwi-bindings/dist/esm/codecs/scale/bitSequence.mjs @@ -0,0 +1,24 @@ +import { createDecoder, Bytes, createCodec } from 'scale-ts'; +import { compactNumber } from './compact.mjs'; + +const bitSequenceDecoder = createDecoder((data) => { + const bitsLen = compactNumber.dec(data); + const bytesLen = Math.ceil(bitsLen / 8); + const bytes = Bytes(bytesLen).dec(data); + return { bytes, bitsLen }; +}); +const bitSequenceEncoder = (input) => { + if (input.bitsLen > input.bytes.length * 8) + throw new Error( + `Not enough bytes. (bitsLen:${input.bitsLen}, bytesLen:${input.bytes.length})` + ); + const lenEncoded = compactNumber.enc(input.bitsLen); + const result = new Uint8Array(input.bytes.length + lenEncoded.length); + result.set(lenEncoded, 0); + result.set(input.bytes, lenEncoded.length); + return result; +}; +const bitSequence$1 = createCodec(bitSequenceEncoder, bitSequenceDecoder); + +export { bitSequence$1 as bitSequence }; +//# sourceMappingURL=bitSequence.mjs.map diff --git a/packages/bizinikiwi-bindings/dist/esm/codecs/scale/bitSequence.mjs.map b/packages/bizinikiwi-bindings/dist/esm/codecs/scale/bitSequence.mjs.map new file mode 100644 index 0000000..84407d3 --- /dev/null +++ b/packages/bizinikiwi-bindings/dist/esm/codecs/scale/bitSequence.mjs.map @@ -0,0 +1 @@ +{"version":3,"file":"bitSequence.mjs","sources":["../../../../src/codecs/scale/bitSequence.ts"],"sourcesContent":["import { Bytes, Decoder, Encoder, createCodec, createDecoder } from \"scale-ts\"\nimport { compactNumber } from \"./compact\"\n\nexport interface BitSequence {\n bitsLen: number\n bytes: Uint8Array\n}\n\nconst bitSequenceDecoder: Decoder = createDecoder((data) => {\n const bitsLen = compactNumber.dec(data)\n\n const bytesLen = Math.ceil(bitsLen / 8)\n const bytes = Bytes(bytesLen).dec(data)\n return { bytes, bitsLen }\n})\n\nconst bitSequenceEncoder: Encoder = (input) => {\n if (input.bitsLen > input.bytes.length * 8)\n throw new Error(\n `Not enough bytes. (bitsLen:${input.bitsLen}, bytesLen:${input.bytes.length})`,\n )\n\n const lenEncoded = compactNumber.enc(input.bitsLen)\n const result = new Uint8Array(input.bytes.length + lenEncoded.length)\n result.set(lenEncoded, 0)\n result.set(input.bytes, lenEncoded.length)\n return result\n}\n\nexport const bitSequence = createCodec(bitSequenceEncoder, bitSequenceDecoder)\n"],"names":["bitSequence"],"mappings":";;;AAQA,MAAM,kBAAA,GAA2C,aAAA,CAAc,CAAC,IAAA,KAAS;AACvE,EAAA,MAAM,OAAA,GAAU,aAAA,CAAc,GAAA,CAAI,IAAI,CAAA;AAEtC,EAAA,MAAM,QAAA,GAAW,IAAA,CAAK,IAAA,CAAK,OAAA,GAAU,CAAC,CAAA;AACtC,EAAA,MAAM,KAAA,GAAQ,KAAA,CAAM,QAAQ,CAAA,CAAE,IAAI,IAAI,CAAA;AACtC,EAAA,OAAO,EAAE,OAAO,OAAA,EAAQ;AAC1B,CAAC,CAAA;AAED,MAAM,kBAAA,GAA2C,CAAC,KAAA,KAAU;AAC1D,EAAA,IAAI,KAAA,CAAM,OAAA,GAAU,KAAA,CAAM,KAAA,CAAM,MAAA,GAAS,CAAA;AACvC,IAAA,MAAM,IAAI,KAAA;AAAA,MACR,8BAA8B,KAAA,CAAM,OAAO,CAAA,WAAA,EAAc,KAAA,CAAM,MAAM,MAAM,CAAA,CAAA;AAAA,KAC7E;AAEF,EAAA,MAAM,UAAA,GAAa,aAAA,CAAc,GAAA,CAAI,KAAA,CAAM,OAAO,CAAA;AAClD,EAAA,MAAM,SAAS,IAAI,UAAA,CAAW,MAAM,KAAA,CAAM,MAAA,GAAS,WAAW,MAAM,CAAA;AACpE,EAAA,MAAA,CAAO,GAAA,CAAI,YAAY,CAAC,CAAA;AACxB,EAAA,MAAA,CAAO,GAAA,CAAI,KAAA,CAAM,KAAA,EAAO,UAAA,CAAW,MAAM,CAAA;AACzC,EAAA,OAAO,MAAA;AACT,CAAA;AAEO,MAAMA,aAAA,GAAc,WAAA,CAAY,kBAAA,EAAoB,kBAAkB;;;;"} \ No newline at end of file diff --git a/packages/bizinikiwi-bindings/dist/esm/codecs/scale/char.mjs b/packages/bizinikiwi-bindings/dist/esm/codecs/scale/char.mjs new file mode 100644 index 0000000..f3f8934 --- /dev/null +++ b/packages/bizinikiwi-bindings/dist/esm/codecs/scale/char.mjs @@ -0,0 +1,10 @@ +import { enhanceCodec, u8 } from 'scale-ts'; + +const char = enhanceCodec( + u8, + (str) => str.charCodeAt(0), + String.fromCharCode +); + +export { char }; +//# sourceMappingURL=char.mjs.map diff --git a/packages/bizinikiwi-bindings/dist/esm/codecs/scale/char.mjs.map b/packages/bizinikiwi-bindings/dist/esm/codecs/scale/char.mjs.map new file mode 100644 index 0000000..84e17f1 --- /dev/null +++ b/packages/bizinikiwi-bindings/dist/esm/codecs/scale/char.mjs.map @@ -0,0 +1 @@ +{"version":3,"file":"char.mjs","sources":["../../../../src/codecs/scale/char.ts"],"sourcesContent":["import { enhanceCodec, u8 } from \"scale-ts\"\n\nexport const char = enhanceCodec(\n u8,\n (str: string) => str.charCodeAt(0),\n String.fromCharCode,\n)\n"],"names":[],"mappings":";;AAEO,MAAM,IAAA,GAAO,YAAA;AAAA,EAClB,EAAA;AAAA,EACA,CAAC,GAAA,KAAgB,GAAA,CAAI,UAAA,CAAW,CAAC,CAAA;AAAA,EACjC,MAAA,CAAO;AACT;;;;"} \ No newline at end of file diff --git a/packages/bizinikiwi-bindings/dist/esm/codecs/scale/compact.mjs b/packages/bizinikiwi-bindings/dist/esm/codecs/scale/compact.mjs new file mode 100644 index 0000000..af34665 --- /dev/null +++ b/packages/bizinikiwi-bindings/dist/esm/codecs/scale/compact.mjs @@ -0,0 +1,7 @@ +import { enhanceCodec, compact } from 'scale-ts'; + +const compactNumber = enhanceCodec(compact, (v) => v, Number); +const compactBn = enhanceCodec(compact, (v) => v, BigInt); + +export { compactBn, compactNumber }; +//# sourceMappingURL=compact.mjs.map diff --git a/packages/bizinikiwi-bindings/dist/esm/codecs/scale/compact.mjs.map b/packages/bizinikiwi-bindings/dist/esm/codecs/scale/compact.mjs.map new file mode 100644 index 0000000..a7556fb --- /dev/null +++ b/packages/bizinikiwi-bindings/dist/esm/codecs/scale/compact.mjs.map @@ -0,0 +1 @@ +{"version":3,"file":"compact.mjs","sources":["../../../../src/codecs/scale/compact.ts"],"sourcesContent":["import { compact, enhanceCodec } from \"scale-ts\"\n\nexport const compactNumber = enhanceCodec(compact, (v) => v, Number)\nexport const compactBn = enhanceCodec(compact, (v) => v, BigInt)\n"],"names":[],"mappings":";;AAEO,MAAM,gBAAgB,YAAA,CAAa,OAAA,EAAS,CAAC,CAAA,KAAM,GAAG,MAAM;AAC5D,MAAM,YAAY,YAAA,CAAa,OAAA,EAAS,CAAC,CAAA,KAAM,GAAG,MAAM;;;;"} \ No newline at end of file diff --git a/packages/bizinikiwi-bindings/dist/esm/codecs/scale/ethAccount.mjs b/packages/bizinikiwi-bindings/dist/esm/codecs/scale/ethAccount.mjs new file mode 100644 index 0000000..419262f --- /dev/null +++ b/packages/bizinikiwi-bindings/dist/esm/codecs/scale/ethAccount.mjs @@ -0,0 +1,37 @@ +import { fromHex, toHex } from '@pezkuwi/papi-utils'; +import { Bytes, createCodec, createDecoder } from 'scale-ts'; +import '@noble/hashes/blake2.js'; +import '@noble/hashes/blake3.js'; +import { Keccak256 } from '../../hashes/keccak.mjs'; +import { textEncoder } from './fixed-str.mjs'; + +const getFormattedAddress = (hexAddress) => { + const nonChecksum = hexAddress.slice(2); + const hashedAddress = toHex(Keccak256(textEncoder.encode(nonChecksum))).slice( + 2 + ); + const result = new Array(40); + for (let i = 0; i < 40; i++) { + const checksumVal = parseInt(hashedAddress[i], 16); + const char = nonChecksum[i]; + result[i] = checksumVal > 7 ? char.toUpperCase() : char; + } + return `0x${result.join("")}`; +}; +const bytes20Dec = Bytes(20)[1]; +const ethAccount = createCodec( + (input) => { + const bytes = fromHex(input); + if (bytes.length !== 20) + throw new Error(`Invalid length found on EthAddress(${input})`); + const hexAddress = toHex(bytes); + if (input === hexAddress || input === hexAddress.toUpperCase()) return bytes; + if (getFormattedAddress(hexAddress) !== input) + throw new Error(`Invalid checksum found on EthAddress(${input})`); + return bytes; + }, + createDecoder((bytes) => getFormattedAddress(toHex(bytes20Dec(bytes)))) +); + +export { ethAccount }; +//# sourceMappingURL=ethAccount.mjs.map diff --git a/packages/bizinikiwi-bindings/dist/esm/codecs/scale/ethAccount.mjs.map b/packages/bizinikiwi-bindings/dist/esm/codecs/scale/ethAccount.mjs.map new file mode 100644 index 0000000..5bab464 --- /dev/null +++ b/packages/bizinikiwi-bindings/dist/esm/codecs/scale/ethAccount.mjs.map @@ -0,0 +1 @@ +{"version":3,"file":"ethAccount.mjs","sources":["../../../../src/codecs/scale/ethAccount.ts"],"sourcesContent":["import { fromHex, toHex } from \"@pezkuwi/papi-utils\"\nimport { Bytes, createCodec, createDecoder } from \"scale-ts\"\nimport { Keccak256 } from \"../../hashes\"\nimport { textEncoder } from \"./fixed-str\"\n\nconst getFormattedAddress = (hexAddress: string) => {\n const nonChecksum = hexAddress.slice(2)\n const hashedAddress = toHex(Keccak256(textEncoder.encode(nonChecksum))).slice(\n 2,\n )\n const result = new Array(40)\n\n for (let i = 0; i < 40; i++) {\n const checksumVal = parseInt(hashedAddress[i], 16)\n const char = nonChecksum[i]\n result[i] = checksumVal > 7 ? char.toUpperCase() : char\n }\n\n return `0x${result.join(\"\")}`\n}\n\nconst bytes20Dec = Bytes(20)[1]\n\nexport const ethAccount = createCodec(\n (input: string) => {\n const bytes = fromHex(input)\n if (bytes.length !== 20)\n throw new Error(`Invalid length found on EthAddress(${input})`)\n\n const hexAddress = toHex(bytes)\n if (input === hexAddress || input === hexAddress.toUpperCase()) return bytes\n\n if (getFormattedAddress(hexAddress) !== input)\n throw new Error(`Invalid checksum found on EthAddress(${input})`)\n\n return bytes\n },\n createDecoder((bytes) => getFormattedAddress(toHex(bytes20Dec(bytes)))),\n)\n"],"names":[],"mappings":";;;;;;;AAKA,MAAM,mBAAA,GAAsB,CAAC,UAAA,KAAuB;AAClD,EAAA,MAAM,WAAA,GAAc,UAAA,CAAW,KAAA,CAAM,CAAC,CAAA;AACtC,EAAA,MAAM,aAAA,GAAgB,MAAM,SAAA,CAAU,WAAA,CAAY,OAAO,WAAW,CAAC,CAAC,CAAA,CAAE,KAAA;AAAA,IACtE;AAAA,GACF;AACA,EAAA,MAAM,MAAA,GAAS,IAAI,KAAA,CAAM,EAAE,CAAA;AAE3B,EAAA,KAAA,IAAS,CAAA,GAAI,CAAA,EAAG,CAAA,GAAI,EAAA,EAAI,CAAA,EAAA,EAAK;AAC3B,IAAA,MAAM,WAAA,GAAc,QAAA,CAAS,aAAA,CAAc,CAAC,GAAG,EAAE,CAAA;AACjD,IAAA,MAAM,IAAA,GAAO,YAAY,CAAC,CAAA;AAC1B,IAAA,MAAA,CAAO,CAAC,CAAA,GAAI,WAAA,GAAc,CAAA,GAAI,IAAA,CAAK,aAAY,GAAI,IAAA;AAAA,EACrD;AAEA,EAAA,OAAO,CAAA,EAAA,EAAK,MAAA,CAAO,IAAA,CAAK,EAAE,CAAC,CAAA,CAAA;AAC7B,CAAA;AAEA,MAAM,UAAA,GAAa,KAAA,CAAM,EAAE,CAAA,CAAE,CAAC,CAAA;AAEvB,MAAM,UAAA,GAAa,WAAA;AAAA,EACxB,CAAC,KAAA,KAAkB;AACjB,IAAA,MAAM,KAAA,GAAQ,QAAQ,KAAK,CAAA;AAC3B,IAAA,IAAI,MAAM,MAAA,KAAW,EAAA;AACnB,MAAA,MAAM,IAAI,KAAA,CAAM,CAAA,mCAAA,EAAsC,KAAK,CAAA,CAAA,CAAG,CAAA;AAEhE,IAAA,MAAM,UAAA,GAAa,MAAM,KAAK,CAAA;AAC9B,IAAA,IAAI,UAAU,UAAA,IAAc,KAAA,KAAU,UAAA,CAAW,WAAA,IAAe,OAAO,KAAA;AAEvE,IAAA,IAAI,mBAAA,CAAoB,UAAU,CAAA,KAAM,KAAA;AACtC,MAAA,MAAM,IAAI,KAAA,CAAM,CAAA,qCAAA,EAAwC,KAAK,CAAA,CAAA,CAAG,CAAA;AAElE,IAAA,OAAO,KAAA;AAAA,EACT,CAAA;AAAA,EACA,aAAA,CAAc,CAAC,KAAA,KAAU,mBAAA,CAAoB,MAAM,UAAA,CAAW,KAAK,CAAC,CAAC,CAAC;AACxE;;;;"} \ No newline at end of file diff --git a/packages/bizinikiwi-bindings/dist/esm/codecs/scale/fixed-str.mjs b/packages/bizinikiwi-bindings/dist/esm/codecs/scale/fixed-str.mjs new file mode 100644 index 0000000..e5d835c --- /dev/null +++ b/packages/bizinikiwi-bindings/dist/esm/codecs/scale/fixed-str.mjs @@ -0,0 +1,12 @@ +import { enhanceCodec, Bytes } from 'scale-ts'; + +const textEncoder$2 = new TextEncoder(); +const textDecoder$1 = new TextDecoder(); +const fixedStr = (nBytes) => enhanceCodec( + Bytes(nBytes), + (str) => textEncoder$2.encode(str), + (bytes) => textDecoder$1.decode(bytes) +); + +export { fixedStr, textEncoder$2 as textEncoder }; +//# sourceMappingURL=fixed-str.mjs.map diff --git a/packages/bizinikiwi-bindings/dist/esm/codecs/scale/fixed-str.mjs.map b/packages/bizinikiwi-bindings/dist/esm/codecs/scale/fixed-str.mjs.map new file mode 100644 index 0000000..08b4efa --- /dev/null +++ b/packages/bizinikiwi-bindings/dist/esm/codecs/scale/fixed-str.mjs.map @@ -0,0 +1 @@ +{"version":3,"file":"fixed-str.mjs","sources":["../../../../src/codecs/scale/fixed-str.ts"],"sourcesContent":["import { Bytes, enhanceCodec } from \"scale-ts\"\n\nexport const textEncoder = new TextEncoder()\nconst textDecoder = new TextDecoder()\n\nexport const fixedStr = (nBytes: number) =>\n enhanceCodec(\n Bytes(nBytes),\n (str: string) => textEncoder.encode(str),\n (bytes) => textDecoder.decode(bytes),\n )\n"],"names":["textEncoder","textDecoder"],"mappings":";;AAEO,MAAMA,aAAA,GAAc,IAAI,WAAA;AAC/B,MAAMC,aAAA,GAAc,IAAI,WAAA,EAAY;AAE7B,MAAM,QAAA,GAAW,CAAC,MAAA,KACvB,YAAA;AAAA,EACE,MAAM,MAAM,CAAA;AAAA,EACZ,CAAC,GAAA,KAAgBD,aAAA,CAAY,MAAA,CAAO,GAAG,CAAA;AAAA,EACvC,CAAC,KAAA,KAAUC,aAAA,CAAY,MAAA,CAAO,KAAK;AACrC;;;;"} \ No newline at end of file diff --git a/packages/bizinikiwi-bindings/dist/esm/codecs/scale/shaped.mjs b/packages/bizinikiwi-bindings/dist/esm/codecs/scale/shaped.mjs new file mode 100644 index 0000000..3c98e2b --- /dev/null +++ b/packages/bizinikiwi-bindings/dist/esm/codecs/scale/shaped.mjs @@ -0,0 +1,21 @@ +import { Struct as Struct$1, Vector as Vector$1, Tuple as Tuple$1, Result as Result$1, Option as Option$1 } from 'scale-ts'; +import { withInner } from './with-inner.mjs'; + +const Struct = (codecs) => withInner(Struct$1(codecs), codecs); +Struct.enc = (x) => withInner(Struct$1.enc(x), x); +Struct.dec = (x) => withInner(Struct$1.dec(x), x); +const Tuple = (...inner) => withInner(Tuple$1(...inner), inner); +Tuple.enc = (...inner) => withInner(Tuple$1.enc(...inner), inner); +Tuple.dec = (...inner) => withInner(Tuple$1.dec(...inner), inner); +const Vector = (inner, ...rest) => withInner(Vector$1(inner, ...rest), inner); +Vector.enc = (inner, ...rest) => withInner(Vector$1.enc(inner, ...rest), inner); +Vector.dec = (inner, ...rest) => withInner(Vector$1.dec(inner, ...rest), inner); +const Result = (ok, ko) => withInner(Result$1(ok, ko), { ok, ko }); +Result.enc = (ok, ko) => withInner(Result$1.enc(ok, ko), { ok, ko }); +Result.dec = (ok, ko) => withInner(Result$1.dec(ok, ko), { ok, ko }); +const Option = (inner) => withInner(Option$1(inner), inner); +Option.enc = (inner) => withInner(Option$1.enc(inner), inner); +Option.dec = (inner) => withInner(Option$1.dec(inner), inner); + +export { Option, Result, Struct, Tuple, Vector }; +//# sourceMappingURL=shaped.mjs.map diff --git a/packages/bizinikiwi-bindings/dist/esm/codecs/scale/shaped.mjs.map b/packages/bizinikiwi-bindings/dist/esm/codecs/scale/shaped.mjs.map new file mode 100644 index 0000000..3ae8b42 --- /dev/null +++ b/packages/bizinikiwi-bindings/dist/esm/codecs/scale/shaped.mjs.map @@ -0,0 +1 @@ +{"version":3,"file":"shaped.mjs","sources":["../../../../src/codecs/scale/shaped.ts"],"sourcesContent":["import {\n Struct as OStruct,\n Tuple as OTuple,\n Vector as OVector,\n Result as OResult,\n Option as OOption,\n Codec,\n Encoder,\n Decoder,\n StringRecord,\n CodecType,\n EncoderType,\n DecoderType,\n ResultPayload,\n} from \"scale-ts\"\nimport { withInner } from \"./with-inner\"\n\nexport const Struct: {\n >>(\n codecs: A,\n ): Codec<{ [K in keyof A]: CodecType }> & { inner: A }\n enc: >>(\n encoders: A_1,\n ) => Encoder<{ [K_1 in keyof A_1]: EncoderType }> & { inner: A_1 }\n dec: >>(\n decoders: A_2,\n ) => Decoder<{ [K_2 in keyof A_2]: DecoderType }> & { inner: A_2 }\n} = (codecs) => withInner(OStruct(codecs), codecs)\nStruct.enc = (x) => withInner(OStruct.enc(x), x)\nStruct.dec = (x) => withInner(OStruct.dec(x), x)\n\nexport const Tuple: {\n []>(\n ...inner: A\n ): Codec<{ [K in keyof A]: A[K] extends Codec ? D : unknown }> & {\n inner: A\n }\n enc: []>(\n ...encoders: A_1\n ) => Encoder<{\n [K_1 in keyof A_1]: A_1[K_1] extends Encoder ? D_1 : unknown\n }> & { inner: A_1 }\n dec: []>(\n ...decoders: A_2\n ) => Decoder<{\n [K_2 in keyof A_2]: A_2[K_2] extends Decoder ? D_2 : unknown\n }> & { inner: A_2 }\n} = (...inner) => withInner(OTuple(...inner), inner)\nTuple.enc = (...inner) => withInner(OTuple.enc(...inner), inner)\nTuple.dec = (...inner) => withInner(OTuple.dec(...inner), inner)\n\nexport const Vector: {\n (\n inner: Codec,\n size?: number | undefined,\n ): Codec & { inner: Codec }\n enc: (\n inner: Encoder,\n size?: number | undefined,\n ) => Encoder & { inner: Encoder }\n dec: (\n getter: Decoder,\n size?: number | undefined,\n ) => Decoder & { inner: Decoder }\n} = (inner, ...rest) => withInner(OVector(inner, ...rest), inner)\nVector.enc = (inner, ...rest) => withInner(OVector.enc(inner, ...rest), inner)\nVector.dec = (inner, ...rest) => withInner(OVector.dec(inner, ...rest), inner)\n\nexport const Result: {\n (\n okCodec: Codec,\n koCodec: Codec,\n ): Codec> & { inner: { ok: Codec; ko: Codec } }\n dec: (\n okDecoder: Decoder,\n koDecoder: Decoder,\n ) => Decoder> & {\n inner: { ok: Decoder; ko: Decoder }\n }\n enc: (\n okEncoder: Encoder,\n koEncoder: Encoder,\n ) => Encoder> & {\n inner: { ok: Encoder; ko: Encoder }\n }\n} = (ok, ko) => withInner(OResult(ok, ko), { ok, ko })\nResult.enc = (ok, ko) => withInner(OResult.enc(ok, ko), { ok, ko })\nResult.dec = (ok, ko) => withInner(OResult.dec(ok, ko), { ok, ko })\n\nexport const Option: {\n (inner: Codec): Codec & { inner: Codec }\n enc: (\n inner: Encoder,\n ) => Encoder & { inner: Encoder }\n dec: (\n inner: Decoder,\n ) => Decoder & { inner: Decoder }\n} = (inner) => withInner(OOption(inner), inner)\nOption.enc = (inner) => withInner(OOption.enc(inner), inner)\nOption.dec = (inner) => withInner(OOption.dec(inner), inner)\n"],"names":["OStruct","OTuple","OVector","OResult","OOption"],"mappings":";;;AAiBO,MAAM,SAUT,CAAC,MAAA,KAAW,UAAUA,QAAA,CAAQ,MAAM,GAAG,MAAM;AACjD,MAAA,CAAO,GAAA,GAAM,CAAC,CAAA,KAAM,SAAA,CAAUA,SAAQ,GAAA,CAAI,CAAC,GAAG,CAAC,CAAA;AAC/C,MAAA,CAAO,GAAA,GAAM,CAAC,CAAA,KAAM,SAAA,CAAUA,SAAQ,GAAA,CAAI,CAAC,GAAG,CAAC,CAAA;AAExC,MAAM,KAAA,GAgBT,IAAI,KAAA,KAAU,SAAA,CAAUC,QAAO,GAAG,KAAK,GAAG,KAAK;AACnD,KAAA,CAAM,GAAA,GAAM,IAAI,KAAA,KAAU,SAAA,CAAUA,QAAO,GAAA,CAAI,GAAG,KAAK,CAAA,EAAG,KAAK,CAAA;AAC/D,KAAA,CAAM,GAAA,GAAM,IAAI,KAAA,KAAU,SAAA,CAAUA,QAAO,GAAA,CAAI,GAAG,KAAK,CAAA,EAAG,KAAK,CAAA;AAExD,MAAM,MAAA,GAaT,CAAC,KAAA,EAAA,GAAU,IAAA,KAAS,SAAA,CAAUC,SAAQ,KAAA,EAAO,GAAG,IAAI,CAAA,EAAG,KAAK;AAChE,MAAA,CAAO,GAAA,GAAM,CAAC,KAAA,EAAA,GAAU,IAAA,KAAS,SAAA,CAAUA,QAAA,CAAQ,GAAA,CAAI,KAAA,EAAO,GAAG,IAAI,CAAA,EAAG,KAAK,CAAA;AAC7E,MAAA,CAAO,GAAA,GAAM,CAAC,KAAA,EAAA,GAAU,IAAA,KAAS,SAAA,CAAUA,QAAA,CAAQ,GAAA,CAAI,KAAA,EAAO,GAAG,IAAI,CAAA,EAAG,KAAK,CAAA;AAEtE,MAAM,MAAA,GAiBT,CAAC,EAAA,EAAI,EAAA,KAAO,SAAA,CAAUC,QAAA,CAAQ,EAAA,EAAI,EAAE,CAAA,EAAG,EAAE,EAAA,EAAI,EAAA,EAAI;AACrD,MAAA,CAAO,GAAA,GAAM,CAAC,EAAA,EAAI,EAAA,KAAO,SAAA,CAAUA,QAAA,CAAQ,GAAA,CAAI,EAAA,EAAI,EAAE,CAAA,EAAG,EAAE,EAAA,EAAI,IAAI,CAAA;AAClE,MAAA,CAAO,GAAA,GAAM,CAAC,EAAA,EAAI,EAAA,KAAO,SAAA,CAAUA,QAAA,CAAQ,GAAA,CAAI,EAAA,EAAI,EAAE,CAAA,EAAG,EAAE,EAAA,EAAI,IAAI,CAAA;AAE3D,MAAM,SAQT,CAAC,KAAA,KAAU,UAAUC,QAAA,CAAQ,KAAK,GAAG,KAAK;AAC9C,MAAA,CAAO,GAAA,GAAM,CAAC,KAAA,KAAU,SAAA,CAAUA,SAAQ,GAAA,CAAI,KAAK,GAAG,KAAK,CAAA;AAC3D,MAAA,CAAO,GAAA,GAAM,CAAC,KAAA,KAAU,SAAA,CAAUA,SAAQ,GAAA,CAAI,KAAK,GAAG,KAAK,CAAA;;;;"} \ No newline at end of file diff --git a/packages/bizinikiwi-bindings/dist/esm/codecs/scale/with-inner.mjs b/packages/bizinikiwi-bindings/dist/esm/codecs/scale/with-inner.mjs new file mode 100644 index 0000000..53dddc6 --- /dev/null +++ b/packages/bizinikiwi-bindings/dist/esm/codecs/scale/with-inner.mjs @@ -0,0 +1,8 @@ +const withInner = (codec, inner) => { + const result = codec; + result.inner = inner; + return result; +}; + +export { withInner }; +//# sourceMappingURL=with-inner.mjs.map diff --git a/packages/bizinikiwi-bindings/dist/esm/codecs/scale/with-inner.mjs.map b/packages/bizinikiwi-bindings/dist/esm/codecs/scale/with-inner.mjs.map new file mode 100644 index 0000000..6e40d3d --- /dev/null +++ b/packages/bizinikiwi-bindings/dist/esm/codecs/scale/with-inner.mjs.map @@ -0,0 +1 @@ +{"version":3,"file":"with-inner.mjs","sources":["../../../../src/codecs/scale/with-inner.ts"],"sourcesContent":["export const withInner = (codec: T, inner: I): T & { inner: I } => {\n const result: T & { inner: I } = codec as any\n result.inner = inner\n return result\n}\n"],"names":[],"mappings":"AAAO,MAAM,SAAA,GAAY,CAAO,KAAA,EAAU,KAAA,KAA+B;AACvE,EAAA,MAAM,MAAA,GAA2B,KAAA;AACjC,EAAA,MAAA,CAAO,KAAA,GAAQ,KAAA;AACf,EAAA,OAAO,MAAA;AACT;;;;"} \ No newline at end of file diff --git a/packages/bizinikiwi-bindings/dist/esm/extrinsics/extrinsic-format.mjs b/packages/bizinikiwi-bindings/dist/esm/extrinsics/extrinsic-format.mjs new file mode 100644 index 0000000..bbd5ae7 --- /dev/null +++ b/packages/bizinikiwi-bindings/dist/esm/extrinsics/extrinsic-format.mjs @@ -0,0 +1,26 @@ +import { enhanceCodec, u8 } from 'scale-ts'; + +const TYPES = { + bare: 0, + 0: "bare", + general: 1, + 1: "general", + signed: 2, + 2: "signed" +}; +const extrinsicFormat = enhanceCodec( + u8, + ({ version, type }) => version + (TYPES[type] << 6), + (v) => { + const version = v & 63; + const type = v >> 6; + if (version === 4 && (type === TYPES.bare || type === TYPES.signed)) + return { version, type: TYPES[type] }; + if (version === 5 && (type === TYPES.bare || type === TYPES.general)) + return { version, type: TYPES[type] }; + throw new Error(`ExtrinsicFormat ${v} not valid`); + } +); + +export { extrinsicFormat }; +//# sourceMappingURL=extrinsic-format.mjs.map diff --git a/packages/bizinikiwi-bindings/dist/esm/extrinsics/extrinsic-format.mjs.map b/packages/bizinikiwi-bindings/dist/esm/extrinsics/extrinsic-format.mjs.map new file mode 100644 index 0000000..76d873e --- /dev/null +++ b/packages/bizinikiwi-bindings/dist/esm/extrinsics/extrinsic-format.mjs.map @@ -0,0 +1 @@ +{"version":3,"file":"extrinsic-format.mjs","sources":["../../../src/extrinsics/extrinsic-format.ts"],"sourcesContent":["import { enhanceCodec, u8 } from \"scale-ts\"\n\nconst TYPES = {\n bare: 0b00,\n 0b00: \"bare\",\n general: 0b01,\n 0b01: \"general\",\n signed: 0b10,\n 0b10: \"signed\",\n} as const\n\nexport type ExtrinsicFormat =\n | { version: 4; type: \"bare\" | \"signed\" }\n | { version: 5; type: \"bare\" | \"general\" }\n\nexport const extrinsicFormat = enhanceCodec(\n u8,\n ({ version, type }) => version + (TYPES[type] << 6),\n (v) => {\n const version = v & 0x3f // 0b0011_1111\n const type = v >> 6\n if (version === 4 && (type === TYPES.bare || type === TYPES.signed))\n return { version, type: TYPES[type] }\n if (version === 5 && (type === TYPES.bare || type === TYPES.general))\n return { version, type: TYPES[type] }\n throw new Error(`ExtrinsicFormat ${v} not valid`)\n },\n)\n"],"names":[],"mappings":";;AAEA,MAAM,KAAA,GAAQ;AAAA,EACZ,IAAA,EAAM,CAAA;AAAA,EACN,CAAA,EAAM,MAAA;AAAA,EACN,OAAA,EAAS,CAAA;AAAA,EACT,CAAA,EAAM,SAAA;AAAA,EACN,MAAA,EAAQ,CAAA;AAAA,EACR,CAAA,EAAM;AACR,CAAA;AAMO,MAAM,eAAA,GAAkB,YAAA;AAAA,EAC7B,EAAA;AAAA,EACA,CAAC,EAAE,OAAA,EAAS,IAAA,OAAW,OAAA,IAAW,KAAA,CAAM,IAAI,CAAA,IAAK,CAAA,CAAA;AAAA,EACjD,CAAC,CAAA,KAAM;AACL,IAAA,MAAM,UAAU,CAAA,GAAI,EAAA;AACpB,IAAA,MAAM,OAAO,CAAA,IAAK,CAAA;AAClB,IAAA,IAAI,YAAY,CAAA,KAAM,IAAA,KAAS,KAAA,CAAM,IAAA,IAAQ,SAAS,KAAA,CAAM,MAAA,CAAA;AAC1D,MAAA,OAAO,EAAE,OAAA,EAAS,IAAA,EAAM,KAAA,CAAM,IAAI,CAAA,EAAE;AACtC,IAAA,IAAI,YAAY,CAAA,KAAM,IAAA,KAAS,KAAA,CAAM,IAAA,IAAQ,SAAS,KAAA,CAAM,OAAA,CAAA;AAC1D,MAAA,OAAO,EAAE,OAAA,EAAS,IAAA,EAAM,KAAA,CAAM,IAAI,CAAA,EAAE;AACtC,IAAA,MAAM,IAAI,KAAA,CAAM,CAAA,gBAAA,EAAmB,CAAC,CAAA,UAAA,CAAY,CAAA;AAAA,EAClD;AACF;;;;"} \ No newline at end of file diff --git a/packages/bizinikiwi-bindings/dist/esm/hashes/blake2.mjs b/packages/bizinikiwi-bindings/dist/esm/hashes/blake2.mjs new file mode 100644 index 0000000..459d1b6 --- /dev/null +++ b/packages/bizinikiwi-bindings/dist/esm/hashes/blake2.mjs @@ -0,0 +1,11 @@ +import { mergeUint8 } from '@pezkuwi/papi-utils'; +import { blake2b } from '@noble/hashes/blake2.js'; + +const len32$1 = { dkLen: 32 }; +const Blake2256 = (encoded) => blake2b(encoded, len32$1); +const len16 = { dkLen: 16 }; +const Blake2128 = (encoded) => blake2b(encoded, len16); +const Blake2128Concat = (encoded) => mergeUint8([Blake2128(encoded), encoded]); + +export { Blake2128, Blake2128Concat, Blake2256 }; +//# sourceMappingURL=blake2.mjs.map diff --git a/packages/bizinikiwi-bindings/dist/esm/hashes/blake2.mjs.map b/packages/bizinikiwi-bindings/dist/esm/hashes/blake2.mjs.map new file mode 100644 index 0000000..615503c --- /dev/null +++ b/packages/bizinikiwi-bindings/dist/esm/hashes/blake2.mjs.map @@ -0,0 +1 @@ +{"version":3,"file":"blake2.mjs","sources":["../../../src/hashes/blake2.ts"],"sourcesContent":["import { mergeUint8 } from \"@pezkuwi/papi-utils\"\nimport { blake2b } from \"@noble/hashes/blake2.js\"\n\nconst len32 = { dkLen: 32 }\nexport const Blake2256 = (encoded: Uint8Array) => blake2b(encoded, len32)\n\nconst len16 = { dkLen: 16 }\nexport const Blake2128 = (encoded: Uint8Array) => blake2b(encoded, len16)\n\nexport const Blake2128Concat = (encoded: Uint8Array) =>\n mergeUint8([Blake2128(encoded), encoded])\n"],"names":["len32"],"mappings":";;;AAGA,MAAMA,OAAA,GAAQ,EAAE,KAAA,EAAO,EAAA,EAAG;AACnB,MAAM,SAAA,GAAY,CAAC,OAAA,KAAwB,OAAA,CAAQ,SAASA,OAAK;AAExE,MAAM,KAAA,GAAQ,EAAE,KAAA,EAAO,EAAA,EAAG;AACnB,MAAM,SAAA,GAAY,CAAC,OAAA,KAAwB,OAAA,CAAQ,SAAS,KAAK;AAEjE,MAAM,eAAA,GAAkB,CAAC,OAAA,KAC9B,UAAA,CAAW,CAAC,SAAA,CAAU,OAAO,CAAA,EAAG,OAAO,CAAC;;;;"} \ No newline at end of file diff --git a/packages/bizinikiwi-bindings/dist/esm/hashes/blake3.mjs b/packages/bizinikiwi-bindings/dist/esm/hashes/blake3.mjs new file mode 100644 index 0000000..83674a7 --- /dev/null +++ b/packages/bizinikiwi-bindings/dist/esm/hashes/blake3.mjs @@ -0,0 +1,9 @@ +import { mergeUint8 } from '@pezkuwi/papi-utils'; +import { blake3 } from '@noble/hashes/blake3.js'; + +const len32 = { dkLen: 32 }; +const Blake3256 = (encoded) => blake3(encoded, len32); +const Blake3256Concat = (encoded) => mergeUint8([Blake3256(encoded), encoded]); + +export { Blake3256, Blake3256Concat }; +//# sourceMappingURL=blake3.mjs.map diff --git a/packages/bizinikiwi-bindings/dist/esm/hashes/blake3.mjs.map b/packages/bizinikiwi-bindings/dist/esm/hashes/blake3.mjs.map new file mode 100644 index 0000000..290b799 --- /dev/null +++ b/packages/bizinikiwi-bindings/dist/esm/hashes/blake3.mjs.map @@ -0,0 +1 @@ +{"version":3,"file":"blake3.mjs","sources":["../../../src/hashes/blake3.ts"],"sourcesContent":["import { mergeUint8 } from \"@pezkuwi/papi-utils\"\nimport { blake3 } from \"@noble/hashes/blake3.js\"\n\nconst len32 = { dkLen: 32 }\nexport const Blake3256 = (encoded: Uint8Array) => blake3(encoded, len32)\n\nexport const Blake3256Concat = (encoded: Uint8Array) =>\n mergeUint8([Blake3256(encoded), encoded])\n"],"names":[],"mappings":";;;AAGA,MAAM,KAAA,GAAQ,EAAE,KAAA,EAAO,EAAA,EAAG;AACnB,MAAM,SAAA,GAAY,CAAC,OAAA,KAAwB,MAAA,CAAO,SAAS,KAAK;AAEhE,MAAM,eAAA,GAAkB,CAAC,OAAA,KAC9B,UAAA,CAAW,CAAC,SAAA,CAAU,OAAO,CAAA,EAAG,OAAO,CAAC;;;;"} \ No newline at end of file diff --git a/packages/bizinikiwi-bindings/dist/esm/hashes/h64.mjs b/packages/bizinikiwi-bindings/dist/esm/hashes/h64.mjs new file mode 100644 index 0000000..6e84270 --- /dev/null +++ b/packages/bizinikiwi-bindings/dist/esm/hashes/h64.mjs @@ -0,0 +1,134 @@ +const bigintFromU16 = (v0, v1, v2, v3) => new DataView(new Uint16Array([v0, v1, v2, v3]).buffer).getBigUint64(0, true); +const MASK_64 = 2n ** 64n - 1n; +const rotl = (input, nBits) => input << nBits & MASK_64 | input >> 64n - nBits; +const multiply = (a, b) => a * b & MASK_64; +const add = (a, b) => a + b & MASK_64; +const PRIME64_1 = 11400714785074694791n; +const PRIME64_2 = 14029467366897019727n; +const PRIME64_3 = 1609587929392839161n; +const PRIME64_4 = 9650029242287828579n; +const PRIME64_5 = 2870177450012600261n; +function h64(input, seed = 0n) { + let v1 = add(add(seed, PRIME64_1), PRIME64_2); + let v2 = add(seed, PRIME64_2); + let v3 = seed; + let v4 = seed - PRIME64_1; + let totalLen = input.length; + let memsize = 0; + let memory = null; + (function update() { + let p2 = 0; + let bEnd = p2 + totalLen; + if (!totalLen) return; + memory = new Uint8Array(32); + if (totalLen < 32) { + memory.set(input.subarray(0, totalLen), memsize); + memsize += totalLen; + return; + } + if (p2 <= bEnd - 32) { + const limit = bEnd - 32; + do { + let other; + other = bigintFromU16( + input[p2 + 1] << 8 | input[p2], + input[p2 + 3] << 8 | input[p2 + 2], + input[p2 + 5] << 8 | input[p2 + 4], + input[p2 + 7] << 8 | input[p2 + 6] + ); + v1 = multiply(rotl(add(v1, multiply(other, PRIME64_2)), 31n), PRIME64_1); + p2 += 8; + other = bigintFromU16( + input[p2 + 1] << 8 | input[p2], + input[p2 + 3] << 8 | input[p2 + 2], + input[p2 + 5] << 8 | input[p2 + 4], + input[p2 + 7] << 8 | input[p2 + 6] + ); + v2 = multiply(rotl(add(v2, multiply(other, PRIME64_2)), 31n), PRIME64_1); + p2 += 8; + other = bigintFromU16( + input[p2 + 1] << 8 | input[p2], + input[p2 + 3] << 8 | input[p2 + 2], + input[p2 + 5] << 8 | input[p2 + 4], + input[p2 + 7] << 8 | input[p2 + 6] + ); + v3 = multiply(rotl(add(v3, multiply(other, PRIME64_2)), 31n), PRIME64_1); + p2 += 8; + other = bigintFromU16( + input[p2 + 1] << 8 | input[p2], + input[p2 + 3] << 8 | input[p2 + 2], + input[p2 + 5] << 8 | input[p2 + 4], + input[p2 + 7] << 8 | input[p2 + 6] + ); + v4 = multiply(rotl(add(v4, multiply(other, PRIME64_2)), 31n), PRIME64_1); + p2 += 8; + } while (p2 <= limit); + } + if (p2 < bEnd) { + memory.set(input.subarray(p2, bEnd), memsize); + memsize = bEnd - p2; + } + })(); + input = memory || input; + let result; + let p = 0; + if (totalLen >= 32) { + result = rotl(v1, 1n); + result = add(result, rotl(v2, 7n)); + result = add(result, rotl(v3, 12n)); + result = add(result, rotl(v4, 18n)); + v1 = multiply(rotl(multiply(v1, PRIME64_2), 31n), PRIME64_1); + result = result ^ v1; + result = add(multiply(result, PRIME64_1), PRIME64_4); + v2 = multiply(rotl(multiply(v2, PRIME64_2), 31n), PRIME64_1); + result = result ^ v2; + result = add(multiply(result, PRIME64_1), PRIME64_4); + v3 = multiply(rotl(multiply(v3, PRIME64_2), 31n), PRIME64_1); + result = result ^ v3; + result = add(multiply(result, PRIME64_1), PRIME64_4); + v4 = multiply(rotl(multiply(v4, PRIME64_2), 31n), PRIME64_1); + result = result ^ v4; + result = add(multiply(result, PRIME64_1), PRIME64_4); + } else { + result = add(seed, PRIME64_5); + } + result = add(result, BigInt(totalLen)); + while (p <= memsize - 8) { + let temp2 = bigintFromU16( + input[p + 1] << 8 | input[p], + input[p + 3] << 8 | input[p + 2], + input[p + 5] << 8 | input[p + 4], + input[p + 7] << 8 | input[p + 6] + ); + temp2 = multiply(rotl(multiply(temp2, PRIME64_2), 31n), PRIME64_1); + result = add(multiply(rotl(result ^ temp2, 27n), PRIME64_1), PRIME64_4); + p += 8; + } + if (p + 4 <= memsize) { + let temp2 = multiply( + bigintFromU16( + input[p + 1] << 8 | input[p], + input[p + 3] << 8 | input[p + 2], + 0, + 0 + ), + PRIME64_1 + ); + result = add(multiply(rotl(result ^ temp2, 23n), PRIME64_2), PRIME64_3); + p += 4; + } + while (p < memsize) { + const temp2 = multiply(bigintFromU16(input[p++], 0, 0, 0), PRIME64_5); + result = multiply(rotl(result ^ temp2, 11n), PRIME64_1); + } + let temp = result >> 33n; + result = multiply(result ^ temp, PRIME64_2); + temp = result >> 29n; + result = multiply(result ^ temp, PRIME64_3); + temp = result >> 32n; + result ^= temp; + return result; +} + +export { h64 }; +//# sourceMappingURL=h64.mjs.map diff --git a/packages/bizinikiwi-bindings/dist/esm/hashes/h64.mjs.map b/packages/bizinikiwi-bindings/dist/esm/hashes/h64.mjs.map new file mode 100644 index 0000000..1b53d5b --- /dev/null +++ b/packages/bizinikiwi-bindings/dist/esm/hashes/h64.mjs.map @@ -0,0 +1 @@ +{"version":3,"file":"h64.mjs","sources":["../../../src/hashes/h64.ts"],"sourcesContent":["// Adapted implementation based on: https://github.com/pierrec/js-xxhash/blob/7ff5ced282f97dba121109d7013e0fa80360398c/lib/xxhash64.js\n\n// Distributed under the MIT software license, see the accompanying\n// file LICENSE or http://www.opensource.org/licenses/mit-license.php.\n\n// helper functions\nconst bigintFromU16 = (\n v0: number,\n v1: number,\n v2: number,\n v3: number,\n): bigint =>\n new DataView(new Uint16Array([v0, v1, v2, v3]).buffer).getBigUint64(0, true)\n\nconst MASK_64 = 2n ** 64n - 1n\n\nconst rotl = (input: bigint, nBits: bigint) =>\n ((input << nBits) & MASK_64) | (input >> (64n - nBits))\n\nconst multiply = (a: bigint, b: bigint) => (a * b) & MASK_64\n\nconst add = (a: bigint, b: bigint) => (a + b) & MASK_64\n\n// constants\nconst PRIME64_1 = 11400714785074694791n\nconst PRIME64_2 = 14029467366897019727n\nconst PRIME64_3 = 1609587929392839161n\nconst PRIME64_4 = 9650029242287828579n\nconst PRIME64_5 = 2870177450012600261n\n\nexport function h64(input: Uint8Array, seed: bigint = 0n) {\n let v1 = add(add(seed, PRIME64_1), PRIME64_2)\n let v2 = add(seed, PRIME64_2)\n let v3 = seed\n let v4 = seed - PRIME64_1\n let totalLen = input.length\n let memsize = 0\n let memory: Uint8Array | null = null\n\n ;(function update() {\n let p = 0\n let bEnd = p + totalLen\n\n if (!totalLen) return\n\n memory = new Uint8Array(32)\n\n if (totalLen < 32) {\n memory.set(input.subarray(0, totalLen), memsize)\n\n memsize += totalLen\n return\n }\n\n if (p <= bEnd - 32) {\n const limit = bEnd - 32\n\n do {\n let other\n other = bigintFromU16(\n (input[p + 1] << 8) | input[p],\n (input[p + 3] << 8) | input[p + 2],\n (input[p + 5] << 8) | input[p + 4],\n (input[p + 7] << 8) | input[p + 6],\n )\n v1 = multiply(rotl(add(v1, multiply(other, PRIME64_2)), 31n), PRIME64_1)\n p += 8\n other = bigintFromU16(\n (input[p + 1] << 8) | input[p],\n (input[p + 3] << 8) | input[p + 2],\n (input[p + 5] << 8) | input[p + 4],\n (input[p + 7] << 8) | input[p + 6],\n )\n\n v2 = multiply(rotl(add(v2, multiply(other, PRIME64_2)), 31n), PRIME64_1)\n p += 8\n other = bigintFromU16(\n (input[p + 1] << 8) | input[p],\n (input[p + 3] << 8) | input[p + 2],\n (input[p + 5] << 8) | input[p + 4],\n (input[p + 7] << 8) | input[p + 6],\n )\n\n v3 = multiply(rotl(add(v3, multiply(other, PRIME64_2)), 31n), PRIME64_1)\n p += 8\n other = bigintFromU16(\n (input[p + 1] << 8) | input[p],\n (input[p + 3] << 8) | input[p + 2],\n (input[p + 5] << 8) | input[p + 4],\n (input[p + 7] << 8) | input[p + 6],\n )\n v4 = multiply(rotl(add(v4, multiply(other, PRIME64_2)), 31n), PRIME64_1)\n p += 8\n } while (p <= limit)\n }\n\n if (p < bEnd) {\n memory.set(input.subarray(p, bEnd), memsize)\n memsize = bEnd - p\n }\n })()\n\n input = memory || input\n\n let result: bigint\n let p = 0\n\n if (totalLen >= 32) {\n result = rotl(v1, 1n)\n result = add(result, rotl(v2, 7n))\n result = add(result, rotl(v3, 12n))\n result = add(result, rotl(v4, 18n))\n\n v1 = multiply(rotl(multiply(v1, PRIME64_2), 31n), PRIME64_1)\n result = result ^ v1\n result = add(multiply(result, PRIME64_1), PRIME64_4)\n\n v2 = multiply(rotl(multiply(v2, PRIME64_2), 31n), PRIME64_1)\n result = result ^ v2\n result = add(multiply(result, PRIME64_1), PRIME64_4)\n\n v3 = multiply(rotl(multiply(v3, PRIME64_2), 31n), PRIME64_1)\n result = result ^ v3\n result = add(multiply(result, PRIME64_1), PRIME64_4)\n\n v4 = multiply(rotl(multiply(v4, PRIME64_2), 31n), PRIME64_1)\n result = result ^ v4\n result = add(multiply(result, PRIME64_1), PRIME64_4)\n } else {\n result = add(seed, PRIME64_5)\n }\n\n result = add(result, BigInt(totalLen))\n\n while (p <= memsize - 8) {\n let temp = bigintFromU16(\n (input[p + 1] << 8) | input[p],\n (input[p + 3] << 8) | input[p + 2],\n (input[p + 5] << 8) | input[p + 4],\n (input[p + 7] << 8) | input[p + 6],\n )\n temp = multiply(rotl(multiply(temp, PRIME64_2), 31n), PRIME64_1)\n result = add(multiply(rotl(result ^ temp, 27n), PRIME64_1), PRIME64_4)\n p += 8\n }\n\n if (p + 4 <= memsize) {\n let temp = multiply(\n bigintFromU16(\n (input[p + 1] << 8) | input[p],\n (input[p + 3] << 8) | input[p + 2],\n 0,\n 0,\n ),\n PRIME64_1,\n )\n\n result = add(multiply(rotl(result ^ temp, 23n), PRIME64_2), PRIME64_3)\n p += 4\n }\n\n while (p < memsize) {\n const temp = multiply(bigintFromU16(input[p++], 0, 0, 0), PRIME64_5)\n result = multiply(rotl(result ^ temp, 11n), PRIME64_1)\n }\n\n let temp = result >> 33n\n result = multiply(result ^ temp, PRIME64_2)\n\n temp = result >> 29n\n result = multiply(result ^ temp, PRIME64_3)\n\n temp = result >> 32n\n result ^= temp\n\n return result\n}\n"],"names":["p","temp"],"mappings":"AAMA,MAAM,aAAA,GAAgB,CACpB,EAAA,EACA,EAAA,EACA,IACA,EAAA,KAEA,IAAI,SAAS,IAAI,WAAA,CAAY,CAAC,EAAA,EAAI,EAAA,EAAI,IAAI,EAAE,CAAC,EAAE,MAAM,CAAA,CAAE,YAAA,CAAa,CAAA,EAAG,IAAI,CAAA;AAE7E,MAAM,OAAA,GAAU,MAAM,GAAA,GAAM,EAAA;AAE5B,MAAM,IAAA,GAAO,CAAC,KAAA,EAAe,KAAA,KACzB,SAAS,KAAA,GAAS,OAAA,GAAY,SAAU,GAAA,GAAM,KAAA;AAElD,MAAM,QAAA,GAAW,CAAC,CAAA,EAAW,CAAA,KAAe,IAAI,CAAA,GAAK,OAAA;AAErD,MAAM,GAAA,GAAM,CAAC,CAAA,EAAW,CAAA,KAAe,IAAI,CAAA,GAAK,OAAA;AAGhD,MAAM,SAAA,GAAY,qBAAA;AAClB,MAAM,SAAA,GAAY,qBAAA;AAClB,MAAM,SAAA,GAAY,oBAAA;AAClB,MAAM,SAAA,GAAY,oBAAA;AAClB,MAAM,SAAA,GAAY,oBAAA;AAEX,SAAS,GAAA,CAAI,KAAA,EAAmB,IAAA,GAAe,EAAA,EAAI;AACxD,EAAA,IAAI,KAAK,GAAA,CAAI,GAAA,CAAI,IAAA,EAAM,SAAS,GAAG,SAAS,CAAA;AAC5C,EAAA,IAAI,EAAA,GAAK,GAAA,CAAI,IAAA,EAAM,SAAS,CAAA;AAC5B,EAAA,IAAI,EAAA,GAAK,IAAA;AACT,EAAA,IAAI,KAAK,IAAA,GAAO,SAAA;AAChB,EAAA,IAAI,WAAW,KAAA,CAAM,MAAA;AACrB,EAAA,IAAI,OAAA,GAAU,CAAA;AACd,EAAA,IAAI,MAAA,GAA4B,IAAA;AAE/B,EAAA,CAAC,SAAS,MAAA,GAAS;AAClB,IAAA,IAAIA,EAAAA,GAAI,CAAA;AACR,IAAA,IAAI,OAAOA,EAAAA,GAAI,QAAA;AAEf,IAAA,IAAI,CAAC,QAAA,EAAU;AAEf,IAAA,MAAA,GAAS,IAAI,WAAW,EAAE,CAAA;AAE1B,IAAA,IAAI,WAAW,EAAA,EAAI;AACjB,MAAA,MAAA,CAAO,IAAI,KAAA,CAAM,QAAA,CAAS,CAAA,EAAG,QAAQ,GAAG,OAAO,CAAA;AAE/C,MAAA,OAAA,IAAW,QAAA;AACX,MAAA;AAAA,IACF;AAEA,IAAA,IAAIA,EAAAA,IAAK,OAAO,EAAA,EAAI;AAClB,MAAA,MAAM,QAAQ,IAAA,GAAO,EAAA;AAErB,MAAA,GAAG;AACD,QAAA,IAAI,KAAA;AACJ,QAAA,KAAA,GAAQ,aAAA;AAAA,UACL,MAAMA,EAAAA,GAAI,CAAC,CAAA,IAAK,CAAA,GAAK,MAAMA,EAAC,CAAA;AAAA,UAC5B,MAAMA,EAAAA,GAAI,CAAC,KAAK,CAAA,GAAK,KAAA,CAAMA,KAAI,CAAC,CAAA;AAAA,UAChC,MAAMA,EAAAA,GAAI,CAAC,KAAK,CAAA,GAAK,KAAA,CAAMA,KAAI,CAAC,CAAA;AAAA,UAChC,MAAMA,EAAAA,GAAI,CAAC,KAAK,CAAA,GAAK,KAAA,CAAMA,KAAI,CAAC;AAAA,SACnC;AACA,QAAA,EAAA,GAAK,QAAA,CAAS,IAAA,CAAK,GAAA,CAAI,EAAA,EAAI,QAAA,CAAS,KAAA,EAAO,SAAS,CAAC,CAAA,EAAG,GAAG,CAAA,EAAG,SAAS,CAAA;AACvE,QAAAA,EAAAA,IAAK,CAAA;AACL,QAAA,KAAA,GAAQ,aAAA;AAAA,UACL,MAAMA,EAAAA,GAAI,CAAC,CAAA,IAAK,CAAA,GAAK,MAAMA,EAAC,CAAA;AAAA,UAC5B,MAAMA,EAAAA,GAAI,CAAC,KAAK,CAAA,GAAK,KAAA,CAAMA,KAAI,CAAC,CAAA;AAAA,UAChC,MAAMA,EAAAA,GAAI,CAAC,KAAK,CAAA,GAAK,KAAA,CAAMA,KAAI,CAAC,CAAA;AAAA,UAChC,MAAMA,EAAAA,GAAI,CAAC,KAAK,CAAA,GAAK,KAAA,CAAMA,KAAI,CAAC;AAAA,SACnC;AAEA,QAAA,EAAA,GAAK,QAAA,CAAS,IAAA,CAAK,GAAA,CAAI,EAAA,EAAI,QAAA,CAAS,KAAA,EAAO,SAAS,CAAC,CAAA,EAAG,GAAG,CAAA,EAAG,SAAS,CAAA;AACvE,QAAAA,EAAAA,IAAK,CAAA;AACL,QAAA,KAAA,GAAQ,aAAA;AAAA,UACL,MAAMA,EAAAA,GAAI,CAAC,CAAA,IAAK,CAAA,GAAK,MAAMA,EAAC,CAAA;AAAA,UAC5B,MAAMA,EAAAA,GAAI,CAAC,KAAK,CAAA,GAAK,KAAA,CAAMA,KAAI,CAAC,CAAA;AAAA,UAChC,MAAMA,EAAAA,GAAI,CAAC,KAAK,CAAA,GAAK,KAAA,CAAMA,KAAI,CAAC,CAAA;AAAA,UAChC,MAAMA,EAAAA,GAAI,CAAC,KAAK,CAAA,GAAK,KAAA,CAAMA,KAAI,CAAC;AAAA,SACnC;AAEA,QAAA,EAAA,GAAK,QAAA,CAAS,IAAA,CAAK,GAAA,CAAI,EAAA,EAAI,QAAA,CAAS,KAAA,EAAO,SAAS,CAAC,CAAA,EAAG,GAAG,CAAA,EAAG,SAAS,CAAA;AACvE,QAAAA,EAAAA,IAAK,CAAA;AACL,QAAA,KAAA,GAAQ,aAAA;AAAA,UACL,MAAMA,EAAAA,GAAI,CAAC,CAAA,IAAK,CAAA,GAAK,MAAMA,EAAC,CAAA;AAAA,UAC5B,MAAMA,EAAAA,GAAI,CAAC,KAAK,CAAA,GAAK,KAAA,CAAMA,KAAI,CAAC,CAAA;AAAA,UAChC,MAAMA,EAAAA,GAAI,CAAC,KAAK,CAAA,GAAK,KAAA,CAAMA,KAAI,CAAC,CAAA;AAAA,UAChC,MAAMA,EAAAA,GAAI,CAAC,KAAK,CAAA,GAAK,KAAA,CAAMA,KAAI,CAAC;AAAA,SACnC;AACA,QAAA,EAAA,GAAK,QAAA,CAAS,IAAA,CAAK,GAAA,CAAI,EAAA,EAAI,QAAA,CAAS,KAAA,EAAO,SAAS,CAAC,CAAA,EAAG,GAAG,CAAA,EAAG,SAAS,CAAA;AACvE,QAAAA,EAAAA,IAAK,CAAA;AAAA,MACP,SAASA,EAAAA,IAAK,KAAA;AAAA,IAChB;AAEA,IAAA,IAAIA,KAAI,IAAA,EAAM;AACZ,MAAA,MAAA,CAAO,IAAI,KAAA,CAAM,QAAA,CAASA,EAAAA,EAAG,IAAI,GAAG,OAAO,CAAA;AAC3C,MAAA,OAAA,GAAU,IAAA,GAAOA,EAAAA;AAAA,IACnB;AAAA,EACF,CAAA,GAAG;AAEH,EAAA,KAAA,GAAQ,MAAA,IAAU,KAAA;AAElB,EAAA,IAAI,MAAA;AACJ,EAAA,IAAI,CAAA,GAAI,CAAA;AAER,EAAA,IAAI,YAAY,EAAA,EAAI;AAClB,IAAA,MAAA,GAAS,IAAA,CAAK,IAAI,EAAE,CAAA;AACpB,IAAA,MAAA,GAAS,GAAA,CAAI,MAAA,EAAQ,IAAA,CAAK,EAAA,EAAI,EAAE,CAAC,CAAA;AACjC,IAAA,MAAA,GAAS,GAAA,CAAI,MAAA,EAAQ,IAAA,CAAK,EAAA,EAAI,GAAG,CAAC,CAAA;AAClC,IAAA,MAAA,GAAS,GAAA,CAAI,MAAA,EAAQ,IAAA,CAAK,EAAA,EAAI,GAAG,CAAC,CAAA;AAElC,IAAA,EAAA,GAAK,QAAA,CAAS,KAAK,QAAA,CAAS,EAAA,EAAI,SAAS,CAAA,EAAG,GAAG,GAAG,SAAS,CAAA;AAC3D,IAAA,MAAA,GAAS,MAAA,GAAS,EAAA;AAClB,IAAA,MAAA,GAAS,GAAA,CAAI,QAAA,CAAS,MAAA,EAAQ,SAAS,GAAG,SAAS,CAAA;AAEnD,IAAA,EAAA,GAAK,QAAA,CAAS,KAAK,QAAA,CAAS,EAAA,EAAI,SAAS,CAAA,EAAG,GAAG,GAAG,SAAS,CAAA;AAC3D,IAAA,MAAA,GAAS,MAAA,GAAS,EAAA;AAClB,IAAA,MAAA,GAAS,GAAA,CAAI,QAAA,CAAS,MAAA,EAAQ,SAAS,GAAG,SAAS,CAAA;AAEnD,IAAA,EAAA,GAAK,QAAA,CAAS,KAAK,QAAA,CAAS,EAAA,EAAI,SAAS,CAAA,EAAG,GAAG,GAAG,SAAS,CAAA;AAC3D,IAAA,MAAA,GAAS,MAAA,GAAS,EAAA;AAClB,IAAA,MAAA,GAAS,GAAA,CAAI,QAAA,CAAS,MAAA,EAAQ,SAAS,GAAG,SAAS,CAAA;AAEnD,IAAA,EAAA,GAAK,QAAA,CAAS,KAAK,QAAA,CAAS,EAAA,EAAI,SAAS,CAAA,EAAG,GAAG,GAAG,SAAS,CAAA;AAC3D,IAAA,MAAA,GAAS,MAAA,GAAS,EAAA;AAClB,IAAA,MAAA,GAAS,GAAA,CAAI,QAAA,CAAS,MAAA,EAAQ,SAAS,GAAG,SAAS,CAAA;AAAA,EACrD,CAAA,MAAO;AACL,IAAA,MAAA,GAAS,GAAA,CAAI,MAAM,SAAS,CAAA;AAAA,EAC9B;AAEA,EAAA,MAAA,GAAS,GAAA,CAAI,MAAA,EAAQ,MAAA,CAAO,QAAQ,CAAC,CAAA;AAErC,EAAA,OAAO,CAAA,IAAK,UAAU,CAAA,EAAG;AACvB,IAAA,IAAIC,KAAAA,GAAO,aAAA;AAAA,MACR,MAAM,CAAA,GAAI,CAAC,CAAA,IAAK,CAAA,GAAK,MAAM,CAAC,CAAA;AAAA,MAC5B,MAAM,CAAA,GAAI,CAAC,KAAK,CAAA,GAAK,KAAA,CAAM,IAAI,CAAC,CAAA;AAAA,MAChC,MAAM,CAAA,GAAI,CAAC,KAAK,CAAA,GAAK,KAAA,CAAM,IAAI,CAAC,CAAA;AAAA,MAChC,MAAM,CAAA,GAAI,CAAC,KAAK,CAAA,GAAK,KAAA,CAAM,IAAI,CAAC;AAAA,KACnC;AACA,IAAAA,KAAAA,GAAO,SAAS,IAAA,CAAK,QAAA,CAASA,OAAM,SAAS,CAAA,EAAG,GAAG,CAAA,EAAG,SAAS,CAAA;AAC/D,IAAA,MAAA,GAAS,GAAA,CAAI,SAAS,IAAA,CAAK,MAAA,GAASA,OAAM,GAAG,CAAA,EAAG,SAAS,CAAA,EAAG,SAAS,CAAA;AACrE,IAAA,CAAA,IAAK,CAAA;AAAA,EACP;AAEA,EAAA,IAAI,CAAA,GAAI,KAAK,OAAA,EAAS;AACpB,IAAA,IAAIA,KAAAA,GAAO,QAAA;AAAA,MACT,aAAA;AAAA,QACG,MAAM,CAAA,GAAI,CAAC,CAAA,IAAK,CAAA,GAAK,MAAM,CAAC,CAAA;AAAA,QAC5B,MAAM,CAAA,GAAI,CAAC,KAAK,CAAA,GAAK,KAAA,CAAM,IAAI,CAAC,CAAA;AAAA,QACjC,CAAA;AAAA,QACA;AAAA,OACF;AAAA,MACA;AAAA,KACF;AAEA,IAAA,MAAA,GAAS,GAAA,CAAI,SAAS,IAAA,CAAK,MAAA,GAASA,OAAM,GAAG,CAAA,EAAG,SAAS,CAAA,EAAG,SAAS,CAAA;AACrE,IAAA,CAAA,IAAK,CAAA;AAAA,EACP;AAEA,EAAA,OAAO,IAAI,OAAA,EAAS;AAClB,IAAA,MAAMA,KAAAA,GAAO,QAAA,CAAS,aAAA,CAAc,KAAA,CAAM,CAAA,EAAG,GAAG,CAAA,EAAG,CAAA,EAAG,CAAC,CAAA,EAAG,SAAS,CAAA;AACnE,IAAA,MAAA,GAAS,SAAS,IAAA,CAAK,MAAA,GAASA,KAAAA,EAAM,GAAG,GAAG,SAAS,CAAA;AAAA,EACvD;AAEA,EAAA,IAAI,OAAO,MAAA,IAAU,GAAA;AACrB,EAAA,MAAA,GAAS,QAAA,CAAS,MAAA,GAAS,IAAA,EAAM,SAAS,CAAA;AAE1C,EAAA,IAAA,GAAO,MAAA,IAAU,GAAA;AACjB,EAAA,MAAA,GAAS,QAAA,CAAS,MAAA,GAAS,IAAA,EAAM,SAAS,CAAA;AAE1C,EAAA,IAAA,GAAO,MAAA,IAAU,GAAA;AACjB,EAAA,MAAA,IAAU,IAAA;AAEV,EAAA,OAAO,MAAA;AACT;;;;"} \ No newline at end of file diff --git a/packages/bizinikiwi-bindings/dist/esm/hashes/identity.mjs b/packages/bizinikiwi-bindings/dist/esm/hashes/identity.mjs new file mode 100644 index 0000000..978a2d2 --- /dev/null +++ b/packages/bizinikiwi-bindings/dist/esm/hashes/identity.mjs @@ -0,0 +1,4 @@ +const Identity = (encoded) => encoded; + +export { Identity }; +//# sourceMappingURL=identity.mjs.map diff --git a/packages/bizinikiwi-bindings/dist/esm/hashes/identity.mjs.map b/packages/bizinikiwi-bindings/dist/esm/hashes/identity.mjs.map new file mode 100644 index 0000000..207945a --- /dev/null +++ b/packages/bizinikiwi-bindings/dist/esm/hashes/identity.mjs.map @@ -0,0 +1 @@ +{"version":3,"file":"identity.mjs","sources":["../../../src/hashes/identity.ts"],"sourcesContent":["export const Identity = (encoded: Uint8Array): Uint8Array => encoded\n"],"names":[],"mappings":"AAAO,MAAM,QAAA,GAAW,CAAC,OAAA,KAAoC;;;;"} \ No newline at end of file diff --git a/packages/bizinikiwi-bindings/dist/esm/hashes/keccak.mjs b/packages/bizinikiwi-bindings/dist/esm/hashes/keccak.mjs new file mode 100644 index 0000000..704f16b --- /dev/null +++ b/packages/bizinikiwi-bindings/dist/esm/hashes/keccak.mjs @@ -0,0 +1,6 @@ +import { keccak_256 } from '@noble/hashes/sha3.js'; + +const Keccak256 = keccak_256; + +export { Keccak256 }; +//# sourceMappingURL=keccak.mjs.map diff --git a/packages/bizinikiwi-bindings/dist/esm/hashes/keccak.mjs.map b/packages/bizinikiwi-bindings/dist/esm/hashes/keccak.mjs.map new file mode 100644 index 0000000..370612b --- /dev/null +++ b/packages/bizinikiwi-bindings/dist/esm/hashes/keccak.mjs.map @@ -0,0 +1 @@ +{"version":3,"file":"keccak.mjs","sources":["../../../src/hashes/keccak.ts"],"sourcesContent":["import { keccak_256 } from \"@noble/hashes/sha3.js\"\n\nexport const Keccak256: (input: Uint8Array) => Uint8Array = keccak_256\n"],"names":[],"mappings":";;AAEO,MAAM,SAAA,GAA+C;;;;"} \ No newline at end of file diff --git a/packages/bizinikiwi-bindings/dist/esm/hashes/twoX.mjs b/packages/bizinikiwi-bindings/dist/esm/hashes/twoX.mjs new file mode 100644 index 0000000..6d4b867 --- /dev/null +++ b/packages/bizinikiwi-bindings/dist/esm/hashes/twoX.mjs @@ -0,0 +1,24 @@ +import { mergeUint8 } from '@pezkuwi/papi-utils'; +import { u64 } from 'scale-ts'; +import { h64 } from './h64.mjs'; + +const Twox128 = (input) => { + const result = new Uint8Array(16); + const dv = new DataView(result.buffer); + dv.setBigUint64(0, h64(input), true); + dv.setBigUint64(8, h64(input, 1n), true); + return result; +}; +const Twox256 = (input) => { + const result = new Uint8Array(32); + const dv = new DataView(result.buffer); + dv.setBigUint64(0, h64(input), true); + dv.setBigUint64(8, h64(input, 1n), true); + dv.setBigUint64(16, h64(input, 2n), true); + dv.setBigUint64(24, h64(input, 3n), true); + return result; +}; +const Twox64Concat = (encoded) => mergeUint8([u64.enc(h64(encoded)), encoded]); + +export { Twox128, Twox256, Twox64Concat }; +//# sourceMappingURL=twoX.mjs.map diff --git a/packages/bizinikiwi-bindings/dist/esm/hashes/twoX.mjs.map b/packages/bizinikiwi-bindings/dist/esm/hashes/twoX.mjs.map new file mode 100644 index 0000000..8f12b7c --- /dev/null +++ b/packages/bizinikiwi-bindings/dist/esm/hashes/twoX.mjs.map @@ -0,0 +1 @@ +{"version":3,"file":"twoX.mjs","sources":["../../../src/hashes/twoX.ts"],"sourcesContent":["import { mergeUint8 } from \"@pezkuwi/papi-utils\"\nimport { u64 } from \"scale-ts\"\nimport { h64 } from \"./h64\"\n\nexport const Twox128 = (input: Uint8Array): Uint8Array => {\n const result = new Uint8Array(16)\n const dv = new DataView(result.buffer)\n\n dv.setBigUint64(0, h64(input), true)\n dv.setBigUint64(8, h64(input, 1n), true)\n\n return result\n}\n\nexport const Twox256 = (input: Uint8Array): Uint8Array => {\n const result = new Uint8Array(32)\n const dv = new DataView(result.buffer)\n\n dv.setBigUint64(0, h64(input), true)\n dv.setBigUint64(8, h64(input, 1n), true)\n dv.setBigUint64(16, h64(input, 2n), true)\n dv.setBigUint64(24, h64(input, 3n), true)\n\n return result\n}\n\nexport const Twox64Concat = (encoded: Uint8Array): Uint8Array =>\n mergeUint8([u64.enc(h64(encoded)), encoded])\n"],"names":[],"mappings":";;;;AAIO,MAAM,OAAA,GAAU,CAAC,KAAA,KAAkC;AACxD,EAAA,MAAM,MAAA,GAAS,IAAI,UAAA,CAAW,EAAE,CAAA;AAChC,EAAA,MAAM,EAAA,GAAK,IAAI,QAAA,CAAS,MAAA,CAAO,MAAM,CAAA;AAErC,EAAA,EAAA,CAAG,YAAA,CAAa,CAAA,EAAG,GAAA,CAAI,KAAK,GAAG,IAAI,CAAA;AACnC,EAAA,EAAA,CAAG,aAAa,CAAA,EAAG,GAAA,CAAI,KAAA,EAAO,EAAE,GAAG,IAAI,CAAA;AAEvC,EAAA,OAAO,MAAA;AACT;AAEO,MAAM,OAAA,GAAU,CAAC,KAAA,KAAkC;AACxD,EAAA,MAAM,MAAA,GAAS,IAAI,UAAA,CAAW,EAAE,CAAA;AAChC,EAAA,MAAM,EAAA,GAAK,IAAI,QAAA,CAAS,MAAA,CAAO,MAAM,CAAA;AAErC,EAAA,EAAA,CAAG,YAAA,CAAa,CAAA,EAAG,GAAA,CAAI,KAAK,GAAG,IAAI,CAAA;AACnC,EAAA,EAAA,CAAG,aAAa,CAAA,EAAG,GAAA,CAAI,KAAA,EAAO,EAAE,GAAG,IAAI,CAAA;AACvC,EAAA,EAAA,CAAG,aAAa,EAAA,EAAI,GAAA,CAAI,KAAA,EAAO,EAAE,GAAG,IAAI,CAAA;AACxC,EAAA,EAAA,CAAG,aAAa,EAAA,EAAI,GAAA,CAAI,KAAA,EAAO,EAAE,GAAG,IAAI,CAAA;AAExC,EAAA,OAAO,MAAA;AACT;AAEO,MAAM,YAAA,GAAe,CAAC,OAAA,KAC3B,UAAA,CAAW,CAAC,GAAA,CAAI,GAAA,CAAI,GAAA,CAAI,OAAO,CAAC,CAAA,EAAG,OAAO,CAAC;;;;"} \ No newline at end of file diff --git a/packages/bizinikiwi-bindings/dist/esm/index.mjs b/packages/bizinikiwi-bindings/dist/esm/index.mjs new file mode 100644 index 0000000..e7c3885 --- /dev/null +++ b/packages/bizinikiwi-bindings/dist/esm/index.mjs @@ -0,0 +1,35 @@ +export { AccountId } from './codecs/scale/AccountId.mjs'; +export { Bin, Binary, FixedSizeBinary } from './codecs/scale/Binary.mjs'; +export { bitSequence } from './codecs/scale/bitSequence.mjs'; +export { char } from './codecs/scale/char.mjs'; +export { compactBn, compactNumber } from './codecs/scale/compact.mjs'; +export { Hex } from './codecs/scale/Hex.mjs'; +export { fixedStr } from './codecs/scale/fixed-str.mjs'; +export { Bytes, _void, bool, compact, createCodec, createDecoder, enhanceCodec, enhanceDecoder, enhanceEncoder, i128, i16, i256, i32, i64, i8, str, u128, u16, u256, u32, u64, u8 } from 'scale-ts'; +export { Self, selfDecoder, selfEncoder } from './codecs/scale/Self.mjs'; +export { ScaleEnum, Variant } from './codecs/scale/Variant.mjs'; +export { ethAccount } from './codecs/scale/ethAccount.mjs'; +export { Option, Result, Struct, Tuple, Vector } from './codecs/scale/shaped.mjs'; +export { BitSeq } from './codecs/scale/BitSeq.mjs'; +export { blockHeader } from './codecs/blockHeader.mjs'; +export { decAnyMetadata, metadata } from './codecs/metadata/metadata.mjs'; +export { v14 } from './codecs/metadata/v14.mjs'; +export { v15 } from './codecs/metadata/v15.mjs'; +export { v16 } from './codecs/metadata/v16.mjs'; +export { unifyMetadata } from './codecs/metadata/unified.mjs'; +export { lookup as v14Lookup } from './codecs/metadata/lookup.mjs'; +export { extrinsicFormat } from './extrinsics/extrinsic-format.mjs'; +export { Blake2128, Blake2128Concat, Blake2256 } from './hashes/blake2.mjs'; +export { Blake3256, Blake3256Concat } from './hashes/blake3.mjs'; +export { Identity } from './hashes/identity.mjs'; +export { Twox128, Twox256, Twox64Concat } from './hashes/twoX.mjs'; +export { h64 } from './hashes/h64.mjs'; +export { Keccak256 } from './hashes/keccak.mjs'; +export { Storage } from './storage.mjs'; +export { Enum, _Enum } from './types/enum.mjs'; +export { fromBufferToBase58, getSs58AddressInfo } from './utils/ss58-util.mjs'; +export { getMultisigAccountId, sortMultisigSignatories } from './utils/multisig.mjs'; +export { TrieNodeHeaders } from './trie/types.mjs'; +export { trieNodeDec } from './trie/node-decoder.mjs'; +export { TrieNodeWithHash, validateProofs } from './trie/proofs.mjs'; +//# sourceMappingURL=index.mjs.map diff --git a/packages/bizinikiwi-bindings/dist/esm/index.mjs.map b/packages/bizinikiwi-bindings/dist/esm/index.mjs.map new file mode 100644 index 0000000..078c8be --- /dev/null +++ b/packages/bizinikiwi-bindings/dist/esm/index.mjs.map @@ -0,0 +1 @@ +{"version":3,"file":"index.mjs","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"} \ No newline at end of file diff --git a/packages/bizinikiwi-bindings/dist/esm/storage.mjs b/packages/bizinikiwi-bindings/dist/esm/storage.mjs new file mode 100644 index 0000000..37bcf67 --- /dev/null +++ b/packages/bizinikiwi-bindings/dist/esm/storage.mjs @@ -0,0 +1,65 @@ +import { mergeUint8, toHex, fromHex } from '@pezkuwi/papi-utils'; +import { Blake2128Concat, Blake2128, Blake2256 } from './hashes/blake2.mjs'; +import '@noble/hashes/blake3.js'; +import { Identity } from './hashes/identity.mjs'; +import { Twox128, Twox64Concat, Twox256 } from './hashes/twoX.mjs'; +import '@noble/hashes/sha3.js'; + +const textEncoder = new TextEncoder(); +const hashers = /* @__PURE__ */ new Map([ + [Identity, 0], + [Twox64Concat, 8], + [Blake2128Concat, 16], + [Blake2128, -16], + [Blake2256, -32], + [Twox128, -16], + [Twox256, -32] +]); +const Storage = (pallet) => { + const palledEncoded = Twox128(textEncoder.encode(pallet)); + return (name, ...encoders) => { + const palletItemEncoded = mergeUint8([ + palledEncoded, + Twox128(textEncoder.encode(name)) + ]); + const palletItemEncodedHex = toHex(palletItemEncoded); + const dec = (key) => { + if (!key.startsWith(palletItemEncodedHex)) + throw new Error(`key does not match this storage (${pallet}.${name})`); + if (encoders.length === 0) return []; + const argsKey = fromHex(key.slice(palletItemEncodedHex.length)); + const result = new Array(encoders.length); + for (let i = 0, cur = 0; i < encoders.length; i++) { + const [codec, hasher] = encoders[i]; + const hBytes = hashers.get(hasher); + if (hBytes == null) throw new Error("Unknown hasher"); + if (hBytes < 0) { + const opaqueBytes = hBytes * -1; + result[i] = toHex(argsKey.slice(cur, cur + opaqueBytes)); + cur += opaqueBytes; + } else { + cur += hBytes; + result[i] = codec.dec(argsKey.slice(cur)); + cur += codec.enc(result[i]).length; + } + } + return result; + }; + const fns = encoders.map( + ([{ enc: enc2 }, hash]) => (val) => hash(enc2(val)) + ); + const enc = (...args) => toHex( + mergeUint8([ + palletItemEncoded, + ...args.map((val, idx) => fns[idx](val)) + ]) + ); + return { + enc, + dec + }; + }; +}; + +export { Storage }; +//# sourceMappingURL=storage.mjs.map diff --git a/packages/bizinikiwi-bindings/dist/esm/storage.mjs.map b/packages/bizinikiwi-bindings/dist/esm/storage.mjs.map new file mode 100644 index 0000000..1987a13 --- /dev/null +++ b/packages/bizinikiwi-bindings/dist/esm/storage.mjs.map @@ -0,0 +1 @@ +{"version":3,"file":"storage.mjs","sources":["../../src/storage.ts"],"sourcesContent":["import { fromHex, mergeUint8, toHex } from \"@pezkuwi/papi-utils\"\nimport type { Codec } from \"scale-ts\"\nimport {\n Blake2128,\n Blake2128Concat,\n Blake2256,\n Identity,\n Twox128,\n Twox256,\n Twox64Concat,\n} from \"./hashes\"\n\nexport type EncoderWithHash = [Codec, (input: Uint8Array) => Uint8Array]\n\nconst textEncoder = new TextEncoder()\n\n// the value indicates:\n// - when positive: the number of bytes to skip before reaching the transparent-encoded key\n// - when negative: the number of bytes that the opaque hasher will generate\nconst hashers: Map<(input: Uint8Array) => Uint8Array, number> = new Map([\n [Identity, 0],\n [Twox64Concat, 8],\n [Blake2128Concat, 16],\n [Blake2128, -16],\n [Blake2256, -32],\n [Twox128, -16],\n [Twox256, -32],\n])\n\nexport type OpaqueKeyHash = string & { __opaqueKeyHash?: unknown }\n\nexport const Storage = (pallet: string) => {\n const palledEncoded = Twox128(textEncoder.encode(pallet))\n return >>(\n name: string,\n ...encoders: [...A]\n ): {\n enc: (\n ...args: {\n [K in keyof A]: A[K] extends EncoderWithHash ? V : unknown\n }\n ) => string\n dec: (value: string) => {\n [K in keyof A]: A[K] extends EncoderWithHash ? V : unknown\n }\n } => {\n const palletItemEncoded = mergeUint8([\n palledEncoded,\n Twox128(textEncoder.encode(name)),\n ])\n\n const palletItemEncodedHex = toHex(palletItemEncoded)\n\n const dec = (\n key: string,\n ): {\n [K in keyof A]: A[K] extends EncoderWithHash ? V : unknown\n } => {\n if (!key.startsWith(palletItemEncodedHex))\n throw new Error(`key does not match this storage (${pallet}.${name})`)\n\n if (encoders.length === 0) return [] as any\n\n const argsKey = fromHex(key.slice(palletItemEncodedHex.length))\n const result = new Array(encoders.length)\n for (let i = 0, cur = 0; i < encoders.length; i++) {\n const [codec, hasher] = encoders[i]\n const hBytes = hashers.get(hasher)\n if (hBytes == null) throw new Error(\"Unknown hasher\")\n if (hBytes < 0) {\n const opaqueBytes = hBytes * -1\n result[i] = toHex(argsKey.slice(cur, cur + opaqueBytes))\n cur += opaqueBytes\n } else {\n cur += hBytes\n result[i] = codec.dec(argsKey.slice(cur))\n cur += codec.enc(result[i]).length\n }\n }\n return result as any\n }\n\n const fns = encoders.map(\n ([{ enc }, hash]) =>\n (val: any) =>\n hash(enc(val)),\n )\n\n const enc = (\n ...args: {\n [K in keyof A]: A[K] extends EncoderWithHash ? V : unknown\n }\n ): string =>\n toHex(\n mergeUint8([\n palletItemEncoded,\n ...args.map((val, idx) => fns[idx](val)),\n ]),\n )\n\n return {\n enc,\n dec,\n }\n }\n}\n"],"names":["enc"],"mappings":"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"} \ No newline at end of file diff --git a/packages/bizinikiwi-bindings/dist/esm/trie/node-decoder.mjs b/packages/bizinikiwi-bindings/dist/esm/trie/node-decoder.mjs new file mode 100644 index 0000000..b3dbdf6 --- /dev/null +++ b/packages/bizinikiwi-bindings/dist/esm/trie/node-decoder.mjs @@ -0,0 +1,66 @@ +import { u8, createDecoder, u16 } from 'scale-ts'; +import '../utils/ss58-util.mjs'; +import '../codecs/scale/Binary.mjs'; +import '../codecs/scale/bitSequence.mjs'; +import '../codecs/scale/char.mjs'; +import '../codecs/scale/compact.mjs'; +import { Hex } from '../codecs/scale/Hex.mjs'; +import '../codecs/scale/fixed-str.mjs'; +import '../codecs/scale/Variant.mjs'; +import '../codecs/scale/ethAccount.mjs'; +import '../codecs/scale/shaped.mjs'; +import '../codecs/scale/BitSeq.mjs'; +import '../codecs/blockHeader.mjs'; +import '../codecs/metadata/metadata.mjs'; +import '../codecs/metadata/v14.mjs'; +import '../codecs/metadata/v15.mjs'; +import '../codecs/metadata/v16.mjs'; +import '../codecs/metadata/lookup.mjs'; +import { TrieNodeHeaders } from './types.mjs'; + +const varHex = Hex().dec; +const allHex = Hex(Infinity).dec; +const hex32 = Hex(32).dec; +const byte = u8.dec; +const getHeader = (bytes) => { + const firstByte = byte(bytes); + let bitsLeft = 6; + const typeId = firstByte >> bitsLeft; + const type = typeId ? typeId === 1 ? TrieNodeHeaders.Leaf : typeId === 2 ? TrieNodeHeaders.Branch : TrieNodeHeaders.BranchWithVal : firstByte >> --bitsLeft ? TrieNodeHeaders.LeafWithHash : firstByte >> --bitsLeft ? TrieNodeHeaders.BranchWithHash : firstByte ? TrieNodeHeaders.Reserved : TrieNodeHeaders.Empty; + let nNibles = firstByte & 255 >> 8 - bitsLeft; + if (nNibles === 2 ** bitsLeft - 1) { + let current; + do + nNibles += current = byte(bytes); + while (current === 255); + } + return { + type, + partialKey: Hex(Math.ceil(nNibles / 2)).dec(bytes).slice(nNibles % 2 ? 3 : 2) + }; +}; +const trieNodeDec = createDecoder((bytes) => { + const header = getHeader(bytes); + const { type } = header; + if (type === "Empty" || type === "Reserved") return header; + if (type === "Leaf" || type === "LeafWithHash") + return { + ...header, + value: allHex(bytes) + }; + const bitmap = u16.dec(bytes); + const keys = []; + for (let i = 0; i < 16; i++) if (bitmap >> i & 1) keys.push(i.toString(16)); + let value = null; + if (type === "BranchWithVal") value = varHex(bytes); + if (type === "BranchWithHash") value = hex32(bytes); + const result = { + ...header, + children: Object.fromEntries(keys.map((key) => [key, varHex(bytes)])) + }; + if (value !== null) result.value = value; + return result; +}); + +export { trieNodeDec }; +//# sourceMappingURL=node-decoder.mjs.map diff --git a/packages/bizinikiwi-bindings/dist/esm/trie/node-decoder.mjs.map b/packages/bizinikiwi-bindings/dist/esm/trie/node-decoder.mjs.map new file mode 100644 index 0000000..6fb7e7c --- /dev/null +++ b/packages/bizinikiwi-bindings/dist/esm/trie/node-decoder.mjs.map @@ -0,0 +1 @@ +{"version":3,"file":"node-decoder.mjs","sources":["../../../src/trie/node-decoder.ts"],"sourcesContent":["import { createDecoder, Hex, u16, u8, type HexString } from \"../codecs\"\nimport { type TrieNodeHeaderKey, TrieNodeHeaders, type TrieNode } from \"./types\"\n\nconst varHex = Hex().dec\nconst allHex = Hex(Infinity).dec\nconst hex32 = Hex(32).dec\nconst byte = u8.dec\n\nconst getHeader = (\n bytes: Uint8Array,\n): { type: TrieNodeHeaderKey; partialKey: string } => {\n const firstByte = byte(bytes)\n\n let bitsLeft = 6\n const typeId = firstByte >> bitsLeft\n const type: TrieNodeHeaderKey = typeId\n ? typeId === 1\n ? TrieNodeHeaders.Leaf\n : typeId === 2\n ? TrieNodeHeaders.Branch\n : TrieNodeHeaders.BranchWithVal\n : firstByte >> --bitsLeft\n ? TrieNodeHeaders.LeafWithHash\n : firstByte >> --bitsLeft\n ? TrieNodeHeaders.BranchWithHash\n : firstByte\n ? TrieNodeHeaders.Reserved\n : TrieNodeHeaders.Empty\n\n let nNibles = firstByte & (0xff >> (8 - bitsLeft))\n if (nNibles === 2 ** bitsLeft - 1) {\n let current: number\n do nNibles += current = byte(bytes)\n while (current === 255)\n }\n\n return {\n type,\n partialKey: Hex(Math.ceil(nNibles / 2))\n .dec(bytes)\n .slice(nNibles % 2 ? 3 : 2),\n }\n}\n\nexport const trieNodeDec = createDecoder((bytes): TrieNode => {\n const header = getHeader(bytes)\n const { type } = header\n\n if (type === \"Empty\" || type === \"Reserved\") return header as TrieNode\n if (type === \"Leaf\" || type === \"LeafWithHash\")\n return {\n ...header,\n value: allHex(bytes),\n } as TrieNode\n\n const bitmap = u16.dec(bytes)\n const keys: string[] = []\n for (let i = 0; i < 16; i++) if ((bitmap >> i) & 1) keys.push(i.toString(16))\n\n let value: null | HexString = null\n if (type === \"BranchWithVal\") value = varHex(bytes)\n if (type === \"BranchWithHash\") value = hex32(bytes)\n\n const result: any = {\n ...header,\n children: Object.fromEntries(keys.map((key) => [key, varHex(bytes)])),\n }\n if (value !== null) result.value = value\n return result\n})\n"],"names":[],"mappings":"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"} \ No newline at end of file diff --git a/packages/bizinikiwi-bindings/dist/esm/trie/proofs.mjs b/packages/bizinikiwi-bindings/dist/esm/trie/proofs.mjs new file mode 100644 index 0000000..f3956b6 --- /dev/null +++ b/packages/bizinikiwi-bindings/dist/esm/trie/proofs.mjs @@ -0,0 +1,75 @@ +import { toHex } from '@pezkuwi/papi-utils'; +import { createDecoder } from 'scale-ts'; +import '../utils/ss58-util.mjs'; +import '../codecs/scale/Binary.mjs'; +import '../codecs/scale/bitSequence.mjs'; +import '../codecs/scale/char.mjs'; +import '../codecs/scale/compact.mjs'; +import '../codecs/scale/Hex.mjs'; +import '../codecs/scale/fixed-str.mjs'; +import '../codecs/scale/Variant.mjs'; +import '../codecs/scale/ethAccount.mjs'; +import '../codecs/scale/shaped.mjs'; +import '../codecs/scale/BitSeq.mjs'; +import '../codecs/blockHeader.mjs'; +import '../codecs/metadata/metadata.mjs'; +import '../codecs/metadata/v14.mjs'; +import '../codecs/metadata/v15.mjs'; +import '../codecs/metadata/v16.mjs'; +import '../codecs/metadata/lookup.mjs'; +import { trieNodeDec } from './node-decoder.mjs'; +import { Blake2256 } from '../hashes/blake2.mjs'; +import '@noble/hashes/blake3.js'; +import '@noble/hashes/sha3.js'; + +const TrieNodeWithHash = (hasher) => createDecoder((input) => { + const hash = toHex(hasher(new Uint8Array(input.buffer))); + try { + return { + hash, + ...trieNodeDec(input) + }; + } catch { + return { type: "Raw", hash, value: "" }; + } +}); +const validateProofs = (proofs, hasher = Blake2256) => { + const proofsList = proofs.map(TrieNodeWithHash(hasher)); + const proofsRecord = Object.fromEntries(proofsList.map((p) => [p.hash, p])); + const hashes = proofsList.map((p) => p.hash); + const roots = new Set(hashes); + const setRawValue = (input) => { + if (input.value) return; + const val = proofs[hashes.indexOf(input.hash)]; + input.value = typeof val === "string" ? val : toHex(val); + }; + proofsList.forEach((p) => { + if ("children" in p) { + Object.values(p.children).forEach((hash) => { + const child = proofsRecord[hash]; + if (child) { + child.parent = p.hash; + roots.delete(hash); + } + }); + } + if (p.type === "BranchWithHash" || p.type === "LeafWithHash") { + const childHash = p.value; + const child = proofsRecord[childHash]; + if (!child) return; + roots.delete(childHash); + if (child.type !== "Raw") { + Object.keys(child).forEach((k) => delete child[k]); + child.type = "Raw"; + child.hash = childHash; + } + child.parent = p.hash; + setRawValue(child); + } + if (p.type === "Raw") setRawValue(p); + }); + return roots.size === 1 ? { rootHash: roots.values().next().value, proofs: proofsRecord } : null; +}; + +export { TrieNodeWithHash, validateProofs }; +//# sourceMappingURL=proofs.mjs.map diff --git a/packages/bizinikiwi-bindings/dist/esm/trie/proofs.mjs.map b/packages/bizinikiwi-bindings/dist/esm/trie/proofs.mjs.map new file mode 100644 index 0000000..435441f --- /dev/null +++ b/packages/bizinikiwi-bindings/dist/esm/trie/proofs.mjs.map @@ -0,0 +1 @@ +{"version":3,"file":"proofs.mjs","sources":["../../../src/trie/proofs.ts"],"sourcesContent":["import { toHex } from \"@pezkuwi/papi-utils\"\nimport { createDecoder, type HexString } from \"../codecs\"\nimport { trieNodeDec } from \"./node-decoder\"\nimport { Blake2256 } from \"@/hashes\"\nimport { type ProofTrieNode } from \"./types\"\n\nexport const TrieNodeWithHash = (hasher: (input: Uint8Array) => Uint8Array) =>\n createDecoder((input): ProofTrieNode => {\n const hash = toHex(hasher(new Uint8Array(input.buffer)))\n try {\n return {\n hash,\n ...trieNodeDec(input),\n }\n } catch {\n // Sometimes the proofs include random raw-values which are not trie-nodes\n return { type: \"Raw\", hash, value: \"\" }\n }\n })\n\nexport const validateProofs = (\n proofs: Array,\n hasher: (input: Uint8Array) => Uint8Array = Blake2256,\n): { rootHash: HexString; proofs: Record } | null => {\n const proofsList = proofs.map(TrieNodeWithHash(hasher))\n const proofsRecord = Object.fromEntries(proofsList.map((p) => [p.hash, p]))\n const hashes = proofsList.map((p) => p.hash)\n const roots = new Set(hashes)\n\n const setRawValue = (input: {\n type: \"Raw\"\n hash: HexString\n value: HexString\n }) => {\n if (input.value) return\n const val = proofs[hashes.indexOf(input.hash)!]\n input.value = typeof val === \"string\" ? val : toHex(val)\n }\n\n proofsList.forEach((p) => {\n if (\"children\" in p) {\n Object.values(p.children).forEach((hash) => {\n const child = proofsRecord[hash]\n if (child) {\n child.parent = p.hash\n roots.delete(hash)\n }\n })\n }\n\n if (p.type === \"BranchWithHash\" || p.type === \"LeafWithHash\") {\n const childHash = p.value\n const child = proofsRecord[childHash]\n if (!child) return\n\n roots.delete(childHash)\n if (child.type !== \"Raw\") {\n Object.keys(child).forEach((k) => delete (child as any)[k])\n ;(child as any).type = \"Raw\"\n child.hash = childHash\n }\n child.parent = p.hash\n setRawValue(child as any)\n }\n\n if (p.type === \"Raw\") setRawValue(p)\n })\n\n return roots.size === 1\n ? { rootHash: roots.values().next().value!, proofs: proofsRecord }\n : null\n}\n"],"names":[],"mappings":"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"} \ No newline at end of file diff --git a/packages/bizinikiwi-bindings/dist/esm/trie/types.mjs b/packages/bizinikiwi-bindings/dist/esm/trie/types.mjs new file mode 100644 index 0000000..56de6cc --- /dev/null +++ b/packages/bizinikiwi-bindings/dist/esm/trie/types.mjs @@ -0,0 +1,12 @@ +const TrieNodeHeaders = { + Leaf: "Leaf", + Branch: "Branch", + BranchWithVal: "BranchWithVal", + LeafWithHash: "LeafWithHash", + BranchWithHash: "BranchWithHash", + Empty: "Empty", + Reserved: "Reserved" +}; + +export { TrieNodeHeaders }; +//# sourceMappingURL=types.mjs.map diff --git a/packages/bizinikiwi-bindings/dist/esm/trie/types.mjs.map b/packages/bizinikiwi-bindings/dist/esm/trie/types.mjs.map new file mode 100644 index 0000000..a982e63 --- /dev/null +++ b/packages/bizinikiwi-bindings/dist/esm/trie/types.mjs.map @@ -0,0 +1 @@ +{"version":3,"file":"types.mjs","sources":["../../../src/trie/types.ts"],"sourcesContent":["import { type HexString } from \"../codecs\"\n\nexport const TrieNodeHeaders = {\n Leaf: \"Leaf\",\n Branch: \"Branch\",\n BranchWithVal: \"BranchWithVal\",\n LeafWithHash: \"LeafWithHash\",\n BranchWithHash: \"BranchWithHash\",\n Empty: \"Empty\",\n Reserved: \"Reserved\",\n} as const\ntype TrieNodeHeaders = typeof TrieNodeHeaders\nexport type TrieNodeHeaderKey =\n (typeof TrieNodeHeaders)[keyof typeof TrieNodeHeaders]\n\nexport type Nibble =\n | \"0\"\n | \"1\"\n | \"2\"\n | \"3\"\n | \"4\"\n | \"5\"\n | \"6\"\n | \"7\"\n | \"8\"\n | \"9\"\n | \"a\"\n | \"b\"\n | \"c\"\n | \"d\"\n | \"e\"\n | \"f\"\n\nexport type TrieNode = { partialKey: string } & (\n | {\n type: TrieNodeHeaders[\"Empty\"] | TrieNodeHeaders[\"Reserved\"]\n }\n | {\n type: TrieNodeHeaders[\"Leaf\"] | TrieNodeHeaders[\"LeafWithHash\"]\n value: HexString\n }\n | ({ children: Record } & (\n | { type: TrieNodeHeaders[\"Branch\"] }\n | {\n type:\n | TrieNodeHeaders[\"BranchWithHash\"]\n | TrieNodeHeaders[\"BranchWithVal\"]\n value: HexString\n }\n ))\n)\nexport type ProofTrieNode = {\n hash: HexString\n parent?: HexString\n} & (TrieNode | { type: \"Raw\"; value: HexString })\n"],"names":[],"mappings":"AAEO,MAAM,eAAA,GAAkB;AAAA,EAC7B,IAAA,EAAM,MAAA;AAAA,EACN,MAAA,EAAQ,QAAA;AAAA,EACR,aAAA,EAAe,eAAA;AAAA,EACf,YAAA,EAAc,cAAA;AAAA,EACd,cAAA,EAAgB,gBAAA;AAAA,EAChB,KAAA,EAAO,OAAA;AAAA,EACP,QAAA,EAAU;AACZ;;;;"} \ No newline at end of file diff --git a/packages/bizinikiwi-bindings/dist/esm/types/enum.mjs b/packages/bizinikiwi-bindings/dist/esm/types/enum.mjs new file mode 100644 index 0000000..e6fd9df --- /dev/null +++ b/packages/bizinikiwi-bindings/dist/esm/types/enum.mjs @@ -0,0 +1,29 @@ +const discriminant = { + is(value, type) { + return value.type === type; + }, + as(value, type) { + if (type !== value.type) + throw new Error( + `Enum.as(enum, ${type}) used with actual type ${value.type}` + ); + return value; + } +}; +const Enum = Object.assign((type, value) => { + return { + type, + value + }; +}, discriminant); +const _Enum = new Proxy( + {}, + { + get(_, prop) { + return (value) => Enum(prop, value); + } + } +); + +export { Enum, _Enum }; +//# sourceMappingURL=enum.mjs.map diff --git a/packages/bizinikiwi-bindings/dist/esm/types/enum.mjs.map b/packages/bizinikiwi-bindings/dist/esm/types/enum.mjs.map new file mode 100644 index 0000000..f8d340e --- /dev/null +++ b/packages/bizinikiwi-bindings/dist/esm/types/enum.mjs.map @@ -0,0 +1 @@ +{"version":3,"file":"enum.mjs","sources":["../../../src/types/enum.ts"],"sourcesContent":["export type Enum = {\n [K in keyof T & string]: {\n type: K\n value: T[K]\n }\n}[keyof T & string]\n\nexport type EnumVariant<\n T extends { type: string; value?: any },\n K extends T[\"type\"],\n> = T & {\n type: K\n}\n\nexport type ExtractEnumValue<\n T extends { type: string; value?: any },\n K extends string,\n> = EnumVariant[\"value\"]\n\ntype ValueArg = undefined extends V ? [value?: V] : [value: V]\n\ninterface Discriminant {\n is(\n value: T,\n type: K,\n ): value is T & { type: K }\n as(\n value: T,\n type: K,\n ): ExtractEnumValue\n}\nconst discriminant: Discriminant = {\n is(\n value: T,\n type: K,\n ): value is T & { type: K } {\n return value.type === type\n },\n as(value, type) {\n if (type !== value.type)\n throw new Error(\n `Enum.as(enum, ${type}) used with actual type ${value.type}`,\n )\n return value\n },\n}\ninterface EnumFn extends Discriminant {\n (\n type: K,\n ...[value]: ValueArg>\n ): EnumVariant\n}\nexport const Enum: EnumFn = Object.assign((type: string, value?: any) => {\n return {\n type,\n value,\n } as any\n}, discriminant)\n\n// well-known enums\nexport type GetEnum> = {\n [K in T[\"type\"]]: (\n ...args: ExtractEnumValue extends undefined\n ? []\n : [value: ExtractEnumValue]\n ) => EnumVariant\n}\nexport const _Enum = new Proxy(\n {},\n {\n get(_, prop: string) {\n return (value: string) => Enum(prop, value)\n },\n },\n)\n\n// type Bar = Enum<{\n// Kaka: 1\n// Bar: 2\n// }>\n\n// type FooInput = Enum<{\n// foo: \"foo\" | undefined\n// bar: Bar\n// baz: number\n// wtf: boolean\n// }>\n\n// declare function foo(foo: FooInput): void\n// foo(Enum(\"bar\", Enum(\"Bar\", 2)))\n\n// const InputEnum: GetEnum = null as any;\n// InputEnum.bar(Enum('Bar', 2))\n"],"names":[],"mappings":"AA+BA,MAAM,YAAA,GAA6B;AAAA,EACjC,EAAA,CACE,OACA,IAAA,EAC0B;AAC1B,IAAA,OAAO,MAAM,IAAA,KAAS,IAAA;AAAA,EACxB,CAAA;AAAA,EACA,EAAA,CAAG,OAAO,IAAA,EAAM;AACd,IAAA,IAAI,SAAS,KAAA,CAAM,IAAA;AACjB,MAAA,MAAM,IAAI,KAAA;AAAA,QACR,CAAA,cAAA,EAAiB,IAAI,CAAA,wBAAA,EAA2B,KAAA,CAAM,IAAI,CAAA;AAAA,OAC5D;AACF,IAAA,OAAO,KAAA;AAAA,EACT;AACF,CAAA;AAOO,MAAM,IAAA,GAAe,MAAA,CAAO,MAAA,CAAO,CAAC,MAAc,KAAA,KAAgB;AACvE,EAAA,OAAO;AAAA,IACL,IAAA;AAAA,IACA;AAAA,GACF;AACF,CAAA,EAAG,YAAY;AAUR,MAAM,QAAQ,IAAI,KAAA;AAAA,EACvB,EAAC;AAAA,EACD;AAAA,IACE,GAAA,CAAI,GAAG,IAAA,EAAc;AACnB,MAAA,OAAO,CAAC,KAAA,KAAkB,IAAA,CAAK,IAAA,EAAM,KAAK,CAAA;AAAA,IAC5C;AAAA;AAEJ;;;;"} \ No newline at end of file diff --git a/packages/bizinikiwi-bindings/dist/esm/utils/multisig.mjs b/packages/bizinikiwi-bindings/dist/esm/utils/multisig.mjs new file mode 100644 index 0000000..5b89d32 --- /dev/null +++ b/packages/bizinikiwi-bindings/dist/esm/utils/multisig.mjs @@ -0,0 +1,50 @@ +import { mergeUint8 } from '@pezkuwi/papi-utils'; +import { compact, u16 } from 'scale-ts'; +import './ss58-util.mjs'; +import { Binary } from '../codecs/scale/Binary.mjs'; +import '../codecs/scale/bitSequence.mjs'; +import '../codecs/scale/char.mjs'; +import '../codecs/scale/compact.mjs'; +import '../codecs/scale/Hex.mjs'; +import '../codecs/scale/fixed-str.mjs'; +import '../codecs/scale/Variant.mjs'; +import '../codecs/scale/ethAccount.mjs'; +import '../codecs/scale/shaped.mjs'; +import '../codecs/scale/BitSeq.mjs'; +import '../codecs/blockHeader.mjs'; +import '../codecs/metadata/metadata.mjs'; +import '../codecs/metadata/v14.mjs'; +import '../codecs/metadata/v15.mjs'; +import '../codecs/metadata/v16.mjs'; +import '../codecs/metadata/lookup.mjs'; +import { Blake2256 } from '../hashes/blake2.mjs'; +import '@noble/hashes/blake3.js'; +import '@noble/hashes/sha3.js'; + +const PREFIX = Binary.fromText("modlpy/utilisuba").asBytes(); +const getMultisigAccountId = ({ + threshold, + signatories +}) => { + const sortedSignatories = sortMultisigSignatories(signatories); + const payload = mergeUint8([ + PREFIX, + compact.enc(sortedSignatories.length), + ...sortedSignatories, + u16.enc(threshold) + ]); + return Blake2256(payload); +}; +const sortMultisigSignatories = (signatories) => signatories.slice().sort((a, b) => { + for (let i = 0; ; i++) { + const overA = i >= a.length; + const overB = i >= b.length; + if (overA && overB) return 0; + else if (overA) return -1; + else if (overB) return 1; + else if (a[i] !== b[i]) return a[i] > b[i] ? 1 : -1; + } +}); + +export { getMultisigAccountId, sortMultisigSignatories }; +//# sourceMappingURL=multisig.mjs.map diff --git a/packages/bizinikiwi-bindings/dist/esm/utils/multisig.mjs.map b/packages/bizinikiwi-bindings/dist/esm/utils/multisig.mjs.map new file mode 100644 index 0000000..d7ad2ec --- /dev/null +++ b/packages/bizinikiwi-bindings/dist/esm/utils/multisig.mjs.map @@ -0,0 +1 @@ +{"version":3,"file":"multisig.mjs","sources":["../../../src/utils/multisig.ts"],"sourcesContent":["import { mergeUint8 } from \"@pezkuwi/papi-utils\"\nimport { Binary, compact, u16 } from \"../codecs\"\nimport { Blake2256 } from \"../hashes\"\n\nconst PREFIX = Binary.fromText(\"modlpy/utilisuba\").asBytes()\nexport const getMultisigAccountId = ({\n threshold,\n signatories,\n}: {\n threshold: number\n signatories: Uint8Array[]\n}) => {\n const sortedSignatories = sortMultisigSignatories(signatories)\n const payload = mergeUint8([\n PREFIX,\n compact.enc(sortedSignatories.length),\n ...sortedSignatories,\n u16.enc(threshold),\n ])\n return Blake2256(payload)\n}\n\nexport const sortMultisigSignatories = (signatories: Uint8Array[]) =>\n signatories.slice().sort((a, b) => {\n for (let i = 0; ; i++) {\n const overA = i >= a.length\n const overB = i >= b.length\n\n if (overA && overB) return 0\n else if (overA) return -1\n else if (overB) return 1\n else if (a[i] !== b[i]) return a[i] > b[i] ? 1 : -1\n }\n })\n"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;AAIA,MAAM,MAAA,GAAS,MAAA,CAAO,QAAA,CAAS,kBAAkB,EAAE,OAAA,EAAQ;AACpD,MAAM,uBAAuB,CAAC;AAAA,EACnC,SAAA;AAAA,EACA;AACF,CAAA,KAGM;AACJ,EAAA,MAAM,iBAAA,GAAoB,wBAAwB,WAAW,CAAA;AAC7D,EAAA,MAAM,UAAU,UAAA,CAAW;AAAA,IACzB,MAAA;AAAA,IACA,OAAA,CAAQ,GAAA,CAAI,iBAAA,CAAkB,MAAM,CAAA;AAAA,IACpC,GAAG,iBAAA;AAAA,IACH,GAAA,CAAI,IAAI,SAAS;AAAA,GAClB,CAAA;AACD,EAAA,OAAO,UAAU,OAAO,CAAA;AAC1B;AAEO,MAAM,uBAAA,GAA0B,CAAC,WAAA,KACtC,WAAA,CAAY,OAAM,CAAE,IAAA,CAAK,CAAC,CAAA,EAAG,CAAA,KAAM;AACjC,EAAA,KAAA,IAAS,CAAA,GAAI,KAAK,CAAA,EAAA,EAAK;AACrB,IAAA,MAAM,KAAA,GAAQ,KAAK,CAAA,CAAE,MAAA;AACrB,IAAA,MAAM,KAAA,GAAQ,KAAK,CAAA,CAAE,MAAA;AAErB,IAAA,IAAI,KAAA,IAAS,OAAO,OAAO,CAAA;AAAA,SAAA,IAClB,OAAO,OAAO,EAAA;AAAA,SAAA,IACd,OAAO,OAAO,CAAA;AAAA,SAAA,IACd,CAAA,CAAE,CAAC,CAAA,KAAM,CAAA,CAAE,CAAC,CAAA,EAAG,OAAO,CAAA,CAAE,CAAC,CAAA,GAAI,CAAA,CAAE,CAAC,IAAI,CAAA,GAAI,EAAA;AAAA,EACnD;AACF,CAAC;;;;"} \ No newline at end of file diff --git a/packages/bizinikiwi-bindings/dist/esm/utils/ss58-util.mjs b/packages/bizinikiwi-bindings/dist/esm/utils/ss58-util.mjs new file mode 100644 index 0000000..b522e51 --- /dev/null +++ b/packages/bizinikiwi-bindings/dist/esm/utils/ss58-util.mjs @@ -0,0 +1,77 @@ +import { base58 } from '@scure/base'; +import { blake2b } from '@noble/hashes/blake2.js'; + +const SS58_PREFIX = new TextEncoder().encode("SS58PRE"); +const CHECKSUM_LENGTH = 2; +const getSs58AddressInfo = (address) => { + try { + const decoded = base58.decode(address); + const prefixBytes = decoded.subarray(0, decoded[0] & 64 ? 2 : 1); + const publicKey = decoded.subarray( + prefixBytes.length, + decoded.length - CHECKSUM_LENGTH + ); + const checksum = decoded.subarray(prefixBytes.length + publicKey.length); + const expectedChecksum = blake2b( + Uint8Array.of(...SS58_PREFIX, ...prefixBytes, ...publicKey), + { + dkLen: 64 + } + ).subarray(0, CHECKSUM_LENGTH); + const isChecksumValid = checksum[0] === expectedChecksum[0] && checksum[1] === expectedChecksum[1]; + if (!isChecksumValid) return { isValid: false }; + return { + isValid: true, + ss58Format: prefixBytesToNumber(prefixBytes), + publicKey: publicKey.slice() + }; + } catch (_) { + return { isValid: false }; + } +}; +const prefixBytesToNumber = (bytes) => { + const dv = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength); + return dv.byteLength === 1 ? dv.getUint8(0) : dv.getUint16(0); +}; +const withSs58Cache = (fn) => { + let cache = {}; + let activityCount = 0; + let latestCount = 0; + const checkActivity = () => { + if (activityCount === latestCount) { + cache = {}; + activityCount = latestCount = 0; + } else { + latestCount = activityCount; + setTimeout(checkActivity, 0); + } + }; + return (publicKey) => { + var _a, _b; + if (++activityCount === 1) checkActivity(); + let entry = cache; + const lastIdx = publicKey.length - 1; + for (let i = 0; i <= lastIdx; i++) entry = entry[_a = publicKey[i]] || (entry[_a] = {}); + return entry[_b = publicKey[lastIdx]] || (entry[_b] = fn(publicKey)); + }; +}; +const fromBufferToBase58 = (ss58Format) => { + const prefixBytes = ss58Format < 64 ? Uint8Array.of(ss58Format) : Uint8Array.of( + (ss58Format & 252) >> 2 | 64, + ss58Format >> 8 | (ss58Format & 3) << 6 + ); + return withSs58Cache((publicKey) => { + const checksum = blake2b( + Uint8Array.of(...SS58_PREFIX, ...prefixBytes, ...publicKey), + { + dkLen: 64 + } + ).subarray(0, CHECKSUM_LENGTH); + return base58.encode( + Uint8Array.of(...prefixBytes, ...publicKey, ...checksum) + ); + }); +}; + +export { fromBufferToBase58, getSs58AddressInfo }; +//# sourceMappingURL=ss58-util.mjs.map diff --git a/packages/bizinikiwi-bindings/dist/esm/utils/ss58-util.mjs.map b/packages/bizinikiwi-bindings/dist/esm/utils/ss58-util.mjs.map new file mode 100644 index 0000000..ffe449e --- /dev/null +++ b/packages/bizinikiwi-bindings/dist/esm/utils/ss58-util.mjs.map @@ -0,0 +1 @@ +{"version":3,"file":"ss58-util.mjs","sources":["../../../src/utils/ss58-util.ts"],"sourcesContent":["import { base58 } from \"@scure/base\"\nimport { blake2b } from \"@noble/hashes/blake2.js\"\n\nconst SS58_PREFIX = new TextEncoder().encode(\"SS58PRE\")\nconst CHECKSUM_LENGTH = 2\n\nexport type SS58String = string & { __SS58String?: unknown }\nexport type SS58AddressInfo =\n | { isValid: false }\n | { isValid: true; ss58Format: number; publicKey: Uint8Array }\n\nexport const getSs58AddressInfo = (address: SS58String): SS58AddressInfo => {\n try {\n const decoded = base58.decode(address)\n const prefixBytes = decoded.subarray(0, decoded[0] & 0b0100_0000 ? 2 : 1)\n const publicKey = decoded.subarray(\n prefixBytes.length,\n decoded.length - CHECKSUM_LENGTH,\n )\n\n const checksum = decoded.subarray(prefixBytes.length + publicKey.length)\n const expectedChecksum = blake2b(\n Uint8Array.of(...SS58_PREFIX, ...prefixBytes, ...publicKey),\n {\n dkLen: 64,\n },\n ).subarray(0, CHECKSUM_LENGTH)\n\n const isChecksumValid =\n checksum[0] === expectedChecksum[0] && checksum[1] === expectedChecksum[1]\n\n if (!isChecksumValid) return { isValid: false }\n\n return {\n isValid: true,\n ss58Format: prefixBytesToNumber(prefixBytes),\n publicKey: publicKey.slice(),\n }\n } catch (_) {\n return { isValid: false }\n }\n}\n\nconst prefixBytesToNumber = (bytes: Uint8Array) => {\n const dv = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength)\n return dv.byteLength === 1 ? dv.getUint8(0) : dv.getUint16(0)\n}\n\nconst withSs58Cache = (fn: (publicKey: Uint8Array) => SS58String) => {\n let cache: Record = {}\n let activityCount = 0\n let latestCount = 0\n const checkActivity = () => {\n if (activityCount === latestCount) {\n cache = {}\n activityCount = latestCount = 0\n } else {\n latestCount = activityCount\n setTimeout(checkActivity, 0)\n }\n }\n\n return (publicKey: Uint8Array): SS58String => {\n if (++activityCount === 1) checkActivity()\n\n let entry = cache\n const lastIdx = publicKey.length - 1\n for (let i = 0; i <= lastIdx; i++) entry = entry[publicKey[i]] ||= {}\n return (entry[publicKey[lastIdx]] ||= fn(publicKey))\n }\n}\n\nexport const fromBufferToBase58 = (ss58Format: number) => {\n const prefixBytes =\n ss58Format < 64\n ? Uint8Array.of(ss58Format)\n : Uint8Array.of(\n ((ss58Format & 0b0000_0000_1111_1100) >> 2) | 0b0100_0000,\n (ss58Format >> 8) | ((ss58Format & 0b0000_0000_0000_0011) << 6),\n )\n\n return withSs58Cache((publicKey: Uint8Array): SS58String => {\n const checksum = blake2b(\n Uint8Array.of(...SS58_PREFIX, ...prefixBytes, ...publicKey),\n {\n dkLen: 64,\n },\n ).subarray(0, CHECKSUM_LENGTH)\n return base58.encode(\n Uint8Array.of(...prefixBytes, ...publicKey, ...checksum),\n )\n })\n}\n"],"names":[],"mappings":"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"} \ No newline at end of file diff --git a/packages/bizinikiwi-bindings/dist/index.d.ts b/packages/bizinikiwi-bindings/dist/index.d.ts new file mode 100644 index 0000000..d8b3a80 --- /dev/null +++ b/packages/bizinikiwi-bindings/dist/index.d.ts @@ -0,0 +1,2305 @@ +import * as scale_ts from 'scale-ts'; +import { Codec, Encoder, Decoder, StringRecord, CodecType, EncoderType, DecoderType, ResultPayload } from 'scale-ts'; +export { Bytes, Codec, CodecType, Decoder, DecoderType, Encoder, EncoderType, ResultPayload, StringRecord, _void, bool, compact, createCodec, createDecoder, enhanceCodec, enhanceDecoder, enhanceEncoder, i128, i16, i256, i32, i64, i8, str, u128, u16, u256, u32, u64, u8 } from 'scale-ts'; + +type SS58String = string & { + __SS58String?: unknown; +}; +type SS58AddressInfo = { + isValid: false; +} | { + isValid: true; + ss58Format: number; + publicKey: Uint8Array; +}; +declare const getSs58AddressInfo: (address: SS58String) => SS58AddressInfo; +declare const fromBufferToBase58: (ss58Format: number) => (publicKey: Uint8Array) => SS58String; + +declare const AccountId: (ss58Format?: number, nBytes?: 32 | 33) => scale_ts.Codec; + +type HexString = string & { + __hexString?: unknown; +}; +declare const Hex: { + (nBytes?: number): Codec; + enc: (nBytes?: number) => Encoder; + dec: (nBytes?: number) => Decoder; +}; + +declare const getMultisigAccountId: ({ threshold, signatories, }: { + threshold: number; + signatories: Uint8Array[]; +}) => Uint8Array; +declare const sortMultisigSignatories: (signatories: Uint8Array[]) => Uint8Array[]; + +declare class Binary { + #private; + constructor(data: Uint8Array, opaque?: boolean); + asText: () => string; + asHex: () => `0x${string}`; + asOpaqueHex: () => `0x${string}`; + asBytes: () => Uint8Array; + asOpaqueBytes: () => Uint8Array; + static fromText(input: string): Binary; + static fromHex(input: HexString): Binary; + static fromOpaqueHex(input: HexString): Binary; + static fromBytes(input: Uint8Array): Binary; + static fromOpaqueBytes(input: Uint8Array): Binary; +} +declare class FixedSizeBinary<_L extends number> extends Binary { + constructor(data: Uint8Array); + static fromArray & { + length: L; + }>(input: I): FixedSizeBinary; + static fromAccountId32(input: L extends 32 ? SS58String : never): FixedSizeBinary; +} +declare const Bin: { + (nBytes?: number): Codec; + enc: (nBytes?: number) => Encoder; + dec: (nBytes?: number) => Decoder; +}; + +interface BitSequence { + bitsLen: number; + bytes: Uint8Array; +} +declare const bitSequence: scale_ts.Codec; + +declare const char: scale_ts.Codec; + +declare const compactNumber: scale_ts.Codec; +declare const compactBn: scale_ts.Codec; + +declare const fixedStr: (nBytes: number) => scale_ts.Codec; + +declare const selfEncoder: (value: () => Encoder) => Encoder; +declare const selfDecoder: (value: () => Decoder) => Decoder; +declare const Self: (value: () => Codec) => Codec; + +type EnumVariant = T & { + type: K; +}; +type ExtractEnumValue = EnumVariant["value"]; +type ValueArg = undefined extends V ? [value?: V] : [value: V]; +interface Discriminant { + is(value: T, type: K): value is T & { + type: K; + }; + as(value: T, type: K): ExtractEnumValue; +} +interface EnumFn extends Discriminant { + (type: K, ...[value]: ValueArg>): EnumVariant; +} +type Enum = { + [K in keyof T & string]: { + type: K; + value: T[K]; + }; +}[keyof T & string]; +declare const Enum: EnumFn; +type GetEnum> = { + [K in T["type"]]: (...args: ExtractEnumValue extends undefined ? [] : [value: ExtractEnumValue]) => EnumVariant; +}; +declare const _Enum: {}; + +type Tuple$1 = readonly [T, ...T[]] & { + length: N; +}; +type Push = [...T, V]; +type UnionToIntersection = (U extends any ? (k: U) => void : never) extends (k: infer I) => void ? I : never; +type LastOf = UnionToIntersection T : never> extends () => infer R ? R : never; +type TuplifyUnion, N = [T] extends [never] ? true : false> = true extends N ? [] : Push>, L>; +type RestrictedLenTuple> = Tuple$1 extends Tuple$1 ? V : 0>; +declare const Variant: { + >>(inner: O, indexes?: RestrictedLenTuple | undefined): Codec; + }>> & { + inner: O; + }; + enc: >>(inner: O_1, x?: RestrictedLenTuple | undefined) => Encoder; + }>> & { + inner: O_1; + }; + dec: >>(inner: O_2, x?: RestrictedLenTuple | undefined) => Decoder; + }>> & { + inner: O_2; + }; +}; +declare const ScaleEnum: { + >>(inner: O, indexes?: RestrictedLenTuple | undefined): Codec<{ + [K in keyof O]: { + tag: K; + value: CodecType; + }; + }[keyof O]> & { + inner: O; + }; + enc: >>(inner: O_1, x?: RestrictedLenTuple | undefined) => Encoder<{ + [K_1 in keyof O_1]: { + tag: K_1; + value: EncoderType; + }; + }[keyof O_1]> & { + inner: O_1; + }; + dec: >>(inner: O_2, x?: RestrictedLenTuple | undefined) => Decoder<{ + [K_2 in keyof O_2]: { + tag: K_2; + value: DecoderType; + }; + }[keyof O_2]> & { + inner: O_2; + }; +}; + +declare const ethAccount: scale_ts.Codec; + +declare const Struct: { + >>(codecs: A): Codec<{ + [K in keyof A]: CodecType; + }> & { + inner: A; + }; + enc: >>(encoders: A_1) => Encoder<{ + [K_1 in keyof A_1]: EncoderType; + }> & { + inner: A_1; + }; + dec: >>(decoders: A_2) => Decoder<{ + [K_2 in keyof A_2]: DecoderType; + }> & { + inner: A_2; + }; +}; +declare const Tuple: { + []>(...inner: A): Codec<{ + [K in keyof A]: A[K] extends Codec ? D : unknown; + }> & { + inner: A; + }; + enc: []>(...encoders: A_1) => Encoder<{ + [K_1 in keyof A_1]: A_1[K_1] extends Encoder ? D_1 : unknown; + }> & { + inner: A_1; + }; + dec: []>(...decoders: A_2) => Decoder<{ + [K_2 in keyof A_2]: A_2[K_2] extends Decoder ? D_2 : unknown; + }> & { + inner: A_2; + }; +}; +declare const Vector: { + (inner: Codec, size?: number | undefined): Codec & { + inner: Codec; + }; + enc: (inner: Encoder, size?: number | undefined) => Encoder & { + inner: Encoder; + }; + dec: (getter: Decoder, size?: number | undefined) => Decoder & { + inner: Decoder; + }; +}; +declare const Result: { + (okCodec: Codec, koCodec: Codec): Codec> & { + inner: { + ok: Codec; + ko: Codec; + }; + }; + dec: (okDecoder: Decoder, koDecoder: Decoder) => Decoder> & { + inner: { + ok: Decoder; + ko: Decoder; + }; + }; + enc: (okEncoder: Encoder, koEncoder: Encoder) => Encoder> & { + inner: { + ok: Encoder; + ko: Encoder; + }; + }; +}; +declare const Option: { + (inner: Codec): Codec & { + inner: Codec; + }; + enc: (inner: Encoder) => Encoder & { + inner: Encoder; + }; + dec: (inner: Decoder) => Decoder & { + inner: Decoder; + }; +}; + +type BitSeq = Array<0 | 1>; +declare const BitSeq: { + (isLsb?: boolean): Codec; + enc: (isLsb?: boolean) => Encoder; + dec: (isLsb?: boolean) => Decoder; +}; + +declare const blockHeader: [scale_ts.Encoder<{ + parentHash: HexString; + number: number; + stateRoot: HexString; + extrinsicRoot: HexString; + digests: Enum<{ + other: Uint8Array; + consensus: { + engine: string; + payload: HexString; + }; + seal: { + engine: string; + payload: HexString; + }; + preRuntime: { + engine: string; + payload: HexString; + }; + runtimeUpdated: undefined; + }>[]; +}>, scale_ts.Decoder<{ + parentHash: HexString; + number: number; + stateRoot: HexString; + extrinsicRoot: HexString; + digests: Enum<{ + other: Uint8Array; + consensus: { + engine: string; + payload: HexString; + }; + seal: { + engine: string; + payload: HexString; + }; + preRuntime: { + engine: string; + payload: HexString; + }; + runtimeUpdated: undefined; + }>[]; +}>] & { + enc: scale_ts.Encoder<{ + parentHash: HexString; + number: number; + stateRoot: HexString; + extrinsicRoot: HexString; + digests: Enum<{ + other: Uint8Array; + consensus: { + engine: string; + payload: HexString; + }; + seal: { + engine: string; + payload: HexString; + }; + preRuntime: { + engine: string; + payload: HexString; + }; + runtimeUpdated: undefined; + }>[]; + }>; + dec: scale_ts.Decoder<{ + parentHash: HexString; + number: number; + stateRoot: HexString; + extrinsicRoot: HexString; + digests: Enum<{ + other: Uint8Array; + consensus: { + engine: string; + payload: HexString; + }; + seal: { + engine: string; + payload: HexString; + }; + preRuntime: { + engine: string; + payload: HexString; + }; + runtimeUpdated: undefined; + }>[]; + }>; +} & { + inner: { + parentHash: scale_ts.Codec; + number: scale_ts.Codec; + stateRoot: scale_ts.Codec; + extrinsicRoot: scale_ts.Codec; + digests: [scale_ts.Encoder; + consensus: { + engine: string; + payload: HexString; + }; + seal: { + engine: string; + payload: HexString; + }; + preRuntime: { + engine: string; + payload: HexString; + }; + runtimeUpdated: undefined; + }>[]>, scale_ts.Decoder; + consensus: { + engine: string; + payload: HexString; + }; + seal: { + engine: string; + payload: HexString; + }; + preRuntime: { + engine: string; + payload: HexString; + }; + runtimeUpdated: undefined; + }>[]>] & { + enc: scale_ts.Encoder; + consensus: { + engine: string; + payload: HexString; + }; + seal: { + engine: string; + payload: HexString; + }; + preRuntime: { + engine: string; + payload: HexString; + }; + runtimeUpdated: undefined; + }>[]>; + dec: scale_ts.Decoder; + consensus: { + engine: string; + payload: HexString; + }; + seal: { + engine: string; + payload: HexString; + }; + preRuntime: { + engine: string; + payload: HexString; + }; + runtimeUpdated: undefined; + }>[]>; + } & { + inner: scale_ts.Codec; + consensus: { + engine: string; + payload: HexString; + }; + seal: { + engine: string; + payload: HexString; + }; + preRuntime: { + engine: string; + payload: HexString; + }; + runtimeUpdated: undefined; + }>>; + }; + }; +}; +type BlockHeader = CodecType; + +declare const metadata: Codec<{ + magicNumber: number; + metadata: { + tag: "v0"; + value: unknown; + } | { + tag: "v1"; + value: unknown; + } | { + tag: "v2"; + value: unknown; + } | { + tag: "v3"; + value: unknown; + } | { + tag: "v4"; + value: unknown; + } | { + tag: "v5"; + value: unknown; + } | { + tag: "v6"; + value: unknown; + } | { + tag: "v7"; + value: unknown; + } | { + tag: "v8"; + value: unknown; + } | { + tag: "v9"; + value: unknown; + } | { + tag: "v10"; + value: unknown; + } | { + tag: "v11"; + value: unknown; + } | { + tag: "v12"; + value: unknown; + } | { + tag: "v13"; + value: unknown; + } | { + tag: "v14"; + value: { + lookup: { + id: number; + path: string[]; + params: { + name: string; + type: number | undefined; + }[]; + def: { + tag: "composite"; + value: { + name: string | undefined; + type: number; + typeName: string | undefined; + docs: string[]; + }[]; + } | { + tag: "variant"; + value: { + name: string; + fields: { + name: string | undefined; + type: number; + typeName: string | undefined; + docs: string[]; + }[]; + index: number; + docs: string[]; + }[]; + } | { + tag: "sequence"; + value: number; + } | { + tag: "array"; + value: { + len: number; + type: number; + }; + } | { + tag: "tuple"; + value: number[]; + } | { + tag: "primitive"; + value: { + tag: "bool"; + value: undefined; + } | { + tag: "char"; + value: undefined; + } | { + tag: "str"; + value: undefined; + } | { + tag: "u8"; + value: undefined; + } | { + tag: "u16"; + value: undefined; + } | { + tag: "u32"; + value: undefined; + } | { + tag: "u64"; + value: undefined; + } | { + tag: "u128"; + value: undefined; + } | { + tag: "u256"; + value: undefined; + } | { + tag: "i8"; + value: undefined; + } | { + tag: "i16"; + value: undefined; + } | { + tag: "i32"; + value: undefined; + } | { + tag: "i64"; + value: undefined; + } | { + tag: "i128"; + value: undefined; + } | { + tag: "i256"; + value: undefined; + }; + } | { + tag: "compact"; + value: number; + } | { + tag: "bitSequence"; + value: { + bitStoreType: number; + bitOrderType: number; + }; + }; + docs: string[]; + }[]; + pallets: { + docs: string[]; + name: string; + storage: { + prefix: string; + items: { + name: string; + modifier: number; + type: { + tag: "map"; + value: { + hashers: ({ + tag: "Blake2128"; + value: undefined; + } | { + tag: "Blake2256"; + value: undefined; + } | { + tag: "Blake2128Concat"; + value: undefined; + } | { + tag: "Twox128"; + value: undefined; + } | { + tag: "Twox256"; + value: undefined; + } | { + tag: "Twox64Concat"; + value: undefined; + } | { + tag: "Identity"; + value: undefined; + })[]; + key: number; + value: number; + }; + } | { + tag: "plain"; + value: number; + }; + fallback: HexString; + docs: string[]; + }[]; + } | undefined; + calls: number | undefined; + events: number | undefined; + constants: { + name: string; + type: number; + value: HexString; + docs: string[]; + }[]; + errors: number | undefined; + index: number; + }[]; + extrinsic: { + type: number; + version: number; + signedExtensions: { + identifier: string; + type: number; + additionalSigned: number; + }[]; + }; + type: number; + apis: { + name: string; + methods: { + deprecationInfo: { + tag: "NotDeprecated"; + value: undefined; + } | { + tag: "DeprecatedWithoutNote"; + value: undefined; + } | { + tag: "Deprecated"; + value: { + note: string; + since: string | undefined; + }; + }; + name: string; + inputs: { + name: string; + type: number; + }[]; + output: number; + docs: string[]; + }[]; + docs: string[]; + version: number; + deprecationInfo: { + tag: "NotDeprecated"; + value: undefined; + } | { + tag: "DeprecatedWithoutNote"; + value: undefined; + } | { + tag: "Deprecated"; + value: { + note: string; + since: string | undefined; + }; + }; + }[]; + }; + } | { + tag: "v15"; + value: { + lookup: { + id: number; + path: string[]; + params: { + name: string; + type: number | undefined; + }[]; + def: { + tag: "composite"; + value: { + name: string | undefined; + type: number; + typeName: string | undefined; + docs: string[]; + }[]; + } | { + tag: "variant"; + value: { + name: string; + fields: { + name: string | undefined; + type: number; + typeName: string | undefined; + docs: string[]; + }[]; + index: number; + docs: string[]; + }[]; + } | { + tag: "sequence"; + value: number; + } | { + tag: "array"; + value: { + len: number; + type: number; + }; + } | { + tag: "tuple"; + value: number[]; + } | { + tag: "primitive"; + value: { + tag: "bool"; + value: undefined; + } | { + tag: "char"; + value: undefined; + } | { + tag: "str"; + value: undefined; + } | { + tag: "u8"; + value: undefined; + } | { + tag: "u16"; + value: undefined; + } | { + tag: "u32"; + value: undefined; + } | { + tag: "u64"; + value: undefined; + } | { + tag: "u128"; + value: undefined; + } | { + tag: "u256"; + value: undefined; + } | { + tag: "i8"; + value: undefined; + } | { + tag: "i16"; + value: undefined; + } | { + tag: "i32"; + value: undefined; + } | { + tag: "i64"; + value: undefined; + } | { + tag: "i128"; + value: undefined; + } | { + tag: "i256"; + value: undefined; + }; + } | { + tag: "compact"; + value: number; + } | { + tag: "bitSequence"; + value: { + bitStoreType: number; + bitOrderType: number; + }; + }; + docs: string[]; + }[]; + pallets: { + docs: string[]; + name: string; + storage: { + prefix: string; + items: { + name: string; + modifier: number; + type: { + tag: "map"; + value: { + hashers: ({ + tag: "Blake2128"; + value: undefined; + } | { + tag: "Blake2256"; + value: undefined; + } | { + tag: "Blake2128Concat"; + value: undefined; + } | { + tag: "Twox128"; + value: undefined; + } | { + tag: "Twox256"; + value: undefined; + } | { + tag: "Twox64Concat"; + value: undefined; + } | { + tag: "Identity"; + value: undefined; + })[]; + key: number; + value: number; + }; + } | { + tag: "plain"; + value: number; + }; + fallback: HexString; + docs: string[]; + }[]; + } | undefined; + calls: number | undefined; + events: number | undefined; + constants: { + name: string; + type: number; + value: HexString; + docs: string[]; + }[]; + errors: number | undefined; + index: number; + }[]; + extrinsic: { + version: number; + address: number; + call: number; + signature: number; + extra: number; + signedExtensions: { + identifier: string; + type: number; + additionalSigned: number; + }[]; + }; + type: number; + apis: { + name: string; + methods: { + name: string; + inputs: { + name: string; + type: number; + }[]; + output: number; + docs: string[]; + }[]; + docs: string[]; + }[]; + outerEnums: { + call: number; + event: number; + error: number; + }; + custom: [string, { + type: number; + value: HexString; + }][]; + }; + } | { + tag: "v16"; + value: { + lookup: { + id: number; + path: string[]; + params: { + name: string; + type: number | undefined; + }[]; + def: { + tag: "composite"; + value: { + name: string | undefined; + type: number; + typeName: string | undefined; + docs: string[]; + }[]; + } | { + tag: "variant"; + value: { + name: string; + fields: { + name: string | undefined; + type: number; + typeName: string | undefined; + docs: string[]; + }[]; + index: number; + docs: string[]; + }[]; + } | { + tag: "sequence"; + value: number; + } | { + tag: "array"; + value: { + len: number; + type: number; + }; + } | { + tag: "tuple"; + value: number[]; + } | { + tag: "primitive"; + value: { + tag: "bool"; + value: undefined; + } | { + tag: "char"; + value: undefined; + } | { + tag: "str"; + value: undefined; + } | { + tag: "u8"; + value: undefined; + } | { + tag: "u16"; + value: undefined; + } | { + tag: "u32"; + value: undefined; + } | { + tag: "u64"; + value: undefined; + } | { + tag: "u128"; + value: undefined; + } | { + tag: "u256"; + value: undefined; + } | { + tag: "i8"; + value: undefined; + } | { + tag: "i16"; + value: undefined; + } | { + tag: "i32"; + value: undefined; + } | { + tag: "i64"; + value: undefined; + } | { + tag: "i128"; + value: undefined; + } | { + tag: "i256"; + value: undefined; + }; + } | { + tag: "compact"; + value: number; + } | { + tag: "bitSequence"; + value: { + bitStoreType: number; + bitOrderType: number; + }; + }; + docs: string[]; + }[]; + pallets: { + name: string; + storage: { + prefix: string; + items: { + deprecationInfo: { + tag: "NotDeprecated"; + value: undefined; + } | { + tag: "DeprecatedWithoutNote"; + value: undefined; + } | { + tag: "Deprecated"; + value: { + note: string; + since: string | undefined; + }; + }; + name: string; + modifier: number; + type: { + tag: "map"; + value: { + hashers: ({ + tag: "Blake2128"; + value: undefined; + } | { + tag: "Blake2256"; + value: undefined; + } | { + tag: "Blake2128Concat"; + value: undefined; + } | { + tag: "Twox128"; + value: undefined; + } | { + tag: "Twox256"; + value: undefined; + } | { + tag: "Twox64Concat"; + value: undefined; + } | { + tag: "Identity"; + value: undefined; + })[]; + key: number; + value: number; + }; + } | { + tag: "plain"; + value: number; + }; + fallback: HexString; + docs: string[]; + }[]; + } | undefined; + calls: { + type: number; + deprecationInfo: { + index: number; + deprecation: { + tag: "DeprecatedWithoutNote"; + value: undefined; + } | { + tag: "Deprecated"; + value: { + note: string; + since: string | undefined; + }; + }; + }[]; + } | undefined; + events: { + type: number; + deprecationInfo: { + index: number; + deprecation: { + tag: "DeprecatedWithoutNote"; + value: undefined; + } | { + tag: "Deprecated"; + value: { + note: string; + since: string | undefined; + }; + }; + }[]; + } | undefined; + constants: { + name: string; + type: number; + value: HexString; + docs: string[]; + deprecationInfo: { + tag: "NotDeprecated"; + value: undefined; + } | { + tag: "DeprecatedWithoutNote"; + value: undefined; + } | { + tag: "Deprecated"; + value: { + note: string; + since: string | undefined; + }; + }; + }[]; + errors: { + type: number; + deprecationInfo: { + index: number; + deprecation: { + tag: "DeprecatedWithoutNote"; + value: undefined; + } | { + tag: "Deprecated"; + value: { + note: string; + since: string | undefined; + }; + }; + }[]; + } | undefined; + associatedTypes: { + name: string; + type: number; + docs: string[]; + }[]; + viewFns: { + deprecationInfo: { + tag: "NotDeprecated"; + value: undefined; + } | { + tag: "DeprecatedWithoutNote"; + value: undefined; + } | { + tag: "Deprecated"; + value: { + note: string; + since: string | undefined; + }; + }; + name: string; + inputs: { + name: string; + type: number; + }[]; + output: number; + docs: string[]; + id: HexString; + }[]; + index: number; + docs: string[]; + deprecationInfo: { + tag: "NotDeprecated"; + value: undefined; + } | { + tag: "DeprecatedWithoutNote"; + value: undefined; + } | { + tag: "Deprecated"; + value: { + note: string; + since: string | undefined; + }; + }; + }[]; + extrinsic: { + version: number[]; + address: number; + call: number; + signature: number; + signedExtensionsByVersion: [number, number[]][]; + signedExtensions: { + identifier: string; + type: number; + additionalSigned: number; + }[]; + }; + apis: { + name: string; + methods: { + deprecationInfo: { + tag: "NotDeprecated"; + value: undefined; + } | { + tag: "DeprecatedWithoutNote"; + value: undefined; + } | { + tag: "Deprecated"; + value: { + note: string; + since: string | undefined; + }; + }; + name: string; + inputs: { + name: string; + type: number; + }[]; + output: number; + docs: string[]; + }[]; + docs: string[]; + version: number; + deprecationInfo: { + tag: "NotDeprecated"; + value: undefined; + } | { + tag: "DeprecatedWithoutNote"; + value: undefined; + } | { + tag: "Deprecated"; + value: { + note: string; + since: string | undefined; + }; + }; + }[]; + outerEnums: { + call: number; + event: number; + error: number; + }; + custom: [string, { + type: number; + value: HexString; + }][]; + }; + }; +}>; +type Metadata = CodecType; +declare const decAnyMetadata: (input: Uint8Array | HexString) => CodecType; + +declare const v14: scale_ts.Codec<{ + lookup: { + id: number; + path: string[]; + params: { + name: string; + type: number | undefined; + }[]; + def: { + tag: "composite"; + value: { + name: string | undefined; + type: number; + typeName: string | undefined; + docs: string[]; + }[]; + } | { + tag: "variant"; + value: { + name: string; + fields: { + name: string | undefined; + type: number; + typeName: string | undefined; + docs: string[]; + }[]; + index: number; + docs: string[]; + }[]; + } | { + tag: "sequence"; + value: number; + } | { + tag: "array"; + value: { + len: number; + type: number; + }; + } | { + tag: "tuple"; + value: number[]; + } | { + tag: "primitive"; + value: { + tag: "bool"; + value: undefined; + } | { + tag: "char"; + value: undefined; + } | { + tag: "str"; + value: undefined; + } | { + tag: "u8"; + value: undefined; + } | { + tag: "u16"; + value: undefined; + } | { + tag: "u32"; + value: undefined; + } | { + tag: "u64"; + value: undefined; + } | { + tag: "u128"; + value: undefined; + } | { + tag: "u256"; + value: undefined; + } | { + tag: "i8"; + value: undefined; + } | { + tag: "i16"; + value: undefined; + } | { + tag: "i32"; + value: undefined; + } | { + tag: "i64"; + value: undefined; + } | { + tag: "i128"; + value: undefined; + } | { + tag: "i256"; + value: undefined; + }; + } | { + tag: "compact"; + value: number; + } | { + tag: "bitSequence"; + value: { + bitStoreType: number; + bitOrderType: number; + }; + }; + docs: string[]; + }[]; + pallets: { + docs: string[]; + name: string; + storage: { + prefix: string; + items: { + name: string; + modifier: number; + type: { + tag: "map"; + value: { + hashers: ({ + tag: "Blake2128"; + value: undefined; + } | { + tag: "Blake2256"; + value: undefined; + } | { + tag: "Blake2128Concat"; + value: undefined; + } | { + tag: "Twox128"; + value: undefined; + } | { + tag: "Twox256"; + value: undefined; + } | { + tag: "Twox64Concat"; + value: undefined; + } | { + tag: "Identity"; + value: undefined; + })[]; + key: number; + value: number; + }; + } | { + tag: "plain"; + value: number; + }; + fallback: HexString; + docs: string[]; + }[]; + } | undefined; + calls: number | undefined; + events: number | undefined; + constants: { + name: string; + type: number; + value: HexString; + docs: string[]; + }[]; + errors: number | undefined; + index: number; + }[]; + extrinsic: { + type: number; + version: number; + signedExtensions: { + identifier: string; + type: number; + additionalSigned: number; + }[]; + }; + type: number; + apis: { + name: string; + methods: { + deprecationInfo: { + tag: "NotDeprecated"; + value: undefined; + } | { + tag: "DeprecatedWithoutNote"; + value: undefined; + } | { + tag: "Deprecated"; + value: { + note: string; + since: string | undefined; + }; + }; + name: string; + inputs: { + name: string; + type: number; + }[]; + output: number; + docs: string[]; + }[]; + docs: string[]; + version: number; + deprecationInfo: { + tag: "NotDeprecated"; + value: undefined; + } | { + tag: "DeprecatedWithoutNote"; + value: undefined; + } | { + tag: "Deprecated"; + value: { + note: string; + since: string | undefined; + }; + }; + }[]; +}>; +type V14 = CodecType; + +declare const v15: scale_ts.Codec<{ + lookup: { + id: number; + path: string[]; + params: { + name: string; + type: number | undefined; + }[]; + def: { + tag: "composite"; + value: { + name: string | undefined; + type: number; + typeName: string | undefined; + docs: string[]; + }[]; + } | { + tag: "variant"; + value: { + name: string; + fields: { + name: string | undefined; + type: number; + typeName: string | undefined; + docs: string[]; + }[]; + index: number; + docs: string[]; + }[]; + } | { + tag: "sequence"; + value: number; + } | { + tag: "array"; + value: { + len: number; + type: number; + }; + } | { + tag: "tuple"; + value: number[]; + } | { + tag: "primitive"; + value: { + tag: "bool"; + value: undefined; + } | { + tag: "char"; + value: undefined; + } | { + tag: "str"; + value: undefined; + } | { + tag: "u8"; + value: undefined; + } | { + tag: "u16"; + value: undefined; + } | { + tag: "u32"; + value: undefined; + } | { + tag: "u64"; + value: undefined; + } | { + tag: "u128"; + value: undefined; + } | { + tag: "u256"; + value: undefined; + } | { + tag: "i8"; + value: undefined; + } | { + tag: "i16"; + value: undefined; + } | { + tag: "i32"; + value: undefined; + } | { + tag: "i64"; + value: undefined; + } | { + tag: "i128"; + value: undefined; + } | { + tag: "i256"; + value: undefined; + }; + } | { + tag: "compact"; + value: number; + } | { + tag: "bitSequence"; + value: { + bitStoreType: number; + bitOrderType: number; + }; + }; + docs: string[]; + }[]; + pallets: { + docs: string[]; + name: string; + storage: { + prefix: string; + items: { + name: string; + modifier: number; + type: { + tag: "map"; + value: { + hashers: ({ + tag: "Blake2128"; + value: undefined; + } | { + tag: "Blake2256"; + value: undefined; + } | { + tag: "Blake2128Concat"; + value: undefined; + } | { + tag: "Twox128"; + value: undefined; + } | { + tag: "Twox256"; + value: undefined; + } | { + tag: "Twox64Concat"; + value: undefined; + } | { + tag: "Identity"; + value: undefined; + })[]; + key: number; + value: number; + }; + } | { + tag: "plain"; + value: number; + }; + fallback: HexString; + docs: string[]; + }[]; + } | undefined; + calls: number | undefined; + events: number | undefined; + constants: { + name: string; + type: number; + value: HexString; + docs: string[]; + }[]; + errors: number | undefined; + index: number; + }[]; + extrinsic: { + version: number; + address: number; + call: number; + signature: number; + extra: number; + signedExtensions: { + identifier: string; + type: number; + additionalSigned: number; + }[]; + }; + type: number; + apis: { + name: string; + methods: { + name: string; + inputs: { + name: string; + type: number; + }[]; + output: number; + docs: string[]; + }[]; + docs: string[]; + }[]; + outerEnums: { + call: number; + event: number; + error: number; + }; + custom: [string, { + type: number; + value: HexString; + }][]; +}>; +type V15 = CodecType; + +declare const v16: scale_ts.Codec<{ + lookup: { + id: number; + path: string[]; + params: { + name: string; + type: number | undefined; + }[]; + def: { + tag: "composite"; + value: { + name: string | undefined; + type: number; + typeName: string | undefined; + docs: string[]; + }[]; + } | { + tag: "variant"; + value: { + name: string; + fields: { + name: string | undefined; + type: number; + typeName: string | undefined; + docs: string[]; + }[]; + index: number; + docs: string[]; + }[]; + } | { + tag: "sequence"; + value: number; + } | { + tag: "array"; + value: { + len: number; + type: number; + }; + } | { + tag: "tuple"; + value: number[]; + } | { + tag: "primitive"; + value: { + tag: "bool"; + value: undefined; + } | { + tag: "char"; + value: undefined; + } | { + tag: "str"; + value: undefined; + } | { + tag: "u8"; + value: undefined; + } | { + tag: "u16"; + value: undefined; + } | { + tag: "u32"; + value: undefined; + } | { + tag: "u64"; + value: undefined; + } | { + tag: "u128"; + value: undefined; + } | { + tag: "u256"; + value: undefined; + } | { + tag: "i8"; + value: undefined; + } | { + tag: "i16"; + value: undefined; + } | { + tag: "i32"; + value: undefined; + } | { + tag: "i64"; + value: undefined; + } | { + tag: "i128"; + value: undefined; + } | { + tag: "i256"; + value: undefined; + }; + } | { + tag: "compact"; + value: number; + } | { + tag: "bitSequence"; + value: { + bitStoreType: number; + bitOrderType: number; + }; + }; + docs: string[]; + }[]; + pallets: { + name: string; + storage: { + prefix: string; + items: { + deprecationInfo: { + tag: "NotDeprecated"; + value: undefined; + } | { + tag: "DeprecatedWithoutNote"; + value: undefined; + } | { + tag: "Deprecated"; + value: { + note: string; + since: string | undefined; + }; + }; + name: string; + modifier: number; + type: { + tag: "map"; + value: { + hashers: ({ + tag: "Blake2128"; + value: undefined; + } | { + tag: "Blake2256"; + value: undefined; + } | { + tag: "Blake2128Concat"; + value: undefined; + } | { + tag: "Twox128"; + value: undefined; + } | { + tag: "Twox256"; + value: undefined; + } | { + tag: "Twox64Concat"; + value: undefined; + } | { + tag: "Identity"; + value: undefined; + })[]; + key: number; + value: number; + }; + } | { + tag: "plain"; + value: number; + }; + fallback: HexString; + docs: string[]; + }[]; + } | undefined; + calls: { + type: number; + deprecationInfo: { + index: number; + deprecation: { + tag: "DeprecatedWithoutNote"; + value: undefined; + } | { + tag: "Deprecated"; + value: { + note: string; + since: string | undefined; + }; + }; + }[]; + } | undefined; + events: { + type: number; + deprecationInfo: { + index: number; + deprecation: { + tag: "DeprecatedWithoutNote"; + value: undefined; + } | { + tag: "Deprecated"; + value: { + note: string; + since: string | undefined; + }; + }; + }[]; + } | undefined; + constants: { + name: string; + type: number; + value: HexString; + docs: string[]; + deprecationInfo: { + tag: "NotDeprecated"; + value: undefined; + } | { + tag: "DeprecatedWithoutNote"; + value: undefined; + } | { + tag: "Deprecated"; + value: { + note: string; + since: string | undefined; + }; + }; + }[]; + errors: { + type: number; + deprecationInfo: { + index: number; + deprecation: { + tag: "DeprecatedWithoutNote"; + value: undefined; + } | { + tag: "Deprecated"; + value: { + note: string; + since: string | undefined; + }; + }; + }[]; + } | undefined; + associatedTypes: { + name: string; + type: number; + docs: string[]; + }[]; + viewFns: { + deprecationInfo: { + tag: "NotDeprecated"; + value: undefined; + } | { + tag: "DeprecatedWithoutNote"; + value: undefined; + } | { + tag: "Deprecated"; + value: { + note: string; + since: string | undefined; + }; + }; + name: string; + inputs: { + name: string; + type: number; + }[]; + output: number; + docs: string[]; + id: HexString; + }[]; + index: number; + docs: string[]; + deprecationInfo: { + tag: "NotDeprecated"; + value: undefined; + } | { + tag: "DeprecatedWithoutNote"; + value: undefined; + } | { + tag: "Deprecated"; + value: { + note: string; + since: string | undefined; + }; + }; + }[]; + extrinsic: { + version: number[]; + address: number; + call: number; + signature: number; + signedExtensionsByVersion: [number, number[]][]; + signedExtensions: { + identifier: string; + type: number; + additionalSigned: number; + }[]; + }; + apis: { + name: string; + methods: { + deprecationInfo: { + tag: "NotDeprecated"; + value: undefined; + } | { + tag: "DeprecatedWithoutNote"; + value: undefined; + } | { + tag: "Deprecated"; + value: { + note: string; + since: string | undefined; + }; + }; + name: string; + inputs: { + name: string; + type: number; + }[]; + output: number; + docs: string[]; + }[]; + docs: string[]; + version: number; + deprecationInfo: { + tag: "NotDeprecated"; + value: undefined; + } | { + tag: "DeprecatedWithoutNote"; + value: undefined; + } | { + tag: "Deprecated"; + value: { + note: string; + since: string | undefined; + }; + }; + }[]; + outerEnums: { + call: number; + event: number; + error: number; + }; + custom: [string, { + type: number; + value: HexString; + }][]; +}>; +type V16 = CodecType; + +declare const lookup: scale_ts.Codec<{ + id: number; + path: string[]; + params: { + name: string; + type: number | undefined; + }[]; + def: { + tag: "composite"; + value: { + name: string | undefined; + type: number; + typeName: string | undefined; + docs: string[]; + }[]; + } | { + tag: "variant"; + value: { + name: string; + fields: { + name: string | undefined; + type: number; + typeName: string | undefined; + docs: string[]; + }[]; + index: number; + docs: string[]; + }[]; + } | { + tag: "sequence"; + value: number; + } | { + tag: "array"; + value: { + len: number; + type: number; + }; + } | { + tag: "tuple"; + value: number[]; + } | { + tag: "primitive"; + value: { + tag: "bool"; + value: undefined; + } | { + tag: "char"; + value: undefined; + } | { + tag: "str"; + value: undefined; + } | { + tag: "u8"; + value: undefined; + } | { + tag: "u16"; + value: undefined; + } | { + tag: "u32"; + value: undefined; + } | { + tag: "u64"; + value: undefined; + } | { + tag: "u128"; + value: undefined; + } | { + tag: "u256"; + value: undefined; + } | { + tag: "i8"; + value: undefined; + } | { + tag: "i16"; + value: undefined; + } | { + tag: "i32"; + value: undefined; + } | { + tag: "i64"; + value: undefined; + } | { + tag: "i128"; + value: undefined; + } | { + tag: "i256"; + value: undefined; + }; + } | { + tag: "compact"; + value: number; + } | { + tag: "bitSequence"; + value: { + bitStoreType: number; + bitOrderType: number; + }; + }; + docs: string[]; +}[]>; +type V14Lookup = CodecType; + +declare const storageMap: scale_ts.Codec<{ + hashers: ({ + tag: "Blake2128"; + value: undefined; + } | { + tag: "Blake2256"; + value: undefined; + } | { + tag: "Blake2128Concat"; + value: undefined; + } | { + tag: "Twox128"; + value: undefined; + } | { + tag: "Twox256"; + value: undefined; + } | { + tag: "Twox64Concat"; + value: undefined; + } | { + tag: "Identity"; + value: undefined; + })[]; + key: number; + value: number; +}>; + +declare const itemDeprecation: scale_ts.Codec<{ + tag: "NotDeprecated"; + value: undefined; +} | { + tag: "DeprecatedWithoutNote"; + value: undefined; +} | { + tag: "Deprecated"; + value: { + note: string; + since: string | undefined; + }; +}>; +declare const variantDeprecation: scale_ts.Codec<{ + index: number; + deprecation: { + tag: "DeprecatedWithoutNote"; + value: undefined; + } | { + tag: "Deprecated"; + value: { + note: string; + since: string | undefined; + }; + }; +}[]>; + +declare const viewFunction: scale_ts.Codec<{ + deprecationInfo: { + tag: "NotDeprecated"; + value: undefined; + } | { + tag: "DeprecatedWithoutNote"; + value: undefined; + } | { + tag: "Deprecated"; + value: { + note: string; + since: string | undefined; + }; + }; + name: string; + inputs: { + name: string; + type: number; + }[]; + output: number; + docs: string[]; + id: HexString; +}>; + +type EnumRef = ({ + type: number; +} & (T extends 16 ? { + deprecationInfo: CodecType; +} : {})) | undefined; +type DeprecationInfo = T extends 16 ? { + deprecationInfo: CodecType; +} : {}; +type UnifiedMetadata = { + version: T; + lookup: V14Lookup; + pallets: Array<{ + name: string; + storage: { + prefix: string; + items: Array<{ + name: string; + modifier: number; + type: { + tag: "plain"; + value: number; + } | { + tag: "map"; + value: CodecType; + }; + fallback: HexString; + docs: string[]; + } & DeprecationInfo>; + } | undefined; + calls: EnumRef; + events: EnumRef; + constants: Array<{ + name: string; + type: number; + value: HexString; + docs: string[]; + } & DeprecationInfo>; + errors: EnumRef; + associatedTypes: Array<{ + name: string; + type: number; + docs: string[]; + }>; + viewFns: Array>; + index: number; + docs: string[]; + } & DeprecationInfo>; + extrinsic: { + version: number[]; + signedExtensions: Array<{ + identifier: string; + type: number; + additionalSigned: number; + }>; + } & (T extends 14 ? { + type: number; + } : { + address: number; + call: number; + signature: number; + }) & (T extends 16 ? { + signedExtensionsByVersion: Array<[number, number[]]>; + } : {}); + apis: Array<{ + name: string; + methods: Array<{ + name: string; + inputs: Array<{ + name: string; + type: number; + }>; + output: number; + docs: string[]; + } & DeprecationInfo>; + docs: string[]; + } & (T extends 16 ? { + version: number; + } : {}) & DeprecationInfo>; +} & (T extends 14 ? {} : { + outerEnums: { + call: number; + event: number; + error: number; + }; + custom: Array<[string, { + type: number; + value: HexString; + }]>; +}); +declare const unifyMetadata: (metadata: Metadata | Metadata["metadata"] | V14 | V15 | V16) => UnifiedMetadata; + +type ExtrinsicFormat = { + version: 4; + type: "bare" | "signed"; +} | { + version: 5; + type: "bare" | "general"; +}; +declare const extrinsicFormat: scale_ts.Codec; + +declare const Blake2256: (encoded: Uint8Array) => Uint8Array; +declare const Blake2128: (encoded: Uint8Array) => Uint8Array; +declare const Blake2128Concat: (encoded: Uint8Array) => Uint8Array; + +declare const Blake3256: (encoded: Uint8Array) => Uint8Array; +declare const Blake3256Concat: (encoded: Uint8Array) => Uint8Array; + +declare const Identity: (encoded: Uint8Array) => Uint8Array; + +declare const Twox128: (input: Uint8Array) => Uint8Array; +declare const Twox256: (input: Uint8Array) => Uint8Array; +declare const Twox64Concat: (encoded: Uint8Array) => Uint8Array; + +declare function h64(input: Uint8Array, seed?: bigint): bigint; + +declare const Keccak256: (input: Uint8Array) => Uint8Array; + +type EncoderWithHash = [Codec, (input: Uint8Array) => Uint8Array]; +type OpaqueKeyHash = string & { + __opaqueKeyHash?: unknown; +}; +declare const Storage: (pallet: string) => >>(name: string, ...encoders: [...A]) => { + enc: (...args: { [K in keyof A]: A[K] extends EncoderWithHash ? V : unknown; }) => string; + dec: (value: string) => { [K in keyof A]: A[K] extends EncoderWithHash ? V : unknown; }; +}; + +declare const TrieNodeHeaders: { + readonly Leaf: "Leaf"; + readonly Branch: "Branch"; + readonly BranchWithVal: "BranchWithVal"; + readonly LeafWithHash: "LeafWithHash"; + readonly BranchWithHash: "BranchWithHash"; + readonly Empty: "Empty"; + readonly Reserved: "Reserved"; +}; +type TrieNodeHeaders = typeof TrieNodeHeaders; +type TrieNodeHeaderKey = (typeof TrieNodeHeaders)[keyof typeof TrieNodeHeaders]; +type Nibble = "0" | "1" | "2" | "3" | "4" | "5" | "6" | "7" | "8" | "9" | "a" | "b" | "c" | "d" | "e" | "f"; +type TrieNode = { + partialKey: string; +} & ({ + type: TrieNodeHeaders["Empty"] | TrieNodeHeaders["Reserved"]; +} | { + type: TrieNodeHeaders["Leaf"] | TrieNodeHeaders["LeafWithHash"]; + value: HexString; +} | ({ + children: Record; +} & ({ + type: TrieNodeHeaders["Branch"]; +} | { + type: TrieNodeHeaders["BranchWithHash"] | TrieNodeHeaders["BranchWithVal"]; + value: HexString; +}))); +type ProofTrieNode = { + hash: HexString; + parent?: HexString; +} & (TrieNode | { + type: "Raw"; + value: HexString; +}); + +declare const trieNodeDec: scale_ts.Decoder; + +declare const TrieNodeWithHash: (hasher: (input: Uint8Array) => Uint8Array) => scale_ts.Decoder; +declare const validateProofs: (proofs: Array, hasher?: (input: Uint8Array) => Uint8Array) => { + rootHash: HexString; + proofs: Record; +} | null; + +export { AccountId, Bin, Binary, BitSeq, Blake2128, Blake2128Concat, Blake2256, Blake3256, Blake3256Concat, Enum, FixedSizeBinary, Hex, Identity, Keccak256, Option, Result, ScaleEnum, Self, Storage, Struct, TrieNodeHeaders, TrieNodeWithHash, Tuple, Twox128, Twox256, Twox64Concat, Variant, Vector, _Enum, bitSequence, blockHeader, char, compactBn, compactNumber, decAnyMetadata, ethAccount, extrinsicFormat, fixedStr, fromBufferToBase58, getMultisigAccountId, getSs58AddressInfo, h64, metadata, selfDecoder, selfEncoder, sortMultisigSignatories, trieNodeDec, unifyMetadata, v14, lookup as v14Lookup, v15, v16, validateProofs }; +export type { BitSequence, BlockHeader, EncoderWithHash, EnumVariant, ExtractEnumValue, ExtrinsicFormat, GetEnum, HexString, Metadata, Nibble, OpaqueKeyHash, ProofTrieNode, SS58AddressInfo, SS58String, TrieNode, TrieNodeHeaderKey, UnifiedMetadata, V14, V14Lookup, V15, V16 }; diff --git a/packages/bizinikiwi-bindings/dist/index.js b/packages/bizinikiwi-bindings/dist/index.js new file mode 100644 index 0000000..98af47d --- /dev/null +++ b/packages/bizinikiwi-bindings/dist/index.js @@ -0,0 +1,1327 @@ +'use strict'; + +var scaleTs = require('scale-ts'); +var base = require('@scure/base'); +var blake2_js = require('@noble/hashes/blake2.js'); +var utils = require('@pezkuwi/papi-utils'); +var blake3_js = require('@noble/hashes/blake3.js'); +var sha3_js = require('@noble/hashes/sha3.js'); + +const SS58_PREFIX = new TextEncoder().encode("SS58PRE"); +const CHECKSUM_LENGTH = 2; +const getSs58AddressInfo = (address) => { + try { + const decoded = base.base58.decode(address); + const prefixBytes = decoded.subarray(0, decoded[0] & 64 ? 2 : 1); + const publicKey = decoded.subarray( + prefixBytes.length, + decoded.length - CHECKSUM_LENGTH + ); + const checksum = decoded.subarray(prefixBytes.length + publicKey.length); + const expectedChecksum = blake2_js.blake2b( + Uint8Array.of(...SS58_PREFIX, ...prefixBytes, ...publicKey), + { + dkLen: 64 + } + ).subarray(0, CHECKSUM_LENGTH); + const isChecksumValid = checksum[0] === expectedChecksum[0] && checksum[1] === expectedChecksum[1]; + if (!isChecksumValid) return { isValid: false }; + return { + isValid: true, + ss58Format: prefixBytesToNumber(prefixBytes), + publicKey: publicKey.slice() + }; + } catch (_) { + return { isValid: false }; + } +}; +const prefixBytesToNumber = (bytes) => { + const dv = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength); + return dv.byteLength === 1 ? dv.getUint8(0) : dv.getUint16(0); +}; +const withSs58Cache = (fn) => { + let cache = {}; + let activityCount = 0; + let latestCount = 0; + const checkActivity = () => { + if (activityCount === latestCount) { + cache = {}; + activityCount = latestCount = 0; + } else { + latestCount = activityCount; + setTimeout(checkActivity, 0); + } + }; + return (publicKey) => { + var _a, _b; + if (++activityCount === 1) checkActivity(); + let entry = cache; + const lastIdx = publicKey.length - 1; + for (let i = 0; i <= lastIdx; i++) entry = entry[_a = publicKey[i]] || (entry[_a] = {}); + return entry[_b = publicKey[lastIdx]] || (entry[_b] = fn(publicKey)); + }; +}; +const fromBufferToBase58 = (ss58Format) => { + const prefixBytes = ss58Format < 64 ? Uint8Array.of(ss58Format) : Uint8Array.of( + (ss58Format & 252) >> 2 | 64, + ss58Format >> 8 | (ss58Format & 3) << 6 + ); + return withSs58Cache((publicKey) => { + const checksum = blake2_js.blake2b( + Uint8Array.of(...SS58_PREFIX, ...prefixBytes, ...publicKey), + { + dkLen: 64 + } + ).subarray(0, CHECKSUM_LENGTH); + return base.base58.encode( + Uint8Array.of(...prefixBytes, ...publicKey, ...checksum) + ); + }); +}; + +function fromBase58ToBuffer(nBytes, _ss58Format) { + return (address) => { + const info = getSs58AddressInfo(address); + if (!info.isValid) throw new Error("Invalid checksum"); + const { publicKey } = info; + if (publicKey.length !== nBytes) + throw new Error("Invalid public key length"); + return publicKey; + }; +} +const AccountId = (ss58Format = 42, nBytes = 32) => scaleTs.enhanceCodec( + scaleTs.Bytes(nBytes), + fromBase58ToBuffer(nBytes), + fromBufferToBase58(ss58Format) +); + +var __defProp = Object.defineProperty; +var __typeError = (msg) => { + throw TypeError(msg); +}; +var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value; +var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value); +var __accessCheck = (obj, member, msg) => member.has(obj) || __typeError("Cannot " + msg); +var __privateGet = (obj, member, getter) => (__accessCheck(obj, member, "read from private field"), getter ? getter.call(obj) : member.get(obj)); +var __privateAdd = (obj, member, value) => member.has(obj) ? __typeError("Cannot add the same private member more than once") : member instanceof WeakSet ? member.add(obj) : member.set(obj, value); +var __privateSet = (obj, member, value, setter) => (__accessCheck(obj, member, "write to private field"), member.set(obj, value), value); +var _bytes, _opaqueBytes, _hex, _opaqueHex, _str; +const textEncoder$3 = new TextEncoder(); +const textDecoder$2 = new TextDecoder(); +const opaqueBytesDec = scaleTs.Tuple(scaleTs.compact, scaleTs.Bytes(Infinity))[1]; +class Binary { + constructor(data, opaque = false) { + __privateAdd(this, _bytes); + __privateAdd(this, _opaqueBytes, null); + __privateAdd(this, _hex, null); + __privateAdd(this, _opaqueHex, null); + __privateAdd(this, _str, null); + __publicField(this, "asText", () => __privateGet(this, _str) ?? __privateSet(this, _str, textDecoder$2.decode(__privateGet(this, _bytes)))); + __publicField(this, "asHex", () => __privateGet(this, _hex) ?? __privateSet(this, _hex, utils.toHex(__privateGet(this, _bytes)))); + __publicField(this, "asOpaqueHex", () => __privateGet(this, _opaqueHex) ?? __privateSet(this, _opaqueHex, utils.toHex(this.asOpaqueBytes()))); + __publicField(this, "asBytes", () => __privateGet(this, _bytes)); + __publicField(this, "asOpaqueBytes", () => __privateGet(this, _opaqueBytes) ?? __privateSet(this, _opaqueBytes, utils.mergeUint8([ + scaleTs.compact[0](__privateGet(this, _bytes).length), + __privateGet(this, _bytes) + ]))); + if (opaque) { + try { + const [len, bytes] = opaqueBytesDec(data); + if (len === bytes.length) { + __privateSet(this, _bytes, bytes); + __privateSet(this, _opaqueBytes, data); + return; + } + } catch (_) { + } + throw new Error("Invalid opaque bytes"); + } else __privateSet(this, _bytes, data); + } + static fromText(input) { + return new this(textEncoder$3.encode(input)); + } + static fromHex(input) { + return new this(utils.fromHex(input)); + } + static fromOpaqueHex(input) { + return new this(utils.fromHex(input), true); + } + static fromBytes(input) { + return new this(input); + } + static fromOpaqueBytes(input) { + return new this(input, true); + } +} +_bytes = new WeakMap(); +_opaqueBytes = new WeakMap(); +_hex = new WeakMap(); +_opaqueHex = new WeakMap(); +_str = new WeakMap(); +const [accountIdEncoder] = AccountId(); +class FixedSizeBinary extends Binary { + constructor(data) { + super(data); + } + static fromArray(input) { + return new this(new Uint8Array(input)); + } + static fromAccountId32(input) { + return new this(accountIdEncoder(input)); + } +} +const enc$2 = (nBytes) => { + const _enc = scaleTs.Bytes.enc(nBytes); + return (value) => _enc(value.asBytes()); +}; +const dec$2 = (nBytes) => { + const _dec = scaleTs.Bytes.dec(nBytes); + const Bin2 = nBytes == null ? Binary : FixedSizeBinary; + return (value) => Bin2.fromBytes(_dec(value)); +}; +const Bin = (nBytes) => scaleTs.createCodec(enc$2(nBytes), dec$2(nBytes)); +Bin.enc = enc$2; +Bin.dec = dec$2; + +const compactNumber = scaleTs.enhanceCodec(scaleTs.compact, (v) => v, Number); +const compactBn = scaleTs.enhanceCodec(scaleTs.compact, (v) => v, BigInt); + +const bitSequenceDecoder = scaleTs.createDecoder((data) => { + const bitsLen = compactNumber.dec(data); + const bytesLen = Math.ceil(bitsLen / 8); + const bytes = scaleTs.Bytes(bytesLen).dec(data); + return { bytes, bitsLen }; +}); +const bitSequenceEncoder = (input) => { + if (input.bitsLen > input.bytes.length * 8) + throw new Error( + `Not enough bytes. (bitsLen:${input.bitsLen}, bytesLen:${input.bytes.length})` + ); + const lenEncoded = compactNumber.enc(input.bitsLen); + const result = new Uint8Array(input.bytes.length + lenEncoded.length); + result.set(lenEncoded, 0); + result.set(input.bytes, lenEncoded.length); + return result; +}; +const bitSequence$1 = scaleTs.createCodec(bitSequenceEncoder, bitSequenceDecoder); + +const char = scaleTs.enhanceCodec( + scaleTs.u8, + (str) => str.charCodeAt(0), + String.fromCharCode +); + +const enc$1 = (nBytes) => { + const _enc = scaleTs.Bytes.enc(nBytes); + return (value) => _enc(utils.fromHex(value)); +}; +const dec$1 = (nBytes) => { + const _dec = scaleTs.Bytes.dec(nBytes); + return (value) => utils.toHex(_dec(value)); +}; +const Hex = (nBytes) => scaleTs.createCodec(enc$1(nBytes), dec$1(nBytes)); +Hex.enc = enc$1; +Hex.dec = dec$1; + +const textEncoder$2 = new TextEncoder(); +const textDecoder$1 = new TextDecoder(); +const fixedStr = (nBytes) => scaleTs.enhanceCodec( + scaleTs.Bytes(nBytes), + (str) => textEncoder$2.encode(str), + (bytes) => textDecoder$1.decode(bytes) +); + +const selfEncoder = (value) => { + let cache = (x) => { + const encoder = value(); + cache = encoder; + return encoder(x); + }; + return (x) => cache(x); +}; +const selfDecoder = (value) => { + let cache = (x) => { + const decoder = value(); + const result = decoder; + cache = decoder; + return result(x); + }; + return (x) => cache(x); +}; +const Self = (value) => scaleTs.createCodec( + selfEncoder(() => value().enc), + selfDecoder(() => value().dec) +); + +const discriminant = { + is(value, type) { + return value.type === type; + }, + as(value, type) { + if (type !== value.type) + throw new Error( + `Enum.as(enum, ${type}) used with actual type ${value.type}` + ); + return value; + } +}; +const Enum = Object.assign((type, value) => { + return { + type, + value + }; +}, discriminant); +const _Enum = new Proxy( + {}, + { + get(_, prop) { + return (value) => Enum(prop, value); + } + } +); + +const withInner = (codec, inner) => { + const result = codec; + result.inner = inner; + return result; +}; + +const VariantEnc = (...args) => { + const enc = scaleTs.Enum.enc(...args); + return withInner((v) => enc({ tag: v.type, value: v.value }), args[0]); +}; +const VariantDec = (...args) => { + const dec = scaleTs.Enum.dec(...args); + return withInner((v) => { + const { tag, value } = dec(v); + return Enum(tag, value); + }, args[0]); +}; +const Variant = (inner, ...args) => withInner( + scaleTs.createCodec( + VariantEnc( + utils.mapObject(inner, ([encoder]) => encoder), + ...args + ), + VariantDec( + utils.mapObject(inner, ([, decoder]) => decoder), + ...args + ) + ), + inner +); +Variant.enc = VariantEnc; +Variant.dec = VariantDec; +const ScaleEnum = (inner, ...args) => withInner(scaleTs.Enum(inner, ...args), inner); +ScaleEnum.enc = (inner, ...rest) => withInner(scaleTs.Enum.enc(inner, ...rest), inner); +ScaleEnum.dec = (inner, ...rest) => withInner(scaleTs.Enum.dec(inner, ...rest), inner); + +const len32$1 = { dkLen: 32 }; +const Blake2256 = (encoded) => blake2_js.blake2b(encoded, len32$1); +const len16 = { dkLen: 16 }; +const Blake2128 = (encoded) => blake2_js.blake2b(encoded, len16); +const Blake2128Concat = (encoded) => utils.mergeUint8([Blake2128(encoded), encoded]); + +const len32 = { dkLen: 32 }; +const Blake3256 = (encoded) => blake3_js.blake3(encoded, len32); +const Blake3256Concat = (encoded) => utils.mergeUint8([Blake3256(encoded), encoded]); + +const Identity = (encoded) => encoded; + +const bigintFromU16 = (v0, v1, v2, v3) => new DataView(new Uint16Array([v0, v1, v2, v3]).buffer).getBigUint64(0, true); +const MASK_64 = 2n ** 64n - 1n; +const rotl = (input, nBits) => input << nBits & MASK_64 | input >> 64n - nBits; +const multiply = (a, b) => a * b & MASK_64; +const add = (a, b) => a + b & MASK_64; +const PRIME64_1 = 11400714785074694791n; +const PRIME64_2 = 14029467366897019727n; +const PRIME64_3 = 1609587929392839161n; +const PRIME64_4 = 9650029242287828579n; +const PRIME64_5 = 2870177450012600261n; +function h64(input, seed = 0n) { + let v1 = add(add(seed, PRIME64_1), PRIME64_2); + let v2 = add(seed, PRIME64_2); + let v3 = seed; + let v4 = seed - PRIME64_1; + let totalLen = input.length; + let memsize = 0; + let memory = null; + (function update() { + let p2 = 0; + let bEnd = p2 + totalLen; + if (!totalLen) return; + memory = new Uint8Array(32); + if (totalLen < 32) { + memory.set(input.subarray(0, totalLen), memsize); + memsize += totalLen; + return; + } + if (p2 <= bEnd - 32) { + const limit = bEnd - 32; + do { + let other; + other = bigintFromU16( + input[p2 + 1] << 8 | input[p2], + input[p2 + 3] << 8 | input[p2 + 2], + input[p2 + 5] << 8 | input[p2 + 4], + input[p2 + 7] << 8 | input[p2 + 6] + ); + v1 = multiply(rotl(add(v1, multiply(other, PRIME64_2)), 31n), PRIME64_1); + p2 += 8; + other = bigintFromU16( + input[p2 + 1] << 8 | input[p2], + input[p2 + 3] << 8 | input[p2 + 2], + input[p2 + 5] << 8 | input[p2 + 4], + input[p2 + 7] << 8 | input[p2 + 6] + ); + v2 = multiply(rotl(add(v2, multiply(other, PRIME64_2)), 31n), PRIME64_1); + p2 += 8; + other = bigintFromU16( + input[p2 + 1] << 8 | input[p2], + input[p2 + 3] << 8 | input[p2 + 2], + input[p2 + 5] << 8 | input[p2 + 4], + input[p2 + 7] << 8 | input[p2 + 6] + ); + v3 = multiply(rotl(add(v3, multiply(other, PRIME64_2)), 31n), PRIME64_1); + p2 += 8; + other = bigintFromU16( + input[p2 + 1] << 8 | input[p2], + input[p2 + 3] << 8 | input[p2 + 2], + input[p2 + 5] << 8 | input[p2 + 4], + input[p2 + 7] << 8 | input[p2 + 6] + ); + v4 = multiply(rotl(add(v4, multiply(other, PRIME64_2)), 31n), PRIME64_1); + p2 += 8; + } while (p2 <= limit); + } + if (p2 < bEnd) { + memory.set(input.subarray(p2, bEnd), memsize); + memsize = bEnd - p2; + } + })(); + input = memory || input; + let result; + let p = 0; + if (totalLen >= 32) { + result = rotl(v1, 1n); + result = add(result, rotl(v2, 7n)); + result = add(result, rotl(v3, 12n)); + result = add(result, rotl(v4, 18n)); + v1 = multiply(rotl(multiply(v1, PRIME64_2), 31n), PRIME64_1); + result = result ^ v1; + result = add(multiply(result, PRIME64_1), PRIME64_4); + v2 = multiply(rotl(multiply(v2, PRIME64_2), 31n), PRIME64_1); + result = result ^ v2; + result = add(multiply(result, PRIME64_1), PRIME64_4); + v3 = multiply(rotl(multiply(v3, PRIME64_2), 31n), PRIME64_1); + result = result ^ v3; + result = add(multiply(result, PRIME64_1), PRIME64_4); + v4 = multiply(rotl(multiply(v4, PRIME64_2), 31n), PRIME64_1); + result = result ^ v4; + result = add(multiply(result, PRIME64_1), PRIME64_4); + } else { + result = add(seed, PRIME64_5); + } + result = add(result, BigInt(totalLen)); + while (p <= memsize - 8) { + let temp2 = bigintFromU16( + input[p + 1] << 8 | input[p], + input[p + 3] << 8 | input[p + 2], + input[p + 5] << 8 | input[p + 4], + input[p + 7] << 8 | input[p + 6] + ); + temp2 = multiply(rotl(multiply(temp2, PRIME64_2), 31n), PRIME64_1); + result = add(multiply(rotl(result ^ temp2, 27n), PRIME64_1), PRIME64_4); + p += 8; + } + if (p + 4 <= memsize) { + let temp2 = multiply( + bigintFromU16( + input[p + 1] << 8 | input[p], + input[p + 3] << 8 | input[p + 2], + 0, + 0 + ), + PRIME64_1 + ); + result = add(multiply(rotl(result ^ temp2, 23n), PRIME64_2), PRIME64_3); + p += 4; + } + while (p < memsize) { + const temp2 = multiply(bigintFromU16(input[p++], 0, 0, 0), PRIME64_5); + result = multiply(rotl(result ^ temp2, 11n), PRIME64_1); + } + let temp = result >> 33n; + result = multiply(result ^ temp, PRIME64_2); + temp = result >> 29n; + result = multiply(result ^ temp, PRIME64_3); + temp = result >> 32n; + result ^= temp; + return result; +} + +const Twox128 = (input) => { + const result = new Uint8Array(16); + const dv = new DataView(result.buffer); + dv.setBigUint64(0, h64(input), true); + dv.setBigUint64(8, h64(input, 1n), true); + return result; +}; +const Twox256 = (input) => { + const result = new Uint8Array(32); + const dv = new DataView(result.buffer); + dv.setBigUint64(0, h64(input), true); + dv.setBigUint64(8, h64(input, 1n), true); + dv.setBigUint64(16, h64(input, 2n), true); + dv.setBigUint64(24, h64(input, 3n), true); + return result; +}; +const Twox64Concat = (encoded) => utils.mergeUint8([scaleTs.u64.enc(h64(encoded)), encoded]); + +const Keccak256 = sha3_js.keccak_256; + +const getFormattedAddress = (hexAddress) => { + const nonChecksum = hexAddress.slice(2); + const hashedAddress = utils.toHex(Keccak256(textEncoder$2.encode(nonChecksum))).slice( + 2 + ); + const result = new Array(40); + for (let i = 0; i < 40; i++) { + const checksumVal = parseInt(hashedAddress[i], 16); + const char = nonChecksum[i]; + result[i] = checksumVal > 7 ? char.toUpperCase() : char; + } + return `0x${result.join("")}`; +}; +const bytes20Dec = scaleTs.Bytes(20)[1]; +const ethAccount = scaleTs.createCodec( + (input) => { + const bytes = utils.fromHex(input); + if (bytes.length !== 20) + throw new Error(`Invalid length found on EthAddress(${input})`); + const hexAddress = utils.toHex(bytes); + if (input === hexAddress || input === hexAddress.toUpperCase()) return bytes; + if (getFormattedAddress(hexAddress) !== input) + throw new Error(`Invalid checksum found on EthAddress(${input})`); + return bytes; + }, + scaleTs.createDecoder((bytes) => getFormattedAddress(utils.toHex(bytes20Dec(bytes)))) +); + +const Struct = (codecs) => withInner(scaleTs.Struct(codecs), codecs); +Struct.enc = (x) => withInner(scaleTs.Struct.enc(x), x); +Struct.dec = (x) => withInner(scaleTs.Struct.dec(x), x); +const Tuple = (...inner) => withInner(scaleTs.Tuple(...inner), inner); +Tuple.enc = (...inner) => withInner(scaleTs.Tuple.enc(...inner), inner); +Tuple.dec = (...inner) => withInner(scaleTs.Tuple.dec(...inner), inner); +const Vector = (inner, ...rest) => withInner(scaleTs.Vector(inner, ...rest), inner); +Vector.enc = (inner, ...rest) => withInner(scaleTs.Vector.enc(inner, ...rest), inner); +Vector.dec = (inner, ...rest) => withInner(scaleTs.Vector.dec(inner, ...rest), inner); +const Result = (ok, ko) => withInner(scaleTs.Result(ok, ko), { ok, ko }); +Result.enc = (ok, ko) => withInner(scaleTs.Result.enc(ok, ko), { ok, ko }); +Result.dec = (ok, ko) => withInner(scaleTs.Result.dec(ok, ko), { ok, ko }); +const Option = (inner) => withInner(scaleTs.Option(inner), inner); +Option.enc = (inner) => withInner(scaleTs.Option.enc(inner), inner); +Option.dec = (inner) => withInner(scaleTs.Option.dec(inner), inner); + +const dec = (isLsb = true) => scaleTs.createDecoder((data) => { + const bitsLen = compactNumber.dec(data); + const bytesLen = Math.ceil(bitsLen / 8); + const bytes = scaleTs.Bytes(bytesLen).dec(data); + const result = new Array(bitsLen); + let resultIdx = 0; + bytes.forEach((val) => { + for (let i = 0; i < 8 && resultIdx < bitsLen; i++) { + const actualIdx = isLsb ? i : 7 - i; + result[resultIdx++] = val >> actualIdx & 1; + } + }); + return result; +}); +const enc = (isLsb = true) => (input) => { + const lenEncoded = compactNumber.enc(input.length); + const nBytes = Math.ceil(input.length / 8); + const bytes = new Uint8Array(nBytes); + for (let byteIdx = 0; byteIdx < nBytes; byteIdx++) { + let inputIdx = byteIdx * 8; + let byte = 0; + for (let i = 0; i < 8 && inputIdx < input.length; i++, inputIdx++) + byte |= input[inputIdx] << (isLsb ? i : 7 - i); + bytes[byteIdx] = byte; + } + return utils.mergeUint8([lenEncoded, bytes]); +}; +const BitSeq = (isLsb) => scaleTs.createCodec(enc(isLsb), dec(isLsb)); +BitSeq.enc = enc; +BitSeq.dec = dec; + +const textEncoder$1 = new TextEncoder(); +const textDecoder = new TextDecoder(); +const fourChars = scaleTs.enhanceCodec( + scaleTs.Bytes(4), + textEncoder$1.encode.bind(textEncoder$1), + textDecoder.decode.bind(textDecoder) +); +const diggestVal = Struct({ + engine: fourChars, + payload: Hex() +}); +const diggest = Variant( + { + other: scaleTs.Bytes(), + consensus: diggestVal, + seal: diggestVal, + preRuntime: diggestVal, + runtimeUpdated: scaleTs._void + }, + [0, 4, 5, 6, 8] +); +const hex32$1 = Hex(32); +const blockHeader = Struct({ + parentHash: hex32$1, + number: compactNumber, + stateRoot: hex32$1, + extrinsicRoot: hex32$1, + digests: Vector(diggest) +}); + +const docs = scaleTs.Vector(scaleTs.str); + +const oStr = scaleTs.Option(scaleTs.str); +const primitive = scaleTs.Enum({ + bool: scaleTs._void, + char: scaleTs._void, + str: scaleTs._void, + u8: scaleTs._void, + u16: scaleTs._void, + u32: scaleTs._void, + u64: scaleTs._void, + u128: scaleTs._void, + u256: scaleTs._void, + i8: scaleTs._void, + i16: scaleTs._void, + i32: scaleTs._void, + i64: scaleTs._void, + i128: scaleTs._void, + i256: scaleTs._void +}); +const fields = scaleTs.Vector( + scaleTs.Struct({ + name: oStr, + type: compactNumber, + typeName: oStr, + docs + }) +); +const arr = scaleTs.Struct({ + len: scaleTs.u32, + type: compactNumber +}); +const bitSequence = scaleTs.Struct({ + bitStoreType: compactNumber, + bitOrderType: compactNumber +}); +const variant = scaleTs.Vector( + scaleTs.Struct({ + name: scaleTs.str, + fields, + index: scaleTs.u8, + docs + }) +); +const def = scaleTs.Enum({ + composite: fields, + variant, + sequence: compactNumber, + array: arr, + tuple: scaleTs.Vector(compactNumber), + primitive, + compact: compactNumber, + bitSequence +}); +const param = scaleTs.Struct({ + name: scaleTs.str, + type: scaleTs.Option(compactNumber) +}); +const params = scaleTs.Vector(param); +const entry = scaleTs.Struct({ + id: compactNumber, + path: docs, + params, + def, + docs +}); +const lookup = scaleTs.Vector(entry); + +const itemDeprecation = scaleTs.Enum({ + NotDeprecated: scaleTs._void, + DeprecatedWithoutNote: scaleTs._void, + Deprecated: scaleTs.Struct({ + note: scaleTs.str, + since: scaleTs.Option(scaleTs.str) + }) +}); +const variantDeprecation = scaleTs.Vector( + scaleTs.Struct({ + index: scaleTs.u8, + deprecation: scaleTs.Enum( + { + DeprecatedWithoutNote: scaleTs._void, + Deprecated: scaleTs.Struct({ + note: scaleTs.str, + since: scaleTs.Option(scaleTs.str) + }) + }, + [1, 2] + ) + }) +); + +const runtimeApiMethod = { + name: scaleTs.str, + inputs: scaleTs.Vector( + scaleTs.Struct({ + name: scaleTs.str, + type: compactNumber + }) + ), + output: compactNumber, + docs +}; +const runtimeApiV15 = scaleTs.Struct({ + name: scaleTs.str, + methods: scaleTs.Vector(scaleTs.Struct(runtimeApiMethod)), + docs +}); +const runtimeApi = scaleTs.Struct({ + name: scaleTs.str, + methods: scaleTs.Vector( + scaleTs.Struct({ ...runtimeApiMethod, deprecationInfo: itemDeprecation }) + ), + docs, + version: compactNumber, + deprecationInfo: itemDeprecation +}); +const viewFunction = scaleTs.Struct({ + id: Hex(32), + ...runtimeApiMethod, + deprecationInfo: itemDeprecation +}); + +const hashType = scaleTs.Enum({ + Blake2128: scaleTs._void, + Blake2256: scaleTs._void, + Blake2128Concat: scaleTs._void, + Twox128: scaleTs._void, + Twox256: scaleTs._void, + Twox64Concat: scaleTs._void, + Identity: scaleTs._void +}); +const hashers$1 = scaleTs.Vector(hashType); +const storageMap = scaleTs.Struct({ + hashers: hashers$1, + key: compactNumber, + value: compactNumber +}); +const storageItem = { + name: scaleTs.str, + modifier: scaleTs.u8, + type: scaleTs.Enum({ + plain: compactNumber, + map: storageMap + }), + fallback: Hex(), + docs +}; +const enumRefV14 = scaleTs.Option(compactNumber); +const v14Pallet = { + name: scaleTs.str, + storage: scaleTs.Option( + scaleTs.Struct({ + prefix: scaleTs.str, + items: scaleTs.Vector(scaleTs.Struct(storageItem)) + }) + ), + calls: enumRefV14, + events: enumRefV14, + constants: scaleTs.Vector( + scaleTs.Struct({ + name: scaleTs.str, + type: compactNumber, + value: Hex(), + docs + }) + ), + errors: enumRefV14, + index: scaleTs.u8 +}; +const v15Pallet = { + ...v14Pallet, + docs +}; +const enumRef = scaleTs.Option( + scaleTs.Struct({ type: compactNumber, deprecationInfo: variantDeprecation }) +); +const v16Pallet = { + name: scaleTs.str, + storage: scaleTs.Option( + scaleTs.Struct({ + prefix: scaleTs.str, + items: scaleTs.Vector( + scaleTs.Struct({ + ...storageItem, + deprecationInfo: itemDeprecation + }) + ) + }) + ), + calls: enumRef, + events: enumRef, + constants: scaleTs.Vector( + scaleTs.Struct({ + name: scaleTs.str, + type: compactNumber, + value: Hex(), + docs, + deprecationInfo: itemDeprecation + }) + ), + errors: enumRef, + associatedTypes: scaleTs.Vector( + scaleTs.Struct({ + name: scaleTs.str, + type: compactNumber, + docs + }) + ), + viewFns: scaleTs.Vector(viewFunction), + index: scaleTs.u8, + docs, + deprecationInfo: itemDeprecation +}; + +const empty = new Uint8Array(); +const Always = (value) => scaleTs.createCodec( + () => empty, + () => value +); +const extrinsic$2 = scaleTs.Struct({ + type: compactNumber, + version: scaleTs.u8, + signedExtensions: scaleTs.Vector( + scaleTs.Struct({ + identifier: scaleTs.str, + type: compactNumber, + additionalSigned: compactNumber + }) + ) +}); +const v14 = scaleTs.Struct({ + lookup, + pallets: scaleTs.Vector(scaleTs.Struct({ ...v14Pallet, docs: Always([]) })), + extrinsic: extrinsic$2, + type: compactNumber, + apis: Always([]) +}); + +const extrinsic$1 = scaleTs.Struct({ + version: scaleTs.u8, + address: compactNumber, + call: compactNumber, + signature: compactNumber, + extra: compactNumber, + signedExtensions: scaleTs.Vector( + scaleTs.Struct({ + identifier: scaleTs.str, + type: compactNumber, + additionalSigned: compactNumber + }) + ) +}); +const v15 = scaleTs.Struct({ + lookup, + pallets: scaleTs.Vector(scaleTs.Struct(v15Pallet)), + extrinsic: extrinsic$1, + type: compactNumber, + apis: scaleTs.Vector(runtimeApiV15), + outerEnums: scaleTs.Struct({ + call: compactNumber, + event: compactNumber, + error: compactNumber + }), + custom: scaleTs.Vector(scaleTs.Tuple(scaleTs.str, scaleTs.Struct({ type: compactNumber, value: Hex() }))) +}); + +const extrinsic = scaleTs.Struct({ + version: scaleTs.Vector(scaleTs.u8), + address: compactNumber, + call: compactNumber, + signature: compactNumber, + signedExtensionsByVersion: scaleTs.Vector(scaleTs.Tuple(scaleTs.u8, scaleTs.Vector(compactNumber))), + signedExtensions: scaleTs.Vector( + scaleTs.Struct({ + identifier: scaleTs.str, + type: compactNumber, + additionalSigned: compactNumber + }) + ) +}); +const v16 = scaleTs.Struct({ + lookup, + pallets: scaleTs.Vector(scaleTs.Struct(v16Pallet)), + extrinsic, + apis: scaleTs.Vector(runtimeApi), + outerEnums: scaleTs.Struct({ + call: compactNumber, + event: compactNumber, + error: compactNumber + }), + custom: scaleTs.Vector(scaleTs.Tuple(scaleTs.str, scaleTs.Struct({ type: compactNumber, value: Hex() }))) +}); + +const unsupportedFn = () => { + throw new Error("Unsupported metadata version!"); +}; +const unsupported = scaleTs.createCodec( + unsupportedFn, + unsupportedFn +); +const metadata = scaleTs.Struct({ + magicNumber: scaleTs.u32, + metadata: scaleTs.Enum({ + v0: unsupported, + v1: unsupported, + v2: unsupported, + v3: unsupported, + v4: unsupported, + v5: unsupported, + v6: unsupported, + v7: unsupported, + v8: unsupported, + v9: unsupported, + v10: unsupported, + v11: unsupported, + v12: unsupported, + v13: unsupported, + v14, + v15, + v16 + }) +}); +const opaqueBytes = scaleTs.Bytes(); +const optionOpaque = scaleTs.Option(opaqueBytes); +const opaqueOpaqueBytes = scaleTs.Tuple(scaleTs.compact, opaqueBytes); +const decAnyMetadata = (input) => { + try { + return metadata.dec(input); + } catch (_) { + } + try { + return metadata.dec(optionOpaque.dec(input)); + } catch (_) { + } + try { + return metadata.dec(opaqueBytes.dec(input)); + } catch (_) { + } + try { + return metadata.dec(opaqueOpaqueBytes.dec(input)[1]); + } catch (_) { + } + throw null; +}; + +const unifyMetadata = (metadata) => { + if ("magicNumber" in metadata) metadata = metadata.metadata; + if ("tag" in metadata) { + if (metadata.tag !== "v14" && metadata.tag !== "v15" && metadata.tag !== "v16") + throw new Error("Only metadata 14, 15, and 16 are supported"); + metadata = metadata.value; + } + if ("signedExtensionsByVersion" in metadata.extrinsic) { + return { version: 16, ...metadata }; + } + if ("custom" in metadata) { + const { lookup: lookup2, extrinsic: extrinsic2, custom, apis, pallets: pallets2, outerEnums } = metadata; + return { + version: 15, + lookup: lookup2, + pallets: pallets2.map((p) => ({ + ...p, + calls: p.calls != null ? { type: p.calls } : void 0, + events: p.events != null ? { type: p.events } : void 0, + errors: p.errors != null ? { type: p.errors } : void 0, + viewFns: [], + associatedTypes: [] + })), + extrinsic: { ...extrinsic2, version: [extrinsic2.version] }, + apis, + outerEnums, + custom + }; + } + const { lookup, extrinsic, pallets } = metadata; + return { + version: 14, + lookup, + pallets: pallets.map((p) => ({ + ...p, + calls: p.calls != null ? { type: p.calls } : void 0, + events: p.events != null ? { type: p.events } : void 0, + errors: p.errors != null ? { type: p.errors } : void 0, + viewFns: [], + associatedTypes: [] + })), + extrinsic: { ...extrinsic, version: [extrinsic.version] }, + apis: [] + }; +}; + +const TYPES = { + bare: 0, + 0: "bare", + general: 1, + 1: "general", + signed: 2, + 2: "signed" +}; +const extrinsicFormat = scaleTs.enhanceCodec( + scaleTs.u8, + ({ version, type }) => version + (TYPES[type] << 6), + (v) => { + const version = v & 63; + const type = v >> 6; + if (version === 4 && (type === TYPES.bare || type === TYPES.signed)) + return { version, type: TYPES[type] }; + if (version === 5 && (type === TYPES.bare || type === TYPES.general)) + return { version, type: TYPES[type] }; + throw new Error(`ExtrinsicFormat ${v} not valid`); + } +); + +const textEncoder = new TextEncoder(); +const hashers = /* @__PURE__ */ new Map([ + [Identity, 0], + [Twox64Concat, 8], + [Blake2128Concat, 16], + [Blake2128, -16], + [Blake2256, -32], + [Twox128, -16], + [Twox256, -32] +]); +const Storage = (pallet) => { + const palledEncoded = Twox128(textEncoder.encode(pallet)); + return (name, ...encoders) => { + const palletItemEncoded = utils.mergeUint8([ + palledEncoded, + Twox128(textEncoder.encode(name)) + ]); + const palletItemEncodedHex = utils.toHex(palletItemEncoded); + const dec = (key) => { + if (!key.startsWith(palletItemEncodedHex)) + throw new Error(`key does not match this storage (${pallet}.${name})`); + if (encoders.length === 0) return []; + const argsKey = utils.fromHex(key.slice(palletItemEncodedHex.length)); + const result = new Array(encoders.length); + for (let i = 0, cur = 0; i < encoders.length; i++) { + const [codec, hasher] = encoders[i]; + const hBytes = hashers.get(hasher); + if (hBytes == null) throw new Error("Unknown hasher"); + if (hBytes < 0) { + const opaqueBytes = hBytes * -1; + result[i] = utils.toHex(argsKey.slice(cur, cur + opaqueBytes)); + cur += opaqueBytes; + } else { + cur += hBytes; + result[i] = codec.dec(argsKey.slice(cur)); + cur += codec.enc(result[i]).length; + } + } + return result; + }; + const fns = encoders.map( + ([{ enc: enc2 }, hash]) => (val) => hash(enc2(val)) + ); + const enc = (...args) => utils.toHex( + utils.mergeUint8([ + palletItemEncoded, + ...args.map((val, idx) => fns[idx](val)) + ]) + ); + return { + enc, + dec + }; + }; +}; + +const PREFIX = Binary.fromText("modlpy/utilisuba").asBytes(); +const getMultisigAccountId = ({ + threshold, + signatories +}) => { + const sortedSignatories = sortMultisigSignatories(signatories); + const payload = utils.mergeUint8([ + PREFIX, + scaleTs.compact.enc(sortedSignatories.length), + ...sortedSignatories, + scaleTs.u16.enc(threshold) + ]); + return Blake2256(payload); +}; +const sortMultisigSignatories = (signatories) => signatories.slice().sort((a, b) => { + for (let i = 0; ; i++) { + const overA = i >= a.length; + const overB = i >= b.length; + if (overA && overB) return 0; + else if (overA) return -1; + else if (overB) return 1; + else if (a[i] !== b[i]) return a[i] > b[i] ? 1 : -1; + } +}); + +const TrieNodeHeaders = { + Leaf: "Leaf", + Branch: "Branch", + BranchWithVal: "BranchWithVal", + LeafWithHash: "LeafWithHash", + BranchWithHash: "BranchWithHash", + Empty: "Empty", + Reserved: "Reserved" +}; + +const varHex = Hex().dec; +const allHex = Hex(Infinity).dec; +const hex32 = Hex(32).dec; +const byte = scaleTs.u8.dec; +const getHeader = (bytes) => { + const firstByte = byte(bytes); + let bitsLeft = 6; + const typeId = firstByte >> bitsLeft; + const type = typeId ? typeId === 1 ? TrieNodeHeaders.Leaf : typeId === 2 ? TrieNodeHeaders.Branch : TrieNodeHeaders.BranchWithVal : firstByte >> --bitsLeft ? TrieNodeHeaders.LeafWithHash : firstByte >> --bitsLeft ? TrieNodeHeaders.BranchWithHash : firstByte ? TrieNodeHeaders.Reserved : TrieNodeHeaders.Empty; + let nNibles = firstByte & 255 >> 8 - bitsLeft; + if (nNibles === 2 ** bitsLeft - 1) { + let current; + do + nNibles += current = byte(bytes); + while (current === 255); + } + return { + type, + partialKey: Hex(Math.ceil(nNibles / 2)).dec(bytes).slice(nNibles % 2 ? 3 : 2) + }; +}; +const trieNodeDec = scaleTs.createDecoder((bytes) => { + const header = getHeader(bytes); + const { type } = header; + if (type === "Empty" || type === "Reserved") return header; + if (type === "Leaf" || type === "LeafWithHash") + return { + ...header, + value: allHex(bytes) + }; + const bitmap = scaleTs.u16.dec(bytes); + const keys = []; + for (let i = 0; i < 16; i++) if (bitmap >> i & 1) keys.push(i.toString(16)); + let value = null; + if (type === "BranchWithVal") value = varHex(bytes); + if (type === "BranchWithHash") value = hex32(bytes); + const result = { + ...header, + children: Object.fromEntries(keys.map((key) => [key, varHex(bytes)])) + }; + if (value !== null) result.value = value; + return result; +}); + +const TrieNodeWithHash = (hasher) => scaleTs.createDecoder((input) => { + const hash = utils.toHex(hasher(new Uint8Array(input.buffer))); + try { + return { + hash, + ...trieNodeDec(input) + }; + } catch { + return { type: "Raw", hash, value: "" }; + } +}); +const validateProofs = (proofs, hasher = Blake2256) => { + const proofsList = proofs.map(TrieNodeWithHash(hasher)); + const proofsRecord = Object.fromEntries(proofsList.map((p) => [p.hash, p])); + const hashes = proofsList.map((p) => p.hash); + const roots = new Set(hashes); + const setRawValue = (input) => { + if (input.value) return; + const val = proofs[hashes.indexOf(input.hash)]; + input.value = typeof val === "string" ? val : utils.toHex(val); + }; + proofsList.forEach((p) => { + if ("children" in p) { + Object.values(p.children).forEach((hash) => { + const child = proofsRecord[hash]; + if (child) { + child.parent = p.hash; + roots.delete(hash); + } + }); + } + if (p.type === "BranchWithHash" || p.type === "LeafWithHash") { + const childHash = p.value; + const child = proofsRecord[childHash]; + if (!child) return; + roots.delete(childHash); + if (child.type !== "Raw") { + Object.keys(child).forEach((k) => delete child[k]); + child.type = "Raw"; + child.hash = childHash; + } + child.parent = p.hash; + setRawValue(child); + } + if (p.type === "Raw") setRawValue(p); + }); + return roots.size === 1 ? { rootHash: roots.values().next().value, proofs: proofsRecord } : null; +}; + +Object.defineProperty(exports, "Bytes", { + enumerable: true, + get: function () { return scaleTs.Bytes; } +}); +Object.defineProperty(exports, "_void", { + enumerable: true, + get: function () { return scaleTs._void; } +}); +Object.defineProperty(exports, "bool", { + enumerable: true, + get: function () { return scaleTs.bool; } +}); +Object.defineProperty(exports, "compact", { + enumerable: true, + get: function () { return scaleTs.compact; } +}); +Object.defineProperty(exports, "createCodec", { + enumerable: true, + get: function () { return scaleTs.createCodec; } +}); +Object.defineProperty(exports, "createDecoder", { + enumerable: true, + get: function () { return scaleTs.createDecoder; } +}); +Object.defineProperty(exports, "enhanceCodec", { + enumerable: true, + get: function () { return scaleTs.enhanceCodec; } +}); +Object.defineProperty(exports, "enhanceDecoder", { + enumerable: true, + get: function () { return scaleTs.enhanceDecoder; } +}); +Object.defineProperty(exports, "enhanceEncoder", { + enumerable: true, + get: function () { return scaleTs.enhanceEncoder; } +}); +Object.defineProperty(exports, "i128", { + enumerable: true, + get: function () { return scaleTs.i128; } +}); +Object.defineProperty(exports, "i16", { + enumerable: true, + get: function () { return scaleTs.i16; } +}); +Object.defineProperty(exports, "i256", { + enumerable: true, + get: function () { return scaleTs.i256; } +}); +Object.defineProperty(exports, "i32", { + enumerable: true, + get: function () { return scaleTs.i32; } +}); +Object.defineProperty(exports, "i64", { + enumerable: true, + get: function () { return scaleTs.i64; } +}); +Object.defineProperty(exports, "i8", { + enumerable: true, + get: function () { return scaleTs.i8; } +}); +Object.defineProperty(exports, "str", { + enumerable: true, + get: function () { return scaleTs.str; } +}); +Object.defineProperty(exports, "u128", { + enumerable: true, + get: function () { return scaleTs.u128; } +}); +Object.defineProperty(exports, "u16", { + enumerable: true, + get: function () { return scaleTs.u16; } +}); +Object.defineProperty(exports, "u256", { + enumerable: true, + get: function () { return scaleTs.u256; } +}); +Object.defineProperty(exports, "u32", { + enumerable: true, + get: function () { return scaleTs.u32; } +}); +Object.defineProperty(exports, "u64", { + enumerable: true, + get: function () { return scaleTs.u64; } +}); +Object.defineProperty(exports, "u8", { + enumerable: true, + get: function () { return scaleTs.u8; } +}); +exports.AccountId = AccountId; +exports.Bin = Bin; +exports.Binary = Binary; +exports.BitSeq = BitSeq; +exports.Blake2128 = Blake2128; +exports.Blake2128Concat = Blake2128Concat; +exports.Blake2256 = Blake2256; +exports.Blake3256 = Blake3256; +exports.Blake3256Concat = Blake3256Concat; +exports.Enum = Enum; +exports.FixedSizeBinary = FixedSizeBinary; +exports.Hex = Hex; +exports.Identity = Identity; +exports.Keccak256 = Keccak256; +exports.Option = Option; +exports.Result = Result; +exports.ScaleEnum = ScaleEnum; +exports.Self = Self; +exports.Storage = Storage; +exports.Struct = Struct; +exports.TrieNodeHeaders = TrieNodeHeaders; +exports.TrieNodeWithHash = TrieNodeWithHash; +exports.Tuple = Tuple; +exports.Twox128 = Twox128; +exports.Twox256 = Twox256; +exports.Twox64Concat = Twox64Concat; +exports.Variant = Variant; +exports.Vector = Vector; +exports._Enum = _Enum; +exports.bitSequence = bitSequence$1; +exports.blockHeader = blockHeader; +exports.char = char; +exports.compactBn = compactBn; +exports.compactNumber = compactNumber; +exports.decAnyMetadata = decAnyMetadata; +exports.ethAccount = ethAccount; +exports.extrinsicFormat = extrinsicFormat; +exports.fixedStr = fixedStr; +exports.fromBufferToBase58 = fromBufferToBase58; +exports.getMultisigAccountId = getMultisigAccountId; +exports.getSs58AddressInfo = getSs58AddressInfo; +exports.h64 = h64; +exports.metadata = metadata; +exports.selfDecoder = selfDecoder; +exports.selfEncoder = selfEncoder; +exports.sortMultisigSignatories = sortMultisigSignatories; +exports.trieNodeDec = trieNodeDec; +exports.unifyMetadata = unifyMetadata; +exports.v14 = v14; +exports.v14Lookup = lookup; +exports.v15 = v15; +exports.v16 = v16; +exports.validateProofs = validateProofs; +//# sourceMappingURL=index.js.map diff --git a/packages/bizinikiwi-bindings/dist/index.js.map b/packages/bizinikiwi-bindings/dist/index.js.map new file mode 100644 index 0000000..877f924 --- /dev/null +++ b/packages/bizinikiwi-bindings/dist/index.js.map @@ -0,0 +1 @@ +{"version":3,"file":"index.js","sources":["../src/utils/ss58-util.ts","../src/codecs/scale/AccountId.ts","../src/codecs/scale/Binary.ts","../src/codecs/scale/compact.ts","../src/codecs/scale/bitSequence.ts","../src/codecs/scale/char.ts","../src/codecs/scale/Hex.ts","../src/codecs/scale/fixed-str.ts","../src/codecs/scale/Self.ts","../src/types/enum.ts","../src/codecs/scale/with-inner.ts","../src/codecs/scale/Variant.ts","../src/hashes/blake2.ts","../src/hashes/blake3.ts","../src/hashes/identity.ts","../src/hashes/h64.ts","../src/hashes/twoX.ts","../src/hashes/keccak.ts","../src/codecs/scale/ethAccount.ts","../src/codecs/scale/shaped.ts","../src/codecs/scale/BitSeq.ts","../src/codecs/blockHeader.ts","../src/codecs/metadata/docs.ts","../src/codecs/metadata/lookup.ts","../src/codecs/metadata/deprecation.ts","../src/codecs/metadata/runtime-api.ts","../src/codecs/metadata/pallets.ts","../src/codecs/metadata/v14.ts","../src/codecs/metadata/v15.ts","../src/codecs/metadata/v16.ts","../src/codecs/metadata/metadata.ts","../src/codecs/metadata/unified.ts","../src/extrinsics/extrinsic-format.ts","../src/storage.ts","../src/utils/multisig.ts","../src/trie/types.ts","../src/trie/node-decoder.ts","../src/trie/proofs.ts"],"sourcesContent":["import { base58 } from \"@scure/base\"\nimport { blake2b } from \"@noble/hashes/blake2.js\"\n\nconst SS58_PREFIX = new TextEncoder().encode(\"SS58PRE\")\nconst CHECKSUM_LENGTH = 2\n\nexport type SS58String = string & { __SS58String?: unknown }\nexport type SS58AddressInfo =\n | { isValid: false }\n | { isValid: true; ss58Format: number; publicKey: Uint8Array }\n\nexport const getSs58AddressInfo = (address: SS58String): SS58AddressInfo => {\n try {\n const decoded = base58.decode(address)\n const prefixBytes = decoded.subarray(0, decoded[0] & 0b0100_0000 ? 2 : 1)\n const publicKey = decoded.subarray(\n prefixBytes.length,\n decoded.length - CHECKSUM_LENGTH,\n )\n\n const checksum = decoded.subarray(prefixBytes.length + publicKey.length)\n const expectedChecksum = blake2b(\n Uint8Array.of(...SS58_PREFIX, ...prefixBytes, ...publicKey),\n {\n dkLen: 64,\n },\n ).subarray(0, CHECKSUM_LENGTH)\n\n const isChecksumValid =\n checksum[0] === expectedChecksum[0] && checksum[1] === expectedChecksum[1]\n\n if (!isChecksumValid) return { isValid: false }\n\n return {\n isValid: true,\n ss58Format: prefixBytesToNumber(prefixBytes),\n publicKey: publicKey.slice(),\n }\n } catch (_) {\n return { isValid: false }\n }\n}\n\nconst prefixBytesToNumber = (bytes: Uint8Array) => {\n const dv = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength)\n return dv.byteLength === 1 ? dv.getUint8(0) : dv.getUint16(0)\n}\n\nconst withSs58Cache = (fn: (publicKey: Uint8Array) => SS58String) => {\n let cache: Record = {}\n let activityCount = 0\n let latestCount = 0\n const checkActivity = () => {\n if (activityCount === latestCount) {\n cache = {}\n activityCount = latestCount = 0\n } else {\n latestCount = activityCount\n setTimeout(checkActivity, 0)\n }\n }\n\n return (publicKey: Uint8Array): SS58String => {\n if (++activityCount === 1) checkActivity()\n\n let entry = cache\n const lastIdx = publicKey.length - 1\n for (let i = 0; i <= lastIdx; i++) entry = entry[publicKey[i]] ||= {}\n return (entry[publicKey[lastIdx]] ||= fn(publicKey))\n }\n}\n\nexport const fromBufferToBase58 = (ss58Format: number) => {\n const prefixBytes =\n ss58Format < 64\n ? Uint8Array.of(ss58Format)\n : Uint8Array.of(\n ((ss58Format & 0b0000_0000_1111_1100) >> 2) | 0b0100_0000,\n (ss58Format >> 8) | ((ss58Format & 0b0000_0000_0000_0011) << 6),\n )\n\n return withSs58Cache((publicKey: Uint8Array): SS58String => {\n const checksum = blake2b(\n Uint8Array.of(...SS58_PREFIX, ...prefixBytes, ...publicKey),\n {\n dkLen: 64,\n },\n ).subarray(0, CHECKSUM_LENGTH)\n return base58.encode(\n Uint8Array.of(...prefixBytes, ...publicKey, ...checksum),\n )\n })\n}\n","import { Bytes, enhanceCodec } from \"scale-ts\"\nimport {\n getSs58AddressInfo,\n SS58String,\n fromBufferToBase58,\n} from \"@/utils/ss58-util\"\n\nfunction fromBase58ToBuffer(nBytes: number, _ss58Format: number) {\n return (address: SS58String) => {\n const info = getSs58AddressInfo(address)\n if (!info.isValid) throw new Error(\"Invalid checksum\")\n const { publicKey } = info\n if (publicKey.length !== nBytes)\n throw new Error(\"Invalid public key length\")\n\n return publicKey\n }\n}\n\nexport const AccountId = (ss58Format: number = 42, nBytes: 32 | 33 = 32) =>\n enhanceCodec(\n Bytes(nBytes),\n fromBase58ToBuffer(nBytes, ss58Format),\n fromBufferToBase58(ss58Format),\n )\n","import {\n Bytes,\n Codec,\n Decoder,\n Encoder,\n Tuple,\n compact,\n createCodec,\n} from \"scale-ts\"\nimport { fromHex, mergeUint8, toHex } from \"@pezkuwi/papi-utils\"\nimport type { HexString } from \"./Hex\"\nimport { SS58String } from \"@/utils\"\nimport { AccountId } from \"./AccountId\"\n\nconst textEncoder = new TextEncoder()\nconst textDecoder = new TextDecoder()\nconst opaqueBytesDec = Tuple(compact, Bytes(Infinity))[1]\n\nexport class Binary {\n #bytes: Uint8Array\n #opaqueBytes: Uint8Array | null = null\n #hex: HexString | null = null\n #opaqueHex: HexString | null = null\n #str: string | null = null\n\n constructor(data: Uint8Array, opaque = false) {\n if (opaque) {\n try {\n const [len, bytes] = opaqueBytesDec(data)\n if (len === bytes.length) {\n this.#bytes = bytes\n this.#opaqueBytes = data\n return\n }\n } catch (_) {}\n throw new Error(\"Invalid opaque bytes\")\n } else this.#bytes = data\n }\n\n asText = () => (this.#str ??= textDecoder.decode(this.#bytes))\n\n asHex = () => (this.#hex ??= toHex(this.#bytes)) as `0x${string}`\n asOpaqueHex = () =>\n (this.#opaqueHex ??= toHex(this.asOpaqueBytes())) as `0x${string}`\n\n asBytes = () => this.#bytes\n asOpaqueBytes = () =>\n (this.#opaqueBytes ??= mergeUint8([\n compact[0](this.#bytes.length),\n this.#bytes,\n ]))\n\n static fromText(input: string): Binary {\n return new this(textEncoder.encode(input))\n }\n\n static fromHex(input: HexString): Binary {\n return new this(fromHex(input))\n }\n static fromOpaqueHex(input: HexString): Binary {\n return new this(fromHex(input), true)\n }\n\n static fromBytes(input: Uint8Array): Binary {\n return new this(input)\n }\n static fromOpaqueBytes(input: Uint8Array): Binary {\n return new this(input, true)\n }\n}\n\nconst [accountIdEncoder] = AccountId()\nexport class FixedSizeBinary<_L extends number> extends Binary {\n constructor(data: Uint8Array) {\n super(data)\n }\n\n static fromArray & { length: L }>(\n input: I,\n ) {\n return new this(new Uint8Array(input))\n }\n\n static fromAccountId32(\n input: L extends 32 ? SS58String : never,\n ) {\n return new this(accountIdEncoder(input))\n }\n}\n\nconst enc = (nBytes?: number): Encoder => {\n const _enc = Bytes.enc(nBytes)\n return (value) => _enc(value.asBytes())\n}\n\nconst dec = (nBytes?: number): Decoder => {\n const _dec = Bytes.dec(nBytes)\n const Bin = nBytes == null ? Binary : FixedSizeBinary\n return (value) => Bin.fromBytes(_dec(value))\n}\n\nexport const Bin = (nBytes?: number): Codec =>\n createCodec(enc(nBytes), dec(nBytes))\n\nBin.enc = enc\nBin.dec = dec\n","import { compact, enhanceCodec } from \"scale-ts\"\n\nexport const compactNumber = enhanceCodec(compact, (v) => v, Number)\nexport const compactBn = enhanceCodec(compact, (v) => v, BigInt)\n","import { Bytes, Decoder, Encoder, createCodec, createDecoder } from \"scale-ts\"\nimport { compactNumber } from \"./compact\"\n\nexport interface BitSequence {\n bitsLen: number\n bytes: Uint8Array\n}\n\nconst bitSequenceDecoder: Decoder = createDecoder((data) => {\n const bitsLen = compactNumber.dec(data)\n\n const bytesLen = Math.ceil(bitsLen / 8)\n const bytes = Bytes(bytesLen).dec(data)\n return { bytes, bitsLen }\n})\n\nconst bitSequenceEncoder: Encoder = (input) => {\n if (input.bitsLen > input.bytes.length * 8)\n throw new Error(\n `Not enough bytes. (bitsLen:${input.bitsLen}, bytesLen:${input.bytes.length})`,\n )\n\n const lenEncoded = compactNumber.enc(input.bitsLen)\n const result = new Uint8Array(input.bytes.length + lenEncoded.length)\n result.set(lenEncoded, 0)\n result.set(input.bytes, lenEncoded.length)\n return result\n}\n\nexport const bitSequence = createCodec(bitSequenceEncoder, bitSequenceDecoder)\n","import { enhanceCodec, u8 } from \"scale-ts\"\n\nexport const char = enhanceCodec(\n u8,\n (str: string) => str.charCodeAt(0),\n String.fromCharCode,\n)\n","import { fromHex, toHex } from \"@pezkuwi/papi-utils\"\nimport { Bytes, Codec, Decoder, Encoder, createCodec } from \"scale-ts\"\n\nexport type HexString = string & { __hexString?: unknown }\n\nconst enc = (nBytes?: number): Encoder => {\n const _enc = Bytes.enc(nBytes)\n return (value: string) => _enc(fromHex(value))\n}\n\nconst dec = (nBytes?: number): Decoder => {\n const _dec = Bytes.dec(nBytes)\n return (value) => toHex(_dec(value)) as HexString\n}\n\nexport const Hex = (nBytes?: number): Codec =>\n createCodec(enc(nBytes), dec(nBytes))\n\nHex.enc = enc\nHex.dec = dec\n","import { Bytes, enhanceCodec } from \"scale-ts\"\n\nexport const textEncoder = new TextEncoder()\nconst textDecoder = new TextDecoder()\n\nexport const fixedStr = (nBytes: number) =>\n enhanceCodec(\n Bytes(nBytes),\n (str: string) => textEncoder.encode(str),\n (bytes) => textDecoder.decode(bytes),\n )\n","import { Codec, Decoder, Encoder, createCodec, _void } from \"scale-ts\"\n\nexport const selfEncoder = (value: () => Encoder): Encoder => {\n let cache: Encoder = (x) => {\n const encoder = value()\n cache = encoder\n return encoder(x)\n }\n\n return (x) => cache(x)\n}\n\nexport const selfDecoder = (value: () => Decoder): Decoder => {\n let cache: Decoder = (x) => {\n const decoder = value()\n const result = decoder\n cache = decoder\n return result(x)\n }\n\n return (x) => cache(x)\n}\n\nexport const Self = (value: () => Codec): Codec =>\n createCodec(\n selfEncoder(() => value().enc),\n selfDecoder(() => value().dec),\n )\n","export type Enum = {\n [K in keyof T & string]: {\n type: K\n value: T[K]\n }\n}[keyof T & string]\n\nexport type EnumVariant<\n T extends { type: string; value?: any },\n K extends T[\"type\"],\n> = T & {\n type: K\n}\n\nexport type ExtractEnumValue<\n T extends { type: string; value?: any },\n K extends string,\n> = EnumVariant[\"value\"]\n\ntype ValueArg = undefined extends V ? [value?: V] : [value: V]\n\ninterface Discriminant {\n is(\n value: T,\n type: K,\n ): value is T & { type: K }\n as(\n value: T,\n type: K,\n ): ExtractEnumValue\n}\nconst discriminant: Discriminant = {\n is(\n value: T,\n type: K,\n ): value is T & { type: K } {\n return value.type === type\n },\n as(value, type) {\n if (type !== value.type)\n throw new Error(\n `Enum.as(enum, ${type}) used with actual type ${value.type}`,\n )\n return value\n },\n}\ninterface EnumFn extends Discriminant {\n (\n type: K,\n ...[value]: ValueArg>\n ): EnumVariant\n}\nexport const Enum: EnumFn = Object.assign((type: string, value?: any) => {\n return {\n type,\n value,\n } as any\n}, discriminant)\n\n// well-known enums\nexport type GetEnum> = {\n [K in T[\"type\"]]: (\n ...args: ExtractEnumValue extends undefined\n ? []\n : [value: ExtractEnumValue]\n ) => EnumVariant\n}\nexport const _Enum = new Proxy(\n {},\n {\n get(_, prop: string) {\n return (value: string) => Enum(prop, value)\n },\n },\n)\n\n// type Bar = Enum<{\n// Kaka: 1\n// Bar: 2\n// }>\n\n// type FooInput = Enum<{\n// foo: \"foo\" | undefined\n// bar: Bar\n// baz: number\n// wtf: boolean\n// }>\n\n// declare function foo(foo: FooInput): void\n// foo(Enum(\"bar\", Enum(\"Bar\", 2)))\n\n// const InputEnum: GetEnum = null as any;\n// InputEnum.bar(Enum('Bar', 2))\n","export const withInner = (codec: T, inner: I): T & { inner: I } => {\n const result: T & { inner: I } = codec as any\n result.inner = inner\n return result\n}\n","import {\n Codec,\n CodecType,\n Decoder,\n DecoderType,\n Encoder,\n EncoderType,\n Enum as OEnum,\n StringRecord,\n createCodec,\n} from \"scale-ts\"\nimport { mapObject } from \"@pezkuwi/papi-utils\"\nimport { Enum } from \"@/types/enum\"\nimport { withInner } from \"./with-inner\"\n\ntype Tuple = readonly [T, ...T[]] & { length: N }\n\ntype Push = [...T, V]\n\ntype UnionToIntersection = (U extends any ? (k: U) => void : never) extends (\n k: infer I,\n) => void\n ? I\n : never\n\ntype LastOf =\n UnionToIntersection T : never> extends () => infer R\n ? R\n : never\n\ntype TuplifyUnion<\n T,\n L = LastOf,\n N = [T] extends [never] ? true : false,\n> = true extends N ? [] : Push>, L>\n\ntype RestrictedLenTuple> = Tuple<\n T,\n TuplifyUnion extends Tuple ? V : 0\n>\n\nconst VariantEnc: >>(\n inner: O,\n x?: RestrictedLenTuple | undefined,\n) => Encoder<\n Enum<{\n [K in keyof O]: EncoderType\n }>\n> & { inner: O } = (...args) => {\n const enc = OEnum.enc(...(args as [any, any]))\n return withInner((v: any) => enc({ tag: v.type, value: v.value }), args[0])\n}\n\nconst VariantDec: >>(\n inner: O,\n x?: RestrictedLenTuple | undefined,\n) => Decoder<\n Enum<{\n [K in keyof O]: DecoderType\n }>\n> & { inner: O } = (...args) => {\n const dec = OEnum.dec(...(args as [any]))\n return withInner((v: any) => {\n const { tag, value } = dec(v)\n return Enum(tag as any, value as any) as any\n }, args[0])\n}\n\nexport const Variant: {\n >>(\n inner: O,\n indexes?: RestrictedLenTuple | undefined,\n ): Codec<\n Enum<{\n [K in keyof O]: CodecType\n }>\n > & { inner: O }\n enc: >>(\n inner: O_1,\n x?: RestrictedLenTuple | undefined,\n ) => Encoder<\n Enum<{\n [K in keyof O_1]: EncoderType\n }>\n > & { inner: O_1 }\n dec: >>(\n inner: O_2,\n x?: RestrictedLenTuple | undefined,\n ) => Decoder<\n Enum<{\n [K in keyof O_2]: DecoderType\n }>\n > & { inner: O_2 }\n} = (inner, ...args) =>\n withInner(\n createCodec(\n VariantEnc(\n mapObject(inner, ([encoder]) => encoder) as any,\n ...(args as any[]),\n ),\n VariantDec(\n mapObject(inner, ([, decoder]) => decoder) as any,\n ...(args as any[]),\n ) as any,\n ),\n inner,\n ) as any\nVariant.enc = VariantEnc\nVariant.dec = VariantDec\n\nexport const ScaleEnum: {\n >>(\n inner: O,\n indexes?: RestrictedLenTuple | undefined,\n ): Codec<\n {\n [K in keyof O]: {\n tag: K\n value: CodecType\n }\n }[keyof O]\n > & { inner: O }\n enc: >>(\n inner: O_1,\n x?: RestrictedLenTuple | undefined,\n ) => Encoder<\n {\n [K_1 in keyof O_1]: {\n tag: K_1\n value: EncoderType\n }\n }[keyof O_1]\n > & { inner: O_1 }\n dec: >>(\n inner: O_2,\n x?: RestrictedLenTuple | undefined,\n ) => Decoder<\n {\n [K_2 in keyof O_2]: {\n tag: K_2\n value: DecoderType\n }\n }[keyof O_2]\n > & { inner: O_2 }\n} = (inner, ...args) => withInner(OEnum(inner, ...(args as any[])), inner)\nScaleEnum.enc = (inner, ...rest) =>\n withInner(OEnum.enc(inner, ...(rest as any[])), inner)\nScaleEnum.dec = (inner, ...rest) =>\n withInner(OEnum.dec(inner, ...(rest as any[])), inner)\n","import { mergeUint8 } from \"@pezkuwi/papi-utils\"\nimport { blake2b } from \"@noble/hashes/blake2.js\"\n\nconst len32 = { dkLen: 32 }\nexport const Blake2256 = (encoded: Uint8Array) => blake2b(encoded, len32)\n\nconst len16 = { dkLen: 16 }\nexport const Blake2128 = (encoded: Uint8Array) => blake2b(encoded, len16)\n\nexport const Blake2128Concat = (encoded: Uint8Array) =>\n mergeUint8([Blake2128(encoded), encoded])\n","import { mergeUint8 } from \"@pezkuwi/papi-utils\"\nimport { blake3 } from \"@noble/hashes/blake3.js\"\n\nconst len32 = { dkLen: 32 }\nexport const Blake3256 = (encoded: Uint8Array) => blake3(encoded, len32)\n\nexport const Blake3256Concat = (encoded: Uint8Array) =>\n mergeUint8([Blake3256(encoded), encoded])\n","export const Identity = (encoded: Uint8Array): Uint8Array => encoded\n","// Adapted implementation based on: https://github.com/pierrec/js-xxhash/blob/7ff5ced282f97dba121109d7013e0fa80360398c/lib/xxhash64.js\n\n// Distributed under the MIT software license, see the accompanying\n// file LICENSE or http://www.opensource.org/licenses/mit-license.php.\n\n// helper functions\nconst bigintFromU16 = (\n v0: number,\n v1: number,\n v2: number,\n v3: number,\n): bigint =>\n new DataView(new Uint16Array([v0, v1, v2, v3]).buffer).getBigUint64(0, true)\n\nconst MASK_64 = 2n ** 64n - 1n\n\nconst rotl = (input: bigint, nBits: bigint) =>\n ((input << nBits) & MASK_64) | (input >> (64n - nBits))\n\nconst multiply = (a: bigint, b: bigint) => (a * b) & MASK_64\n\nconst add = (a: bigint, b: bigint) => (a + b) & MASK_64\n\n// constants\nconst PRIME64_1 = 11400714785074694791n\nconst PRIME64_2 = 14029467366897019727n\nconst PRIME64_3 = 1609587929392839161n\nconst PRIME64_4 = 9650029242287828579n\nconst PRIME64_5 = 2870177450012600261n\n\nexport function h64(input: Uint8Array, seed: bigint = 0n) {\n let v1 = add(add(seed, PRIME64_1), PRIME64_2)\n let v2 = add(seed, PRIME64_2)\n let v3 = seed\n let v4 = seed - PRIME64_1\n let totalLen = input.length\n let memsize = 0\n let memory: Uint8Array | null = null\n\n ;(function update() {\n let p = 0\n let bEnd = p + totalLen\n\n if (!totalLen) return\n\n memory = new Uint8Array(32)\n\n if (totalLen < 32) {\n memory.set(input.subarray(0, totalLen), memsize)\n\n memsize += totalLen\n return\n }\n\n if (p <= bEnd - 32) {\n const limit = bEnd - 32\n\n do {\n let other\n other = bigintFromU16(\n (input[p + 1] << 8) | input[p],\n (input[p + 3] << 8) | input[p + 2],\n (input[p + 5] << 8) | input[p + 4],\n (input[p + 7] << 8) | input[p + 6],\n )\n v1 = multiply(rotl(add(v1, multiply(other, PRIME64_2)), 31n), PRIME64_1)\n p += 8\n other = bigintFromU16(\n (input[p + 1] << 8) | input[p],\n (input[p + 3] << 8) | input[p + 2],\n (input[p + 5] << 8) | input[p + 4],\n (input[p + 7] << 8) | input[p + 6],\n )\n\n v2 = multiply(rotl(add(v2, multiply(other, PRIME64_2)), 31n), PRIME64_1)\n p += 8\n other = bigintFromU16(\n (input[p + 1] << 8) | input[p],\n (input[p + 3] << 8) | input[p + 2],\n (input[p + 5] << 8) | input[p + 4],\n (input[p + 7] << 8) | input[p + 6],\n )\n\n v3 = multiply(rotl(add(v3, multiply(other, PRIME64_2)), 31n), PRIME64_1)\n p += 8\n other = bigintFromU16(\n (input[p + 1] << 8) | input[p],\n (input[p + 3] << 8) | input[p + 2],\n (input[p + 5] << 8) | input[p + 4],\n (input[p + 7] << 8) | input[p + 6],\n )\n v4 = multiply(rotl(add(v4, multiply(other, PRIME64_2)), 31n), PRIME64_1)\n p += 8\n } while (p <= limit)\n }\n\n if (p < bEnd) {\n memory.set(input.subarray(p, bEnd), memsize)\n memsize = bEnd - p\n }\n })()\n\n input = memory || input\n\n let result: bigint\n let p = 0\n\n if (totalLen >= 32) {\n result = rotl(v1, 1n)\n result = add(result, rotl(v2, 7n))\n result = add(result, rotl(v3, 12n))\n result = add(result, rotl(v4, 18n))\n\n v1 = multiply(rotl(multiply(v1, PRIME64_2), 31n), PRIME64_1)\n result = result ^ v1\n result = add(multiply(result, PRIME64_1), PRIME64_4)\n\n v2 = multiply(rotl(multiply(v2, PRIME64_2), 31n), PRIME64_1)\n result = result ^ v2\n result = add(multiply(result, PRIME64_1), PRIME64_4)\n\n v3 = multiply(rotl(multiply(v3, PRIME64_2), 31n), PRIME64_1)\n result = result ^ v3\n result = add(multiply(result, PRIME64_1), PRIME64_4)\n\n v4 = multiply(rotl(multiply(v4, PRIME64_2), 31n), PRIME64_1)\n result = result ^ v4\n result = add(multiply(result, PRIME64_1), PRIME64_4)\n } else {\n result = add(seed, PRIME64_5)\n }\n\n result = add(result, BigInt(totalLen))\n\n while (p <= memsize - 8) {\n let temp = bigintFromU16(\n (input[p + 1] << 8) | input[p],\n (input[p + 3] << 8) | input[p + 2],\n (input[p + 5] << 8) | input[p + 4],\n (input[p + 7] << 8) | input[p + 6],\n )\n temp = multiply(rotl(multiply(temp, PRIME64_2), 31n), PRIME64_1)\n result = add(multiply(rotl(result ^ temp, 27n), PRIME64_1), PRIME64_4)\n p += 8\n }\n\n if (p + 4 <= memsize) {\n let temp = multiply(\n bigintFromU16(\n (input[p + 1] << 8) | input[p],\n (input[p + 3] << 8) | input[p + 2],\n 0,\n 0,\n ),\n PRIME64_1,\n )\n\n result = add(multiply(rotl(result ^ temp, 23n), PRIME64_2), PRIME64_3)\n p += 4\n }\n\n while (p < memsize) {\n const temp = multiply(bigintFromU16(input[p++], 0, 0, 0), PRIME64_5)\n result = multiply(rotl(result ^ temp, 11n), PRIME64_1)\n }\n\n let temp = result >> 33n\n result = multiply(result ^ temp, PRIME64_2)\n\n temp = result >> 29n\n result = multiply(result ^ temp, PRIME64_3)\n\n temp = result >> 32n\n result ^= temp\n\n return result\n}\n","import { mergeUint8 } from \"@pezkuwi/papi-utils\"\nimport { u64 } from \"scale-ts\"\nimport { h64 } from \"./h64\"\n\nexport const Twox128 = (input: Uint8Array): Uint8Array => {\n const result = new Uint8Array(16)\n const dv = new DataView(result.buffer)\n\n dv.setBigUint64(0, h64(input), true)\n dv.setBigUint64(8, h64(input, 1n), true)\n\n return result\n}\n\nexport const Twox256 = (input: Uint8Array): Uint8Array => {\n const result = new Uint8Array(32)\n const dv = new DataView(result.buffer)\n\n dv.setBigUint64(0, h64(input), true)\n dv.setBigUint64(8, h64(input, 1n), true)\n dv.setBigUint64(16, h64(input, 2n), true)\n dv.setBigUint64(24, h64(input, 3n), true)\n\n return result\n}\n\nexport const Twox64Concat = (encoded: Uint8Array): Uint8Array =>\n mergeUint8([u64.enc(h64(encoded)), encoded])\n","import { keccak_256 } from \"@noble/hashes/sha3.js\"\n\nexport const Keccak256: (input: Uint8Array) => Uint8Array = keccak_256\n","import { fromHex, toHex } from \"@pezkuwi/papi-utils\"\nimport { Bytes, createCodec, createDecoder } from \"scale-ts\"\nimport { Keccak256 } from \"../../hashes\"\nimport { textEncoder } from \"./fixed-str\"\n\nconst getFormattedAddress = (hexAddress: string) => {\n const nonChecksum = hexAddress.slice(2)\n const hashedAddress = toHex(Keccak256(textEncoder.encode(nonChecksum))).slice(\n 2,\n )\n const result = new Array(40)\n\n for (let i = 0; i < 40; i++) {\n const checksumVal = parseInt(hashedAddress[i], 16)\n const char = nonChecksum[i]\n result[i] = checksumVal > 7 ? char.toUpperCase() : char\n }\n\n return `0x${result.join(\"\")}`\n}\n\nconst bytes20Dec = Bytes(20)[1]\n\nexport const ethAccount = createCodec(\n (input: string) => {\n const bytes = fromHex(input)\n if (bytes.length !== 20)\n throw new Error(`Invalid length found on EthAddress(${input})`)\n\n const hexAddress = toHex(bytes)\n if (input === hexAddress || input === hexAddress.toUpperCase()) return bytes\n\n if (getFormattedAddress(hexAddress) !== input)\n throw new Error(`Invalid checksum found on EthAddress(${input})`)\n\n return bytes\n },\n createDecoder((bytes) => getFormattedAddress(toHex(bytes20Dec(bytes)))),\n)\n","import {\n Struct as OStruct,\n Tuple as OTuple,\n Vector as OVector,\n Result as OResult,\n Option as OOption,\n Codec,\n Encoder,\n Decoder,\n StringRecord,\n CodecType,\n EncoderType,\n DecoderType,\n ResultPayload,\n} from \"scale-ts\"\nimport { withInner } from \"./with-inner\"\n\nexport const Struct: {\n >>(\n codecs: A,\n ): Codec<{ [K in keyof A]: CodecType }> & { inner: A }\n enc: >>(\n encoders: A_1,\n ) => Encoder<{ [K_1 in keyof A_1]: EncoderType }> & { inner: A_1 }\n dec: >>(\n decoders: A_2,\n ) => Decoder<{ [K_2 in keyof A_2]: DecoderType }> & { inner: A_2 }\n} = (codecs) => withInner(OStruct(codecs), codecs)\nStruct.enc = (x) => withInner(OStruct.enc(x), x)\nStruct.dec = (x) => withInner(OStruct.dec(x), x)\n\nexport const Tuple: {\n []>(\n ...inner: A\n ): Codec<{ [K in keyof A]: A[K] extends Codec ? D : unknown }> & {\n inner: A\n }\n enc: []>(\n ...encoders: A_1\n ) => Encoder<{\n [K_1 in keyof A_1]: A_1[K_1] extends Encoder ? D_1 : unknown\n }> & { inner: A_1 }\n dec: []>(\n ...decoders: A_2\n ) => Decoder<{\n [K_2 in keyof A_2]: A_2[K_2] extends Decoder ? D_2 : unknown\n }> & { inner: A_2 }\n} = (...inner) => withInner(OTuple(...inner), inner)\nTuple.enc = (...inner) => withInner(OTuple.enc(...inner), inner)\nTuple.dec = (...inner) => withInner(OTuple.dec(...inner), inner)\n\nexport const Vector: {\n (\n inner: Codec,\n size?: number | undefined,\n ): Codec & { inner: Codec }\n enc: (\n inner: Encoder,\n size?: number | undefined,\n ) => Encoder & { inner: Encoder }\n dec: (\n getter: Decoder,\n size?: number | undefined,\n ) => Decoder & { inner: Decoder }\n} = (inner, ...rest) => withInner(OVector(inner, ...rest), inner)\nVector.enc = (inner, ...rest) => withInner(OVector.enc(inner, ...rest), inner)\nVector.dec = (inner, ...rest) => withInner(OVector.dec(inner, ...rest), inner)\n\nexport const Result: {\n (\n okCodec: Codec,\n koCodec: Codec,\n ): Codec> & { inner: { ok: Codec; ko: Codec } }\n dec: (\n okDecoder: Decoder,\n koDecoder: Decoder,\n ) => Decoder> & {\n inner: { ok: Decoder; ko: Decoder }\n }\n enc: (\n okEncoder: Encoder,\n koEncoder: Encoder,\n ) => Encoder> & {\n inner: { ok: Encoder; ko: Encoder }\n }\n} = (ok, ko) => withInner(OResult(ok, ko), { ok, ko })\nResult.enc = (ok, ko) => withInner(OResult.enc(ok, ko), { ok, ko })\nResult.dec = (ok, ko) => withInner(OResult.dec(ok, ko), { ok, ko })\n\nexport const Option: {\n (inner: Codec): Codec & { inner: Codec }\n enc: (\n inner: Encoder,\n ) => Encoder & { inner: Encoder }\n dec: (\n inner: Decoder,\n ) => Decoder & { inner: Decoder }\n} = (inner) => withInner(OOption(inner), inner)\nOption.enc = (inner) => withInner(OOption.enc(inner), inner)\nOption.dec = (inner) => withInner(OOption.dec(inner), inner)\n","import {\n Bytes,\n Codec,\n Decoder,\n Encoder,\n createCodec,\n createDecoder,\n} from \"scale-ts\"\nimport { compactNumber } from \"./compact\"\nimport { mergeUint8 } from \"@pezkuwi/papi-utils\"\n\nexport type BitSeq = Array<0 | 1>\n\nconst dec: (isLsb?: boolean) => Decoder = (isLsb = true) =>\n createDecoder((data) => {\n const bitsLen = compactNumber.dec(data)\n const bytesLen = Math.ceil(bitsLen / 8)\n const bytes = Bytes(bytesLen).dec(data)\n\n const result = new Array<0 | 1>(bitsLen)\n let resultIdx = 0\n bytes.forEach((val) => {\n for (let i = 0; i < 8 && resultIdx < bitsLen; i++) {\n const actualIdx = isLsb ? i : 7 - i\n result[resultIdx++] = ((val >> actualIdx) & 1) as 1 | 0\n }\n })\n return result\n })\n\nconst enc: (isLsb?: boolean) => Encoder =\n (isLsb = true) =>\n (input) => {\n const lenEncoded = compactNumber.enc(input.length)\n const nBytes = Math.ceil(input.length / 8)\n\n const bytes = new Uint8Array(nBytes)\n for (let byteIdx = 0; byteIdx < nBytes; byteIdx++) {\n let inputIdx = byteIdx * 8\n let byte = 0\n for (let i = 0; i < 8 && inputIdx < input.length; i++, inputIdx++)\n byte |= input[inputIdx] << (isLsb ? i : 7 - i)\n bytes[byteIdx] = byte\n }\n\n return mergeUint8([lenEncoded, bytes])\n }\n\nexport const BitSeq = (isLsb?: boolean): Codec =>\n createCodec(enc(isLsb), dec(isLsb))\n\nBitSeq.enc = enc\nBitSeq.dec = dec\n","import {\n Bytes,\n CodecType,\n Struct,\n Vector,\n _void,\n enhanceCodec,\n Hex,\n Variant,\n compactNumber,\n} from \"./scale\"\n\nconst textEncoder = new TextEncoder()\nconst textDecoder = new TextDecoder()\n\nconst fourChars = enhanceCodec(\n Bytes(4),\n textEncoder.encode.bind(textEncoder),\n textDecoder.decode.bind(textDecoder),\n)\n\nconst diggestVal = Struct({\n engine: fourChars,\n payload: Hex(),\n})\n\nconst diggest = Variant(\n {\n other: Bytes(),\n consensus: diggestVal,\n seal: diggestVal,\n preRuntime: diggestVal,\n runtimeUpdated: _void,\n },\n [0, 4, 5, 6, 8],\n)\n\nconst hex32 = Hex(32)\nexport const blockHeader = Struct({\n parentHash: hex32,\n number: compactNumber,\n stateRoot: hex32,\n extrinsicRoot: hex32,\n digests: Vector(diggest),\n})\n\nexport type BlockHeader = CodecType\n","import { Vector, str } from \"scale-ts\"\n\nexport const docs = Vector(str)\n","import { compactNumber } from \"../scale/compact\"\nimport {\n CodecType,\n Enum,\n Option,\n Struct,\n Vector,\n _void,\n str,\n u32,\n u8,\n} from \"scale-ts\"\nimport { docs } from \"./docs\"\n\nconst oStr = Option(str)\n\nconst primitive = Enum({\n bool: _void,\n char: _void,\n str: _void,\n u8: _void,\n u16: _void,\n u32: _void,\n u64: _void,\n u128: _void,\n u256: _void,\n i8: _void,\n i16: _void,\n i32: _void,\n i64: _void,\n i128: _void,\n i256: _void,\n})\n\nconst fields = Vector(\n Struct({\n name: oStr,\n type: compactNumber,\n typeName: oStr,\n docs,\n }),\n)\n\nconst arr = Struct({\n len: u32,\n type: compactNumber,\n})\n\nconst bitSequence = Struct({\n bitStoreType: compactNumber,\n bitOrderType: compactNumber,\n})\n\nconst variant = Vector(\n Struct({\n name: str,\n fields,\n index: u8,\n docs,\n }),\n)\n\nconst def = Enum({\n composite: fields,\n variant,\n sequence: compactNumber,\n array: arr,\n tuple: Vector(compactNumber),\n primitive,\n compact: compactNumber,\n bitSequence,\n})\n\nconst param = Struct({\n name: str,\n type: Option(compactNumber),\n})\nconst params = Vector(param)\n\nconst entry = Struct({\n id: compactNumber,\n path: docs,\n params,\n def,\n docs,\n})\n\nexport const lookup = Vector(entry)\nexport type V14Lookup = CodecType\n","import { _void, Enum, Option, str, Struct, u8, Vector } from \"scale-ts\"\n\nexport const itemDeprecation = Enum({\n NotDeprecated: _void,\n DeprecatedWithoutNote: _void,\n Deprecated: Struct({\n note: str,\n since: Option(str),\n }),\n})\n\nexport const variantDeprecation = Vector(\n Struct({\n index: u8,\n deprecation: Enum(\n {\n DeprecatedWithoutNote: _void,\n Deprecated: Struct({\n note: str,\n since: Option(str),\n }),\n },\n [1, 2],\n ),\n }),\n)\n","import { Struct, Vector, str } from \"scale-ts\"\nimport { docs } from \"./docs\"\nimport { compactNumber, Hex, compactNumber as ty } from \"../scale\"\nimport { itemDeprecation } from \"./deprecation\"\n\nexport const runtimeApiMethod = {\n name: str,\n inputs: Vector(\n Struct({\n name: str,\n type: ty,\n }),\n ),\n output: ty,\n docs,\n}\n\nexport const runtimeApiV15 = Struct({\n name: str,\n methods: Vector(Struct(runtimeApiMethod)),\n docs,\n})\n\nexport const runtimeApi = Struct({\n name: str,\n methods: Vector(\n Struct({ ...runtimeApiMethod, deprecationInfo: itemDeprecation }),\n ),\n docs,\n version: compactNumber,\n deprecationInfo: itemDeprecation,\n})\n\nexport const viewFunction = Struct({\n id: Hex(32),\n ...runtimeApiMethod,\n deprecationInfo: itemDeprecation,\n})\n","import { Hex, compactNumber } from \"@/codecs/scale\"\nimport { Struct, Option, Vector, u8, str, Enum, _void } from \"scale-ts\"\nimport { docs } from \"./docs\"\nimport { itemDeprecation, variantDeprecation } from \"./deprecation\"\nimport { viewFunction } from \"./runtime-api\"\n\nconst hashType = Enum({\n Blake2128: _void,\n Blake2256: _void,\n Blake2128Concat: _void,\n Twox128: _void,\n Twox256: _void,\n Twox64Concat: _void,\n Identity: _void,\n})\n\nconst hashers = Vector(hashType)\n\nexport const storageMap = Struct({\n hashers,\n key: compactNumber,\n value: compactNumber,\n})\n\nconst storageItem = {\n name: str,\n modifier: u8,\n type: Enum({\n plain: compactNumber,\n map: storageMap,\n }),\n fallback: Hex(),\n docs,\n}\n\nconst enumRefV14 = Option(compactNumber)\n\nexport const v14Pallet = {\n name: str,\n storage: Option(\n Struct({\n prefix: str,\n items: Vector(Struct(storageItem)),\n }),\n ),\n calls: enumRefV14,\n events: enumRefV14,\n constants: Vector(\n Struct({\n name: str,\n type: compactNumber,\n value: Hex(),\n docs,\n }),\n ),\n errors: enumRefV14,\n index: u8,\n}\n\nexport const v15Pallet = {\n ...v14Pallet,\n docs,\n}\n\nconst enumRef = Option(\n Struct({ type: compactNumber, deprecationInfo: variantDeprecation }),\n)\n\nexport const v16Pallet = {\n name: str,\n storage: Option(\n Struct({\n prefix: str,\n items: Vector(\n Struct({\n ...storageItem,\n deprecationInfo: itemDeprecation,\n }),\n ),\n }),\n ),\n calls: enumRef,\n events: enumRef,\n constants: Vector(\n Struct({\n name: str,\n type: compactNumber,\n value: Hex(),\n docs,\n deprecationInfo: itemDeprecation,\n }),\n ),\n errors: enumRef,\n associatedTypes: Vector(\n Struct({\n name: str,\n type: compactNumber,\n docs,\n }),\n ),\n viewFns: Vector(viewFunction),\n index: u8,\n docs,\n deprecationInfo: itemDeprecation,\n}\n","import { CodecType, Struct, Vector, createCodec, str, u8 } from \"scale-ts\"\nimport { lookup } from \"./lookup\"\nimport { compactNumber } from \"../scale\"\nimport { v14Pallet } from \"./pallets\"\nimport { runtimeApi } from \"./runtime-api\"\n\nconst empty = new Uint8Array()\nconst Always = (value: T) =>\n createCodec(\n () => empty,\n () => value,\n )\n\nconst extrinsic = Struct({\n type: compactNumber,\n version: u8,\n signedExtensions: Vector(\n Struct({\n identifier: str,\n type: compactNumber,\n additionalSigned: compactNumber,\n }),\n ),\n})\n\nexport const v14 = Struct({\n lookup,\n pallets: Vector(Struct({ ...v14Pallet, docs: Always([] as string[]) })),\n extrinsic,\n type: compactNumber,\n apis: Always([] as Array>),\n})\nexport type V14 = CodecType\n","import { CodecType, Struct, Tuple, Vector, str, u8 } from \"scale-ts\"\nimport { lookup } from \"./lookup\"\nimport { v15Pallet } from \"./pallets\"\nimport { Hex, compactNumber as ty } from \"../scale\"\nimport { runtimeApiV15 } from \"./runtime-api\"\n\nconst extrinsic = Struct({\n version: u8,\n address: ty,\n call: ty,\n signature: ty,\n extra: ty,\n signedExtensions: Vector(\n Struct({\n identifier: str,\n type: ty,\n additionalSigned: ty,\n }),\n ),\n})\n\nexport const v15 = Struct({\n lookup,\n pallets: Vector(Struct(v15Pallet)),\n extrinsic,\n type: ty,\n apis: Vector(runtimeApiV15),\n outerEnums: Struct({\n call: ty,\n event: ty,\n error: ty,\n }),\n custom: Vector(Tuple(str, Struct({ type: ty, value: Hex() }))),\n})\nexport type V15 = CodecType\n","import { CodecType, Struct, Tuple, Vector, str, u8 } from \"scale-ts\"\nimport { lookup } from \"./lookup\"\nimport { v16Pallet } from \"./pallets\"\nimport { compactNumber, Hex, compactNumber as ty } from \"../scale\"\nimport { runtimeApi } from \"./runtime-api\"\n\nconst extrinsic = Struct({\n version: Vector(u8),\n address: ty,\n call: ty,\n signature: ty,\n signedExtensionsByVersion: Vector(Tuple(u8, Vector(compactNumber))),\n signedExtensions: Vector(\n Struct({\n identifier: str,\n type: ty,\n additionalSigned: ty,\n }),\n ),\n})\n\nexport const v16 = Struct({\n lookup,\n pallets: Vector(Struct(v16Pallet)),\n extrinsic,\n apis: Vector(runtimeApi),\n outerEnums: Struct({\n call: ty,\n event: ty,\n error: ty,\n }),\n custom: Vector(Tuple(str, Struct({ type: ty, value: Hex() }))),\n})\nexport type V16 = CodecType\n","import {\n Bytes,\n type Codec,\n type CodecType,\n Enum,\n Option,\n Struct,\n Tuple,\n compact,\n createCodec,\n u32,\n} from \"scale-ts\"\nimport type { HexString } from \"../scale\"\nimport { v14 } from \"./v14\"\nimport { v15 } from \"./v15\"\nimport { v16 } from \"./v16\"\n\nconst unsupportedFn = () => {\n throw new Error(\"Unsupported metadata version!\")\n}\n\nconst unsupported = createCodec(\n unsupportedFn,\n unsupportedFn,\n) as unknown as Codec\n\nexport const metadata = Struct({\n magicNumber: u32,\n metadata: Enum({\n v0: unsupported,\n v1: unsupported,\n v2: unsupported,\n v3: unsupported,\n v4: unsupported,\n v5: unsupported,\n v6: unsupported,\n v7: unsupported,\n v8: unsupported,\n v9: unsupported,\n v10: unsupported,\n v11: unsupported,\n v12: unsupported,\n v13: unsupported,\n v14,\n v15,\n v16,\n }),\n})\nexport type Metadata = CodecType\n\nconst opaqueBytes = Bytes()\nconst optionOpaque = Option(opaqueBytes)\nconst opaqueOpaqueBytes = Tuple(compact, opaqueBytes)\n\nexport const decAnyMetadata = (\n input: Uint8Array | HexString,\n): CodecType => {\n try {\n return metadata.dec(input)\n } catch (_) {}\n\n // comes from metadata.metadata_at_version\n try {\n return metadata.dec(optionOpaque.dec(input)!)\n } catch (_) {}\n\n // comes from state.getMetadata\n try {\n return metadata.dec(opaqueBytes.dec(input))\n } catch (_) {}\n\n // comes from metadata.metadata\n try {\n return metadata.dec(opaqueOpaqueBytes.dec(input)[1])\n } catch (_) {}\n\n throw null\n}\n","import { CodecType } from \"scale-ts\"\nimport { V14Lookup } from \"./lookup\"\nimport { storageMap } from \"./pallets\"\nimport { HexString } from \"../scale\"\nimport { itemDeprecation, variantDeprecation } from \"./deprecation\"\nimport { viewFunction } from \"./runtime-api\"\nimport { V14 } from \"./v14\"\nimport { V16 } from \"./v16\"\nimport { V15 } from \"./v15\"\nimport { Metadata } from \"./metadata\"\n\ntype EnumRef =\n | ({\n type: number\n } & (T extends 16\n ? { deprecationInfo: CodecType }\n : {}))\n | undefined\n\ntype DeprecationInfo = T extends 16\n ? { deprecationInfo: CodecType }\n : {}\n\nexport type UnifiedMetadata = {\n version: T\n lookup: V14Lookup\n pallets: Array<\n {\n name: string\n storage:\n | {\n prefix: string\n items: Array<\n {\n name: string\n modifier: number\n type:\n | { tag: \"plain\"; value: number }\n | { tag: \"map\"; value: CodecType }\n fallback: HexString\n docs: string[]\n } & DeprecationInfo\n >\n }\n | undefined\n calls: EnumRef\n events: EnumRef\n constants: Array<\n {\n name: string\n type: number\n value: HexString\n docs: string[]\n } & DeprecationInfo\n >\n errors: EnumRef\n associatedTypes: Array<{\n name: string\n type: number\n docs: string[]\n }>\n viewFns: Array>\n index: number\n docs: string[]\n } & DeprecationInfo\n >\n extrinsic: {\n version: number[]\n signedExtensions: Array<{\n identifier: string\n type: number\n additionalSigned: number\n }>\n } & (T extends 14\n ? {\n type: number\n }\n : { address: number; call: number; signature: number }) &\n (T extends 16\n ? { signedExtensionsByVersion: Array<[number, number[]]> }\n : {})\n apis: Array<\n {\n name: string\n methods: Array<\n {\n name: string\n inputs: Array<{ name: string; type: number }>\n output: number\n docs: string[]\n } & DeprecationInfo\n >\n docs: string[]\n } & (T extends 16 ? { version: number } : {}) &\n DeprecationInfo\n >\n} & (T extends 14\n ? {}\n : {\n outerEnums: { call: number; event: number; error: number }\n custom: Array<[string, { type: number; value: HexString }]>\n })\n\nexport const unifyMetadata = (\n metadata: Metadata | Metadata[\"metadata\"] | V14 | V15 | V16,\n): UnifiedMetadata => {\n // complete metadata\n if (\"magicNumber\" in metadata) metadata = metadata.metadata\n if (\"tag\" in metadata) {\n if (\n metadata.tag !== \"v14\" &&\n metadata.tag !== \"v15\" &&\n metadata.tag !== \"v16\"\n )\n throw new Error(\"Only metadata 14, 15, and 16 are supported\")\n metadata = metadata.value\n }\n\n // v16\n if (\"signedExtensionsByVersion\" in metadata.extrinsic) {\n return { version: 16, ...(metadata as V16) }\n }\n // v15\n if (\"custom\" in metadata) {\n const { lookup, extrinsic, custom, apis, pallets, outerEnums } =\n metadata as V15\n\n return {\n version: 15,\n lookup,\n pallets: pallets.map((p): UnifiedMetadata<15>[\"pallets\"][number] => ({\n ...p,\n calls: p.calls != null ? { type: p.calls } : undefined,\n events: p.events != null ? { type: p.events } : undefined,\n errors: p.errors != null ? { type: p.errors } : undefined,\n viewFns: [],\n associatedTypes: [],\n })),\n extrinsic: { ...extrinsic, version: [extrinsic.version] },\n apis,\n outerEnums,\n custom,\n }\n }\n // fallback, v14\n const { lookup, extrinsic, pallets } = metadata as V14\n return {\n version: 14,\n lookup,\n pallets: pallets.map((p): UnifiedMetadata<14>[\"pallets\"][number] => ({\n ...p,\n calls: p.calls != null ? { type: p.calls } : undefined,\n events: p.events != null ? { type: p.events } : undefined,\n errors: p.errors != null ? { type: p.errors } : undefined,\n viewFns: [],\n associatedTypes: [],\n })),\n extrinsic: { ...extrinsic, version: [extrinsic.version] },\n apis: [],\n }\n}\n","import { enhanceCodec, u8 } from \"scale-ts\"\n\nconst TYPES = {\n bare: 0b00,\n 0b00: \"bare\",\n general: 0b01,\n 0b01: \"general\",\n signed: 0b10,\n 0b10: \"signed\",\n} as const\n\nexport type ExtrinsicFormat =\n | { version: 4; type: \"bare\" | \"signed\" }\n | { version: 5; type: \"bare\" | \"general\" }\n\nexport const extrinsicFormat = enhanceCodec(\n u8,\n ({ version, type }) => version + (TYPES[type] << 6),\n (v) => {\n const version = v & 0x3f // 0b0011_1111\n const type = v >> 6\n if (version === 4 && (type === TYPES.bare || type === TYPES.signed))\n return { version, type: TYPES[type] }\n if (version === 5 && (type === TYPES.bare || type === TYPES.general))\n return { version, type: TYPES[type] }\n throw new Error(`ExtrinsicFormat ${v} not valid`)\n },\n)\n","import { fromHex, mergeUint8, toHex } from \"@pezkuwi/papi-utils\"\nimport type { Codec } from \"scale-ts\"\nimport {\n Blake2128,\n Blake2128Concat,\n Blake2256,\n Identity,\n Twox128,\n Twox256,\n Twox64Concat,\n} from \"./hashes\"\n\nexport type EncoderWithHash = [Codec, (input: Uint8Array) => Uint8Array]\n\nconst textEncoder = new TextEncoder()\n\n// the value indicates:\n// - when positive: the number of bytes to skip before reaching the transparent-encoded key\n// - when negative: the number of bytes that the opaque hasher will generate\nconst hashers: Map<(input: Uint8Array) => Uint8Array, number> = new Map([\n [Identity, 0],\n [Twox64Concat, 8],\n [Blake2128Concat, 16],\n [Blake2128, -16],\n [Blake2256, -32],\n [Twox128, -16],\n [Twox256, -32],\n])\n\nexport type OpaqueKeyHash = string & { __opaqueKeyHash?: unknown }\n\nexport const Storage = (pallet: string) => {\n const palledEncoded = Twox128(textEncoder.encode(pallet))\n return >>(\n name: string,\n ...encoders: [...A]\n ): {\n enc: (\n ...args: {\n [K in keyof A]: A[K] extends EncoderWithHash ? V : unknown\n }\n ) => string\n dec: (value: string) => {\n [K in keyof A]: A[K] extends EncoderWithHash ? V : unknown\n }\n } => {\n const palletItemEncoded = mergeUint8([\n palledEncoded,\n Twox128(textEncoder.encode(name)),\n ])\n\n const palletItemEncodedHex = toHex(palletItemEncoded)\n\n const dec = (\n key: string,\n ): {\n [K in keyof A]: A[K] extends EncoderWithHash ? V : unknown\n } => {\n if (!key.startsWith(palletItemEncodedHex))\n throw new Error(`key does not match this storage (${pallet}.${name})`)\n\n if (encoders.length === 0) return [] as any\n\n const argsKey = fromHex(key.slice(palletItemEncodedHex.length))\n const result = new Array(encoders.length)\n for (let i = 0, cur = 0; i < encoders.length; i++) {\n const [codec, hasher] = encoders[i]\n const hBytes = hashers.get(hasher)\n if (hBytes == null) throw new Error(\"Unknown hasher\")\n if (hBytes < 0) {\n const opaqueBytes = hBytes * -1\n result[i] = toHex(argsKey.slice(cur, cur + opaqueBytes))\n cur += opaqueBytes\n } else {\n cur += hBytes\n result[i] = codec.dec(argsKey.slice(cur))\n cur += codec.enc(result[i]).length\n }\n }\n return result as any\n }\n\n const fns = encoders.map(\n ([{ enc }, hash]) =>\n (val: any) =>\n hash(enc(val)),\n )\n\n const enc = (\n ...args: {\n [K in keyof A]: A[K] extends EncoderWithHash ? V : unknown\n }\n ): string =>\n toHex(\n mergeUint8([\n palletItemEncoded,\n ...args.map((val, idx) => fns[idx](val)),\n ]),\n )\n\n return {\n enc,\n dec,\n }\n }\n}\n","import { mergeUint8 } from \"@pezkuwi/papi-utils\"\nimport { Binary, compact, u16 } from \"../codecs\"\nimport { Blake2256 } from \"../hashes\"\n\nconst PREFIX = Binary.fromText(\"modlpy/utilisuba\").asBytes()\nexport const getMultisigAccountId = ({\n threshold,\n signatories,\n}: {\n threshold: number\n signatories: Uint8Array[]\n}) => {\n const sortedSignatories = sortMultisigSignatories(signatories)\n const payload = mergeUint8([\n PREFIX,\n compact.enc(sortedSignatories.length),\n ...sortedSignatories,\n u16.enc(threshold),\n ])\n return Blake2256(payload)\n}\n\nexport const sortMultisigSignatories = (signatories: Uint8Array[]) =>\n signatories.slice().sort((a, b) => {\n for (let i = 0; ; i++) {\n const overA = i >= a.length\n const overB = i >= b.length\n\n if (overA && overB) return 0\n else if (overA) return -1\n else if (overB) return 1\n else if (a[i] !== b[i]) return a[i] > b[i] ? 1 : -1\n }\n })\n","import { type HexString } from \"../codecs\"\n\nexport const TrieNodeHeaders = {\n Leaf: \"Leaf\",\n Branch: \"Branch\",\n BranchWithVal: \"BranchWithVal\",\n LeafWithHash: \"LeafWithHash\",\n BranchWithHash: \"BranchWithHash\",\n Empty: \"Empty\",\n Reserved: \"Reserved\",\n} as const\ntype TrieNodeHeaders = typeof TrieNodeHeaders\nexport type TrieNodeHeaderKey =\n (typeof TrieNodeHeaders)[keyof typeof TrieNodeHeaders]\n\nexport type Nibble =\n | \"0\"\n | \"1\"\n | \"2\"\n | \"3\"\n | \"4\"\n | \"5\"\n | \"6\"\n | \"7\"\n | \"8\"\n | \"9\"\n | \"a\"\n | \"b\"\n | \"c\"\n | \"d\"\n | \"e\"\n | \"f\"\n\nexport type TrieNode = { partialKey: string } & (\n | {\n type: TrieNodeHeaders[\"Empty\"] | TrieNodeHeaders[\"Reserved\"]\n }\n | {\n type: TrieNodeHeaders[\"Leaf\"] | TrieNodeHeaders[\"LeafWithHash\"]\n value: HexString\n }\n | ({ children: Record } & (\n | { type: TrieNodeHeaders[\"Branch\"] }\n | {\n type:\n | TrieNodeHeaders[\"BranchWithHash\"]\n | TrieNodeHeaders[\"BranchWithVal\"]\n value: HexString\n }\n ))\n)\nexport type ProofTrieNode = {\n hash: HexString\n parent?: HexString\n} & (TrieNode | { type: \"Raw\"; value: HexString })\n","import { createDecoder, Hex, u16, u8, type HexString } from \"../codecs\"\nimport { type TrieNodeHeaderKey, TrieNodeHeaders, type TrieNode } from \"./types\"\n\nconst varHex = Hex().dec\nconst allHex = Hex(Infinity).dec\nconst hex32 = Hex(32).dec\nconst byte = u8.dec\n\nconst getHeader = (\n bytes: Uint8Array,\n): { type: TrieNodeHeaderKey; partialKey: string } => {\n const firstByte = byte(bytes)\n\n let bitsLeft = 6\n const typeId = firstByte >> bitsLeft\n const type: TrieNodeHeaderKey = typeId\n ? typeId === 1\n ? TrieNodeHeaders.Leaf\n : typeId === 2\n ? TrieNodeHeaders.Branch\n : TrieNodeHeaders.BranchWithVal\n : firstByte >> --bitsLeft\n ? TrieNodeHeaders.LeafWithHash\n : firstByte >> --bitsLeft\n ? TrieNodeHeaders.BranchWithHash\n : firstByte\n ? TrieNodeHeaders.Reserved\n : TrieNodeHeaders.Empty\n\n let nNibles = firstByte & (0xff >> (8 - bitsLeft))\n if (nNibles === 2 ** bitsLeft - 1) {\n let current: number\n do nNibles += current = byte(bytes)\n while (current === 255)\n }\n\n return {\n type,\n partialKey: Hex(Math.ceil(nNibles / 2))\n .dec(bytes)\n .slice(nNibles % 2 ? 3 : 2),\n }\n}\n\nexport const trieNodeDec = createDecoder((bytes): TrieNode => {\n const header = getHeader(bytes)\n const { type } = header\n\n if (type === \"Empty\" || type === \"Reserved\") return header as TrieNode\n if (type === \"Leaf\" || type === \"LeafWithHash\")\n return {\n ...header,\n value: allHex(bytes),\n } as TrieNode\n\n const bitmap = u16.dec(bytes)\n const keys: string[] = []\n for (let i = 0; i < 16; i++) if ((bitmap >> i) & 1) keys.push(i.toString(16))\n\n let value: null | HexString = null\n if (type === \"BranchWithVal\") value = varHex(bytes)\n if (type === \"BranchWithHash\") value = hex32(bytes)\n\n const result: any = {\n ...header,\n children: Object.fromEntries(keys.map((key) => [key, varHex(bytes)])),\n }\n if (value !== null) result.value = value\n return result\n})\n","import { toHex } from \"@pezkuwi/papi-utils\"\nimport { createDecoder, type HexString } from \"../codecs\"\nimport { trieNodeDec } from \"./node-decoder\"\nimport { Blake2256 } from \"@/hashes\"\nimport { type ProofTrieNode } from \"./types\"\n\nexport const TrieNodeWithHash = (hasher: (input: Uint8Array) => Uint8Array) =>\n createDecoder((input): ProofTrieNode => {\n const hash = toHex(hasher(new Uint8Array(input.buffer)))\n try {\n return {\n hash,\n ...trieNodeDec(input),\n }\n } catch {\n // Sometimes the proofs include random raw-values which are not trie-nodes\n return { type: \"Raw\", hash, value: \"\" }\n }\n })\n\nexport const validateProofs = (\n proofs: Array,\n hasher: (input: Uint8Array) => Uint8Array = Blake2256,\n): { rootHash: HexString; proofs: Record } | null => {\n const proofsList = proofs.map(TrieNodeWithHash(hasher))\n const proofsRecord = Object.fromEntries(proofsList.map((p) => [p.hash, p]))\n const hashes = proofsList.map((p) => p.hash)\n const roots = new Set(hashes)\n\n const setRawValue = (input: {\n type: \"Raw\"\n hash: HexString\n value: HexString\n }) => {\n if (input.value) return\n const val = proofs[hashes.indexOf(input.hash)!]\n input.value = typeof val === \"string\" ? val : toHex(val)\n }\n\n proofsList.forEach((p) => {\n if (\"children\" in p) {\n Object.values(p.children).forEach((hash) => {\n const child = proofsRecord[hash]\n if (child) {\n child.parent = p.hash\n roots.delete(hash)\n }\n })\n }\n\n if (p.type === \"BranchWithHash\" || p.type === \"LeafWithHash\") {\n const childHash = p.value\n const child = proofsRecord[childHash]\n if (!child) return\n\n roots.delete(childHash)\n if (child.type !== \"Raw\") {\n Object.keys(child).forEach((k) => delete (child as any)[k])\n ;(child as any).type = \"Raw\"\n child.hash = childHash\n }\n child.parent = p.hash\n setRawValue(child as any)\n }\n\n if (p.type === \"Raw\") setRawValue(p)\n })\n\n return roots.size === 1\n ? { rootHash: roots.values().next().value!, proofs: proofsRecord }\n : null\n}\n"],"names":["base58","blake2b","enhanceCodec","Bytes","textEncoder","textDecoder","Tuple","compact","toHex","mergeUint8","fromHex","enc","dec","Bin","createCodec","createDecoder","bitSequence","u8","OEnum","mapObject","len32","blake3","p","temp","u64","keccak_256","OStruct","OTuple","OVector","OResult","OOption","_void","hex32","Vector","str","Option","Enum","Struct","u32","ty","hashers","extrinsic","lookup","pallets","u16"],"mappings":"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"} \ No newline at end of file diff --git a/packages/bizinikiwi-bindings/package.json b/packages/bizinikiwi-bindings/package.json new file mode 100644 index 0000000..33ea2ad --- /dev/null +++ b/packages/bizinikiwi-bindings/package.json @@ -0,0 +1,47 @@ +{ + "name": "@pezkuwi/bizinikiwi-bindings", + "version": "1.0.0", + "author": "Dijital Kurdistan Tech Institute ", + "bugs": "https://github.com/pezkuwichain/pezkuwi-api/issues", + "homepage": "https://github.com/pezkuwichain/pezkuwi-api/tree/master/packages/bizinikiwi-bindings#readme", + "repository": { + "directory": "packages/bizinikiwi-bindings", + "type": "git", + "url": "https://github.com/pezkuwichain/pezkuwi-api.git" + }, + "license": "MIT", + "sideEffects": false, + "type": "module", + "exports": { + ".": { + "node": { + "production": { + "import": "./dist/esm/index.mjs", + "require": "./dist/index.js", + "default": "./dist/index.js" + }, + "import": "./dist/esm/index.mjs", + "require": "./dist/index.js", + "default": "./dist/index.js" + }, + "module": "./dist/esm/index.mjs", + "import": "./dist/esm/index.mjs", + "require": "./dist/index.js", + "default": "./dist/index.js" + }, + "./package.json": "./package.json" + }, + "main": "./dist/index.js", + "module": "./dist/esm/index.mjs", + "browser": "./dist/esm/index.mjs", + "types": "./dist/index.d.ts", + "files": [ + "dist" + ], + "dependencies": { + "@noble/hashes": "^2.0.1", + "@scure/base": "^2.0.0", + "scale-ts": "^1.6.1", + "@pezkuwi/papi-utils": "1.0.0" + } +} diff --git a/packages/merkleize-metadata/LICENSE b/packages/merkleize-metadata/LICENSE new file mode 100644 index 0000000..e7c9b1a --- /dev/null +++ b/packages/merkleize-metadata/LICENSE @@ -0,0 +1,21 @@ +MIT License + +Copyright (c) 2023 Josep M Sobrepere + +Permission is hereby granted, free of charge, to any person obtaining a copy +of this software and associated documentation files (the "Software"), to deal +in the Software without restriction, including without limitation the rights +to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +copies of the Software, and to permit persons to whom the Software is +furnished to do so, subject to the following conditions: + +The above copyright notice and this permission notice shall be included in all +copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +SOFTWARE. diff --git a/packages/merkleize-metadata/README.md b/packages/merkleize-metadata/README.md new file mode 100644 index 0000000..d5ade61 --- /dev/null +++ b/packages/merkleize-metadata/README.md @@ -0,0 +1,46 @@ +# @polkadot-api/merkleize-metadata + +This TS package provides utils for the merkleization of [`frame_metadata`](https://docs.rs/frame-metadata/latest/frame_metadata/) as described in +[RFC78](https://polkadot-fellows.github.io/RFCs/approved/0078-merkleized-metadata.html). + +## Usage + +```ts +import { merkleizeMetadata } from "@polkadot-api/merkleized-metadata" + +const ksmMetadata = new Uint8Array(await readFile("ksm.bin")) +const merkleizedMetadata = merkleizeMetadata(ksmMetadata, { + decimals: 12, + tokenSymbol: "KSM", +}) + +// it returns the digest value of the metadata (aka its merkleized root-hash) +const rootHash = merkleizedMetadata.digest() + +// given an extrinsic, it returns an encoded `Proof` +const proof1: Uint8Array = merkleizedMetadata.getProofForExtrinsic( + // Hex for the transaction bytes + "c10184008eaf04151687736326c9fea17e25fc5287613693c912909cb226aa4794f26a4801127d333c8f60c0d81dd0a6e2e20ea477a06f96aaca1811872c54c244f0935c60b1f8a38aabef3d3a4ef4050d8d078e35b57b3cf4f9545f8145ce98afb8755384550000000000001448656c6c6f", + // Optionally, we can pass the tx additional signed data + "386d0f001a000000143c3561eefac7bc66facd4f0a7ec31d33b64f1827932fb3fda0ce361def535f143c3561eefac7bc66facd4f0a7ec31d33b64f1827932fb3fda0ce361def535f00", +) + +// given the extrinsic "parts", it returns an encoded `Proof` +const proof2: Uint8Array = merkleizedMetadata.getProofForExtrinsicParts( + // Call data + "0x040300648ad065ea416ca1725c29979cd41e288180f3e8aefde705cd3e0bab6cd212010bcb04fb711f01", + // Signed Extension data included in the extrinsic + "0x2503000000", + // Signed Extension data included in the signature + "0x164a0f001a000000b0a8d493285c2df73290dfb7e61f870f17b41801197a149ca93654499ea3dafe878a023bcb37967b6ba0685d002bb74e6cf3b4fc4ae37eb85f756bd9b026bede00", +) + +// The type `Proof` definition is as follows: +// interface Proof { +// leaves: Array, +// leafIdxs: Array, +// proofs: Array, +// extrinsic: ExtrinsicMetadata, +// info: ExtraInfo +// } +``` diff --git a/packages/merkleize-metadata/dist/esm/codecs.mjs b/packages/merkleize-metadata/dist/esm/codecs.mjs new file mode 100644 index 0000000..0fa9c46 --- /dev/null +++ b/packages/merkleize-metadata/dist/esm/codecs.mjs @@ -0,0 +1,118 @@ +import { Struct, str, u8, u16, u32, Bytes, ScaleEnum, _void, compactNumber, Option, Vector, bool, Tuple, compact, extrinsicFormat } from '@pezkuwi/bizinikiwi-bindings'; + +const extraInfoInner = { + specVersion: u32, + specName: str, + base58Prefix: u16, + decimals: u8, + tokenSymbol: str +}; +const extraInfo = Struct(extraInfoInner); +const hash = Bytes(32); +const metadataDigest = ScaleEnum({ + V0: _void, + V1: Struct({ + typeInformationTreeRoot: hash, + extrinsicMetadataHash: hash, + ...extraInfoInner + }) +}); +ScaleEnum({ + bool: _void, + char: _void, + str: _void, + u8: _void, + u16: _void, + u32: _void, + u64: _void, + u128: _void, + u256: _void, + i8: _void, + i16: _void, + i32: _void, + i64: _void, + i128: _void, + i256: _void +}); +const typeRef = ScaleEnum({ + bool: _void, + char: _void, + str: _void, + u8: _void, + u16: _void, + u32: _void, + u64: _void, + u128: _void, + u256: _void, + i8: _void, + i16: _void, + i32: _void, + i64: _void, + i128: _void, + i256: _void, + compactU8: _void, + compactU16: _void, + compactU32: _void, + compactU64: _void, + compactU128: _void, + compactU256: _void, + void: _void, + perId: compactNumber +}); +const field = Struct({ + name: Option(str), + ty: typeRef, + typeName: Option(str) +}); +const typeDef = ScaleEnum({ + composite: Vector(field), + enumeration: Struct({ + name: str, + fields: Vector(field), + index: compactNumber + }), + sequence: typeRef, + array: Struct({ + len: u32, + typeParam: typeRef + }), + tuple: Vector(typeRef), + bitSequence: Struct({ + numBytes: u8, + leastSignificantBitFirst: bool + }) +}); +const lookupType = Struct({ + path: Vector(str), + typeDef, + typeId: compactNumber +}); +const lookup = Vector(lookupType); +const extrinsicMetadata = Struct({ + version: u8, + addressTy: typeRef, + callTy: typeRef, + signatureTy: typeRef, + signedExtensions: Vector( + Struct({ + identifier: str, + includedInExtrinsic: typeRef, + includedInSignedData: typeRef + }) + ) +}); +const extrinsicDec = Tuple.dec( + compact[1], + extrinsicFormat[1], + Bytes(Infinity)[1] +); +const proof = Struct({ + leaves: lookup, + leafIdxs: Vector(u32), + proofs: Vector(hash), + extrinsic: extrinsicMetadata, + info: extraInfo +}); + +export { extraInfo, extrinsicDec, extrinsicMetadata, hash, lookup, lookupType, metadataDigest, proof, typeDef, typeRef }; +//# sourceMappingURL=codecs.mjs.map diff --git a/packages/merkleize-metadata/dist/esm/codecs.mjs.map b/packages/merkleize-metadata/dist/esm/codecs.mjs.map new file mode 100644 index 0000000..931017f --- /dev/null +++ b/packages/merkleize-metadata/dist/esm/codecs.mjs.map @@ -0,0 +1 @@ +{"version":3,"file":"codecs.mjs","sources":["../../src/codecs.ts"],"sourcesContent":["import {\n Bytes,\n Codec,\n CodecType,\n Option,\n ScaleEnum,\n Struct,\n Tuple,\n V14Lookup,\n Vector,\n _void,\n bool,\n compact,\n compactNumber,\n extrinsicFormat,\n str,\n u16,\n u32,\n u8,\n} from \"@pezkuwi/bizinikiwi-bindings\"\n\nconst extraInfoInner = {\n specVersion: u32,\n specName: str,\n base58Prefix: u16,\n decimals: u8,\n tokenSymbol: str,\n}\nexport const extraInfo = Struct(extraInfoInner)\nexport type ExtraInfo = CodecType\n\nexport const hash = Bytes(32)\nexport const metadataDigest = ScaleEnum({\n V0: _void,\n V1: Struct({\n typeInformationTreeRoot: hash,\n extrinsicMetadataHash: hash,\n ...extraInfoInner,\n }),\n})\nexport type MetadataDigest = CodecType\n\nexport const scalePrimitive = ScaleEnum({\n bool: _void,\n char: _void,\n str: _void,\n u8: _void,\n u16: _void,\n u32: _void,\n u64: _void,\n u128: _void,\n u256: _void,\n i8: _void,\n i16: _void,\n i32: _void,\n i64: _void,\n i128: _void,\n i256: _void,\n})\nexport type ScalePrimitive = CodecType\n\nexport const typeRef = ScaleEnum({\n bool: _void,\n char: _void,\n str: _void,\n u8: _void,\n u16: _void,\n u32: _void,\n u64: _void,\n u128: _void,\n u256: _void,\n i8: _void,\n i16: _void,\n i32: _void,\n i64: _void,\n i128: _void,\n i256: _void,\n compactU8: _void,\n compactU16: _void,\n compactU32: _void,\n compactU64: _void,\n compactU128: _void,\n compactU256: _void,\n void: _void,\n perId: compactNumber,\n})\nexport type TypeRef = CodecType\n\nconst field = Struct({\n name: Option(str),\n ty: typeRef,\n typeName: Option(str),\n})\nexport const typeDef = ScaleEnum({\n composite: Vector(field),\n enumeration: Struct({\n name: str,\n fields: Vector(field),\n index: compactNumber,\n }),\n sequence: typeRef,\n array: Struct({\n len: u32,\n typeParam: typeRef,\n }),\n tuple: Vector(typeRef),\n bitSequence: Struct({\n numBytes: u8,\n leastSignificantBitFirst: bool,\n }),\n})\nexport type TypeDef = CodecType\n\nexport const lookupType = Struct({\n path: Vector(str),\n typeDef: typeDef,\n typeId: compactNumber,\n})\nexport type LookupEntry = CodecType\nexport type Lookup = Array\nexport const lookup: Codec = Vector(lookupType)\n\nexport const extrinsicMetadata = Struct({\n version: u8,\n addressTy: typeRef,\n callTy: typeRef,\n signatureTy: typeRef,\n signedExtensions: Vector(\n Struct({\n identifier: str,\n includedInExtrinsic: typeRef,\n includedInSignedData: typeRef,\n }),\n ),\n})\nexport type ExtrinsicMetadata = CodecType\nexport type LookupValue = V14Lookup[number]\n\nexport const extrinsicDec = Tuple.dec(\n compact[1],\n extrinsicFormat[1],\n Bytes(Infinity)[1],\n)\n\nexport const proof = Struct({\n leaves: lookup,\n leafIdxs: Vector(u32),\n proofs: Vector(hash),\n extrinsic: extrinsicMetadata,\n info: extraInfo,\n})\nexport type Proof = CodecType\n"],"names":[],"mappings":"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"} \ No newline at end of file diff --git a/packages/merkleize-metadata/dist/esm/decode-and-collect.mjs b/packages/merkleize-metadata/dist/esm/decode-and-collect.mjs new file mode 100644 index 0000000..ec3b80f --- /dev/null +++ b/packages/merkleize-metadata/dist/esm/decode-and-collect.mjs @@ -0,0 +1,94 @@ +import { createDecoder, compact, _void, i256, i128, i64, i32, i16, i8, u256, u128, u64, u32, u16, u8, str } from '@pezkuwi/bizinikiwi-bindings'; + +const typeRefDecoders = { + bool: u8, + char: u8, + str, + u8, + u16, + u32, + u64, + u128, + u256, + i8, + i16, + i32, + i64, + i128, + i256, + void: _void, + compactU8: compact, + compactU16: compact, + compactU32: compact, + compactU64: compact, + compactU128: compact, + compactU256: compact +}; +const innerDecodeAndCollect = (input, typeRef, idToLookups, lookup, collected) => { + if (typeRef.tag !== "perId") { + typeRefDecoders[typeRef.tag][1](input); + return; + } + const handleTypeRef = (typeRef2) => { + innerDecodeAndCollect(input, typeRef2, idToLookups, lookup, collected); + }; + const lookupIdxs = idToLookups.get(typeRef.value); + const [currentIdx] = lookupIdxs; + const current = lookup[currentIdx]; + if (lookupIdxs.length === 1) collected.add(currentIdx); + switch (current.typeDef.tag) { + case "enumeration": { + const selectedIdx = u8.dec(input); + const [selected, collectedIdx] = lookupIdxs.map( + (lookupIdx) => [lookup[lookupIdx].typeDef, lookupIdx] + ).find(([x]) => x.value.index === selectedIdx); + collected.add(collectedIdx); + selected.value.fields.forEach(({ ty }) => { + handleTypeRef(ty); + }); + break; + } + case "sequence": { + const len = compact.dec(input); + for (let i = 0; i < len; i++) handleTypeRef(current.typeDef.value); + break; + } + case "array": { + for (let i = 0; i < current.typeDef.value.len; i++) + handleTypeRef(current.typeDef.value.typeParam); + break; + } + case "composite": { + current.typeDef.value.forEach((x) => { + handleTypeRef(x.ty); + }); + break; + } + case "tuple": { + current.typeDef.value.forEach(handleTypeRef); + break; + } + case "bitSequence": + throw new Error("bitSequence is not supported"); + } +}; +const decodeAndCollectKnownLeafs = (data, typeRefs, lookup) => { + let input = new Uint8Array(); + createDecoder((_input) => { + input = _input; + })(data); + const idToLookups = /* @__PURE__ */ new Map(); + lookup.forEach((lookup2, idx) => { + const arr = idToLookups.get(lookup2.typeId); + if (arr) arr.push(idx); + else idToLookups.set(lookup2.typeId, [idx]); + }); + const result = /* @__PURE__ */ new Set(); + typeRefs.forEach((typeRef) => { + innerDecodeAndCollect(input, typeRef, idToLookups, lookup, result); + }); + return [...result].sort((a, b) => a - b); +}; + +export { decodeAndCollectKnownLeafs }; +//# sourceMappingURL=decode-and-collect.mjs.map diff --git a/packages/merkleize-metadata/dist/esm/decode-and-collect.mjs.map b/packages/merkleize-metadata/dist/esm/decode-and-collect.mjs.map new file mode 100644 index 0000000..38d3f19 --- /dev/null +++ b/packages/merkleize-metadata/dist/esm/decode-and-collect.mjs.map @@ -0,0 +1 @@ +{"version":3,"file":"decode-and-collect.mjs","sources":["../../src/decode-and-collect.ts"],"sourcesContent":["import {\n HexString,\n _void,\n compact,\n createDecoder,\n i128,\n i16,\n i256,\n i32,\n i64,\n i8,\n str,\n u128,\n u16,\n u256,\n u32,\n u64,\n u8,\n} from \"@pezkuwi/bizinikiwi-bindings\"\nimport { Lookup, TypeDef, TypeRef } from \"./codecs\"\n\nconst typeRefDecoders = {\n bool: u8,\n char: u8,\n str,\n u8,\n u16,\n u32,\n u64,\n u128,\n u256,\n i8,\n i16,\n i32,\n i64,\n i128,\n i256,\n void: _void,\n compactU8: compact,\n compactU16: compact,\n compactU32: compact,\n compactU64: compact,\n compactU128: compact,\n compactU256: compact,\n}\n\nconst innerDecodeAndCollect = (\n input: Uint8Array,\n typeRef: TypeRef,\n idToLookups: Map>,\n lookup: Lookup,\n collected: Set,\n) => {\n if (typeRef.tag !== \"perId\") {\n typeRefDecoders[typeRef.tag][1](input)\n return\n }\n\n const handleTypeRef = (typeRef: TypeRef) => {\n innerDecodeAndCollect(input, typeRef, idToLookups, lookup, collected)\n }\n\n const lookupIdxs = idToLookups.get(typeRef.value)!\n const [currentIdx] = lookupIdxs\n const current = lookup[currentIdx]\n\n if (lookupIdxs.length === 1) collected.add(currentIdx)\n\n switch (current.typeDef.tag) {\n case \"enumeration\": {\n const selectedIdx = u8.dec(input)\n const [selected, collectedIdx] = lookupIdxs\n .map(\n (lookupIdx) =>\n [lookup[lookupIdx].typeDef, lookupIdx] as [\n TypeDef & { tag: \"enumeration\" },\n number,\n ],\n )\n .find(([x]) => x.value.index === selectedIdx)!\n collected.add(collectedIdx)\n selected.value.fields.forEach(({ ty }) => {\n handleTypeRef(ty)\n })\n break\n }\n case \"sequence\": {\n const len = compact.dec(input)\n for (let i = 0; i < len; i++) handleTypeRef(current.typeDef.value)\n break\n }\n case \"array\": {\n for (let i = 0; i < current.typeDef.value.len; i++)\n handleTypeRef(current.typeDef.value.typeParam)\n break\n }\n case \"composite\": {\n current.typeDef.value.forEach((x) => {\n handleTypeRef(x.ty)\n })\n break\n }\n case \"tuple\": {\n current.typeDef.value.forEach(handleTypeRef)\n break\n }\n case \"bitSequence\":\n throw new Error(\"bitSequence is not supported\")\n }\n}\n\nexport const decodeAndCollectKnownLeafs = (\n data: Uint8Array | HexString,\n typeRefs: Array,\n lookup: Lookup,\n): Array => {\n let input: Uint8Array = new Uint8Array()\n createDecoder((_input) => {\n input = _input\n })(data)\n\n const idToLookups = new Map()\n lookup.forEach((lookup, idx) => {\n const arr = idToLookups.get(lookup.typeId)\n if (arr) arr.push(idx)\n else idToLookups.set(lookup.typeId, [idx])\n })\n\n const result = new Set()\n typeRefs.forEach((typeRef) => {\n innerDecodeAndCollect(input, typeRef, idToLookups, lookup, result)\n })\n\n return [...result].sort((a, b) => a - b)\n}\n"],"names":["typeRef","lookup"],"mappings":"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"} \ No newline at end of file diff --git a/packages/merkleize-metadata/dist/esm/get-accessible-types.mjs b/packages/merkleize-metadata/dist/esm/get-accessible-types.mjs new file mode 100644 index 0000000..6c24e91 --- /dev/null +++ b/packages/merkleize-metadata/dist/esm/get-accessible-types.mjs @@ -0,0 +1,52 @@ +const getAccessibleTypes = (metadata, definitions) => { + const types = /* @__PURE__ */ new Set(); + const collectTypesFromId = (id) => { + if (types.has(id)) return; + const { tag, value } = definitions.get(id).def; + switch (tag) { + case "composite": + if (!value.length) break; + types.add(id); + value.forEach(({ type }) => { + collectTypesFromId(type); + }); + break; + case "variant": + if (!value.length) break; + types.add(id); + value.forEach(({ fields }) => { + fields.forEach(({ type }) => { + collectTypesFromId(type); + }); + }); + break; + case "tuple": + if (!value.length) break; + types.add(id); + value.forEach(collectTypesFromId); + break; + case "sequence": + types.add(id); + collectTypesFromId(value); + break; + case "array": + types.add(id); + collectTypesFromId(value.type); + break; + case "bitSequence": + types.add(id); + } + }; + collectTypesFromId(metadata.extrinsic.call); + collectTypesFromId(metadata.extrinsic.address); + collectTypesFromId(metadata.extrinsic.signature); + metadata.extrinsic.signedExtensions.forEach(({ type, additionalSigned }) => { + collectTypesFromId(type); + collectTypesFromId(additionalSigned); + }); + const sortedTypes = [...types].sort((a, b) => a - b); + return new Map(sortedTypes.map((value, idx) => [value, idx])); +}; + +export { getAccessibleTypes }; +//# sourceMappingURL=get-accessible-types.mjs.map diff --git a/packages/merkleize-metadata/dist/esm/get-accessible-types.mjs.map b/packages/merkleize-metadata/dist/esm/get-accessible-types.mjs.map new file mode 100644 index 0000000..5c83c01 --- /dev/null +++ b/packages/merkleize-metadata/dist/esm/get-accessible-types.mjs.map @@ -0,0 +1 @@ +{"version":3,"file":"get-accessible-types.mjs","sources":["../../src/get-accessible-types.ts"],"sourcesContent":["import { UnifiedMetadata } from \"@pezkuwi/bizinikiwi-bindings\"\nimport { LookupValue } from \"./codecs\"\n\nexport const getAccessibleTypes = (\n metadata: UnifiedMetadata<15 | 16>,\n definitions: Map,\n): Map => {\n const types = new Set()\n\n const collectTypesFromId = (id: number) => {\n if (types.has(id)) return\n\n const { tag, value } = definitions.get(id)!.def\n switch (tag) {\n case \"composite\":\n if (!value.length) break\n types.add(id)\n value.forEach(({ type }) => {\n collectTypesFromId(type)\n })\n break\n case \"variant\":\n if (!value.length) break\n types.add(id)\n value.forEach(({ fields }) => {\n fields.forEach(({ type }) => {\n collectTypesFromId(type)\n })\n })\n break\n case \"tuple\":\n if (!value.length) break\n types.add(id)\n value.forEach(collectTypesFromId)\n break\n case \"sequence\":\n types.add(id)\n collectTypesFromId(value)\n break\n case \"array\":\n types.add(id)\n collectTypesFromId(value.type)\n break\n case \"bitSequence\": // bitSequence inner types are not stored\n types.add(id)\n // primitive and compact are not stored\n }\n }\n\n collectTypesFromId(metadata.extrinsic.call)\n collectTypesFromId(metadata.extrinsic.address)\n collectTypesFromId(metadata.extrinsic.signature)\n metadata.extrinsic.signedExtensions.forEach(({ type, additionalSigned }) => {\n collectTypesFromId(type)\n collectTypesFromId(additionalSigned)\n })\n\n const sortedTypes = [...types].sort((a, b) => a - b)\n return new Map(sortedTypes.map((value, idx) => [value, idx]))\n}\n"],"names":[],"mappings":"AAGO,MAAM,kBAAA,GAAqB,CAChC,QAAA,EACA,WAAA,KACwB;AACxB,EAAA,MAAM,KAAA,uBAAY,GAAA,EAAY;AAE9B,EAAA,MAAM,kBAAA,GAAqB,CAAC,EAAA,KAAe;AACzC,IAAA,IAAI,KAAA,CAAM,GAAA,CAAI,EAAE,CAAA,EAAG;AAEnB,IAAA,MAAM,EAAE,GAAA,EAAK,KAAA,KAAU,WAAA,CAAY,GAAA,CAAI,EAAE,CAAA,CAAG,GAAA;AAC5C,IAAA,QAAQ,GAAA;AAAK,MACX,KAAK,WAAA;AACH,QAAA,IAAI,CAAC,MAAM,MAAA,EAAQ;AACnB,QAAA,KAAA,CAAM,IAAI,EAAE,CAAA;AACZ,QAAA,KAAA,CAAM,OAAA,CAAQ,CAAC,EAAE,IAAA,EAAK,KAAM;AAC1B,UAAA,kBAAA,CAAmB,IAAI,CAAA;AAAA,QACzB,CAAC,CAAA;AACD,QAAA;AAAA,MACF,KAAK,SAAA;AACH,QAAA,IAAI,CAAC,MAAM,MAAA,EAAQ;AACnB,QAAA,KAAA,CAAM,IAAI,EAAE,CAAA;AACZ,QAAA,KAAA,CAAM,OAAA,CAAQ,CAAC,EAAE,MAAA,EAAO,KAAM;AAC5B,UAAA,MAAA,CAAO,OAAA,CAAQ,CAAC,EAAE,IAAA,EAAK,KAAM;AAC3B,YAAA,kBAAA,CAAmB,IAAI,CAAA;AAAA,UACzB,CAAC,CAAA;AAAA,QACH,CAAC,CAAA;AACD,QAAA;AAAA,MACF,KAAK,OAAA;AACH,QAAA,IAAI,CAAC,MAAM,MAAA,EAAQ;AACnB,QAAA,KAAA,CAAM,IAAI,EAAE,CAAA;AACZ,QAAA,KAAA,CAAM,QAAQ,kBAAkB,CAAA;AAChC,QAAA;AAAA,MACF,KAAK,UAAA;AACH,QAAA,KAAA,CAAM,IAAI,EAAE,CAAA;AACZ,QAAA,kBAAA,CAAmB,KAAK,CAAA;AACxB,QAAA;AAAA,MACF,KAAK,OAAA;AACH,QAAA,KAAA,CAAM,IAAI,EAAE,CAAA;AACZ,QAAA,kBAAA,CAAmB,MAAM,IAAI,CAAA;AAC7B,QAAA;AAAA,MACF,KAAK,aAAA;AACH,QAAA,KAAA,CAAM,IAAI,EAAE,CAAA;AAAA;AAEhB,EACF,CAAA;AAEA,EAAA,kBAAA,CAAmB,QAAA,CAAS,UAAU,IAAI,CAAA;AAC1C,EAAA,kBAAA,CAAmB,QAAA,CAAS,UAAU,OAAO,CAAA;AAC7C,EAAA,kBAAA,CAAmB,QAAA,CAAS,UAAU,SAAS,CAAA;AAC/C,EAAA,QAAA,CAAS,UAAU,gBAAA,CAAiB,OAAA,CAAQ,CAAC,EAAE,IAAA,EAAM,kBAAiB,KAAM;AAC1E,IAAA,kBAAA,CAAmB,IAAI,CAAA;AACvB,IAAA,kBAAA,CAAmB,gBAAgB,CAAA;AAAA,EACrC,CAAC,CAAA;AAED,EAAA,MAAM,WAAA,GAAc,CAAC,GAAG,KAAK,CAAA,CAAE,KAAK,CAAC,CAAA,EAAG,CAAA,KAAM,CAAA,GAAI,CAAC,CAAA;AACnD,EAAA,OAAO,IAAI,GAAA,CAAI,WAAA,CAAY,GAAA,CAAI,CAAC,KAAA,EAAO,GAAA,KAAQ,CAAC,KAAA,EAAO,GAAG,CAAC,CAAC,CAAA;AAC9D;;;;"} \ No newline at end of file diff --git a/packages/merkleize-metadata/dist/esm/get-lookup.mjs b/packages/merkleize-metadata/dist/esm/get-lookup.mjs new file mode 100644 index 0000000..a38c516 --- /dev/null +++ b/packages/merkleize-metadata/dist/esm/get-lookup.mjs @@ -0,0 +1,103 @@ +const bitSequenceBytes = { + u8: 1, + u16: 2, + u32: 4, + u64: 8 +}; +const constructTypeDef = (definitions, getTypeRef, getPrimitive, frameId) => { + const { + def: { tag, value } + } = definitions.get(frameId); + switch (tag) { + case "composite": + return [ + { + tag, + value: value.map((f) => ({ + name: f.name, + typeName: f.typeName, + ty: getTypeRef(f.type) + })) + } + ]; + case "variant": { + return value.map((v) => ({ + tag: "enumeration", + value: { + name: v.name, + index: v.index, + fields: v.fields.map((f) => ({ + name: f.name, + typeName: f.typeName, + ty: getTypeRef(f.type) + })) + } + })); + } + case "sequence": + return [ + { + tag, + value: getTypeRef(value) + } + ]; + case "array": + return [ + { + tag, + value: { + len: value.len, + typeParam: getTypeRef(value.type) + } + } + ]; + case "tuple": + return [ + { + tag, + value: value.map(getTypeRef) + } + ]; + case "bitSequence": { + const primitive = getPrimitive(value.bitStoreType); + const numBytes = bitSequenceBytes[primitive]; + if (!numBytes) throw new Error("Invalid primitive for BitSequence"); + const storeOrderPath = definitions.get(value.bitOrderType).path; + const leastSignificantBitFirst = storeOrderPath.includes("Lsb0"); + if (!leastSignificantBitFirst && !storeOrderPath.includes("Msb0")) + throw new Error("BitOrderType not recognized"); + return [ + { + tag: "bitSequence", + value: { numBytes, leastSignificantBitFirst } + } + ]; + } + } + throw new Error(`FrameId(${frameId}) should have been filtered out`); +}; +const getLookup = (definitions, accessibleTypes, getTypeRef, getPrimitive) => { + const typeTree = []; + [...accessibleTypes.entries()].forEach(([frameId, typeId]) => { + const { path } = definitions.get(frameId); + constructTypeDef(definitions, getTypeRef, getPrimitive, frameId).forEach( + (typeDef) => { + typeTree.push({ + path, + typeId, + typeDef + }); + } + ); + }); + typeTree.sort((a, b) => { + if (a.typeId !== b.typeId) return a.typeId - b.typeId; + if (a.typeDef.tag !== "enumeration" || b.typeDef.tag !== "enumeration") + throw new Error("Found two types with same id"); + return a.typeDef.value.index - b.typeDef.value.index; + }); + return typeTree; +}; + +export { getLookup }; +//# sourceMappingURL=get-lookup.mjs.map diff --git a/packages/merkleize-metadata/dist/esm/get-lookup.mjs.map b/packages/merkleize-metadata/dist/esm/get-lookup.mjs.map new file mode 100644 index 0000000..24b15c4 --- /dev/null +++ b/packages/merkleize-metadata/dist/esm/get-lookup.mjs.map @@ -0,0 +1 @@ +{"version":3,"file":"get-lookup.mjs","sources":["../../src/get-lookup.ts"],"sourcesContent":["import { Lookup, LookupValue, ScalePrimitive, TypeDef, TypeRef } from \"./codecs\"\n\nconst bitSequenceBytes = {\n u8: 1,\n u16: 2,\n u32: 4,\n u64: 8,\n}\n\nconst constructTypeDef = (\n definitions: Map,\n getTypeRef: (frameId: number) => TypeRef,\n getPrimitive: (frameId: number) => ScalePrimitive[\"tag\"] | null,\n frameId: number,\n): TypeDef[] => {\n const {\n def: { tag, value },\n } = definitions.get(frameId)!\n switch (tag) {\n case \"composite\":\n return [\n {\n tag,\n value: value.map((f) => ({\n name: f.name,\n typeName: f.typeName,\n ty: getTypeRef(f.type),\n })),\n },\n ]\n case \"variant\": {\n return value.map((v) => ({\n tag: \"enumeration\",\n value: {\n name: v.name,\n index: v.index,\n fields: v.fields.map((f) => ({\n name: f.name,\n typeName: f.typeName,\n ty: getTypeRef(f.type),\n })),\n },\n }))\n }\n case \"sequence\":\n return [\n {\n tag,\n value: getTypeRef(value),\n },\n ]\n case \"array\":\n return [\n {\n tag,\n value: {\n len: value.len,\n typeParam: getTypeRef(value.type),\n },\n },\n ]\n case \"tuple\":\n return [\n {\n tag,\n value: value.map(getTypeRef),\n },\n ]\n case \"bitSequence\": {\n const primitive = getPrimitive(value.bitStoreType)\n const numBytes = bitSequenceBytes[primitive as \"u8\"]\n if (!numBytes) throw new Error(\"Invalid primitive for BitSequence\")\n\n const storeOrderPath = definitions.get(value.bitOrderType)!.path\n const leastSignificantBitFirst = storeOrderPath.includes(\"Lsb0\")\n if (!leastSignificantBitFirst && !storeOrderPath.includes(\"Msb0\"))\n throw new Error(\"BitOrderType not recognized\")\n\n return [\n {\n tag: \"bitSequence\",\n value: { numBytes, leastSignificantBitFirst },\n },\n ]\n }\n }\n\n throw new Error(`FrameId(${frameId}) should have been filtered out`)\n}\n\nexport const getLookup = (\n definitions: Map,\n accessibleTypes: Map,\n getTypeRef: (frameId: number) => TypeRef,\n getPrimitive: (frameId: number) => ScalePrimitive[\"tag\"] | null,\n) => {\n const typeTree: Lookup = []\n ;[...accessibleTypes.entries()].forEach(([frameId, typeId]) => {\n const { path } = definitions.get(frameId)!\n constructTypeDef(definitions, getTypeRef, getPrimitive, frameId).forEach(\n (typeDef) => {\n typeTree.push({\n path,\n typeId,\n typeDef,\n })\n },\n )\n })\n\n typeTree.sort((a, b) => {\n if (a.typeId !== b.typeId) return a.typeId - b.typeId // in general\n // should only happen for variants\n if (a.typeDef.tag !== \"enumeration\" || b.typeDef.tag !== \"enumeration\")\n throw new Error(\"Found two types with same id\")\n return a.typeDef.value.index - b.typeDef.value.index\n })\n return typeTree\n}\n"],"names":[],"mappings":"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"} \ No newline at end of file diff --git a/packages/merkleize-metadata/dist/esm/get-metadata.mjs b/packages/merkleize-metadata/dist/esm/get-metadata.mjs new file mode 100644 index 0000000..62cb552 --- /dev/null +++ b/packages/merkleize-metadata/dist/esm/get-metadata.mjs @@ -0,0 +1,14 @@ +import { unifyMetadata, decAnyMetadata } from '@pezkuwi/bizinikiwi-bindings'; + +const getMetadata = (input) => { + try { + const metadata = unifyMetadata(decAnyMetadata(input)); + if (metadata.version <= 14) throw new Error("Wrong metadata version"); + return metadata; + } catch (e) { + throw e || new Error("Unable to decode metadata"); + } +}; + +export { getMetadata }; +//# sourceMappingURL=get-metadata.mjs.map diff --git a/packages/merkleize-metadata/dist/esm/get-metadata.mjs.map b/packages/merkleize-metadata/dist/esm/get-metadata.mjs.map new file mode 100644 index 0000000..2d85f97 --- /dev/null +++ b/packages/merkleize-metadata/dist/esm/get-metadata.mjs.map @@ -0,0 +1 @@ +{"version":3,"file":"get-metadata.mjs","sources":["../../src/get-metadata.ts"],"sourcesContent":["import {\n decAnyMetadata,\n UnifiedMetadata,\n type HexString,\n unifyMetadata,\n} from \"@pezkuwi/bizinikiwi-bindings\"\n\nexport const getMetadata = (\n input: Uint8Array | HexString,\n): UnifiedMetadata<15 | 16> => {\n try {\n const metadata = unifyMetadata(decAnyMetadata(input))\n if (metadata.version <= 14) throw new Error(\"Wrong metadata version\")\n return metadata as UnifiedMetadata<15 | 16>\n } catch (e) {\n throw e || new Error(\"Unable to decode metadata\")\n }\n}\n"],"names":[],"mappings":";;AAOO,MAAM,WAAA,GAAc,CACzB,KAAA,KAC6B;AAC7B,EAAA,IAAI;AACF,IAAA,MAAM,QAAA,GAAW,aAAA,CAAc,cAAA,CAAe,KAAK,CAAC,CAAA;AACpD,IAAA,IAAI,SAAS,OAAA,IAAW,EAAA,EAAI,MAAM,IAAI,MAAM,wBAAwB,CAAA;AACpE,IAAA,OAAO,QAAA;AAAA,EACT,SAAS,CAAA,EAAG;AACV,IAAA,MAAM,CAAA,IAAK,IAAI,KAAA,CAAM,2BAA2B,CAAA;AAAA,EAClD;AACF;;;;"} \ No newline at end of file diff --git a/packages/merkleize-metadata/dist/esm/index.mjs b/packages/merkleize-metadata/dist/esm/index.mjs new file mode 100644 index 0000000..b481e92 --- /dev/null +++ b/packages/merkleize-metadata/dist/esm/index.mjs @@ -0,0 +1,3 @@ +export { merkleizeMetadata } from './main.mjs'; +export { extraInfo, extrinsicMetadata, hash, lookup, lookupType, proof } from './codecs.mjs'; +//# sourceMappingURL=index.mjs.map diff --git a/packages/merkleize-metadata/dist/esm/index.mjs.map b/packages/merkleize-metadata/dist/esm/index.mjs.map new file mode 100644 index 0000000..3642066 --- /dev/null +++ b/packages/merkleize-metadata/dist/esm/index.mjs.map @@ -0,0 +1 @@ +{"version":3,"file":"index.mjs","sources":[],"sourcesContent":[],"names":[],"mappings":";"} \ No newline at end of file diff --git a/packages/merkleize-metadata/dist/esm/main.mjs b/packages/merkleize-metadata/dist/esm/main.mjs new file mode 100644 index 0000000..da09f87 --- /dev/null +++ b/packages/merkleize-metadata/dist/esm/main.mjs @@ -0,0 +1,175 @@ +import { Blake3256, compact, u32 } from '@pezkuwi/bizinikiwi-bindings'; +import { lookupType, extrinsicDec, extrinsicMetadata, metadataDigest, extraInfo } from './codecs.mjs'; +import { getAccessibleTypes } from './get-accessible-types.mjs'; +import { getLookup } from './get-lookup.mjs'; +import { getMetadata } from './get-metadata.mjs'; +import { compactTypeRefs, toBytes } from './utils.mjs'; +import { decodeAndCollectKnownLeafs } from './decode-and-collect.mjs'; +import { getProofData } from './proof.mjs'; +import { getDynamicBuilder, getLookupFn } from '@pezkuwi/metadata-builders'; +import { mergeUint8 } from '@pezkuwi/papi-utils'; + +const assertExpected = (name, expected, received) => { + if (received != null && received !== expected) + throw new Error( + `${name} not expected. Received ${received} expected ${expected}` + ); +}; +const merkleizeMetadata = (metadataBytes, { + decimals, + tokenSymbol, + ...hinted +}) => { + const metadata = getMetadata(metadataBytes); + const checkedVersion = metadata.extrinsic.version.includes(4) ? 4 : null; + if (checkedVersion == null) throw new Error("Only extrinsic v4 is supported"); + const { ss58Prefix, buildDefinition } = getDynamicBuilder( + getLookupFn(metadata) + ); + if (ss58Prefix == null) throw new Error("SS58 prefix not found in metadata"); + assertExpected("SS58 prefix", ss58Prefix, hinted.base58Prefix); + const version = metadata.pallets.find((x) => x.name === "System")?.constants.find((x) => x.name === "Version"); + if (version == null) throw new Error("System.Version constant not found"); + const { spec_name: specName, spec_version: specVersion } = buildDefinition( + version.type + ).dec(version.value); + if (typeof specName !== "string" || typeof specVersion !== "number") + throw new Error("Spec name or spec version not found"); + assertExpected("Spec name", specName, hinted.specName); + assertExpected("Spec version", specVersion, hinted.specVersion); + const info = { + decimals, + tokenSymbol, + specVersion, + specName, + base58Prefix: ss58Prefix + }; + const definitions = new Map( + metadata.lookup.map((value) => [value.id, value]) + ); + const accessibleTypes = getAccessibleTypes(metadata, definitions); + const getPrimitive = (frameId) => { + const { + def: { tag, value } + } = definitions.get(frameId); + if (tag === "primitive") return value.tag; + if (tag !== "composite" && tag !== "tuple" || value.length > 1) + throw new Error("The provided definition doesn't map to a primitive"); + return value.length === 0 ? null : getPrimitive(tag === "tuple" ? value[0] : value[0].type); + }; + const getTypeRef = (frameId) => { + const { def } = definitions.get(frameId); + if (def.tag === "primitive") return { tag: def.value.tag, value: void 0 }; + if (def.tag === "compact") { + const primitive = getPrimitive(def.value); + const tag = compactTypeRefs[primitive]; + if (!tag) throw new Error("Invalid primitive for Compact"); + return { tag, value: void 0 }; + } + return accessibleTypes.has(frameId) ? { tag: "perId", value: accessibleTypes.get(frameId) } : { tag: "void", value: void 0 }; + }; + const extrinsic = { + version: checkedVersion, + addressTy: getTypeRef(metadata.extrinsic.address), + callTy: getTypeRef(metadata.extrinsic.call), + signatureTy: getTypeRef(metadata.extrinsic.signature), + signedExtensions: metadata.extrinsic.signedExtensions.map((se) => ({ + identifier: se.identifier, + includedInExtrinsic: getTypeRef(se.type), + includedInSignedData: getTypeRef(se.additionalSigned) + })) + }; + const lookup = getLookup( + definitions, + accessibleTypes, + getTypeRef, + getPrimitive + ); + const lookupEncoded = lookup.map(lookupType.enc); + let hashTree; + const getHashTree = () => { + if (hashTree) return hashTree; + if (!lookupEncoded.length) return hashTree = [new Uint8Array(32).fill(0)]; + hashTree = new Array(lookupEncoded.length * 2 - 1); + let leavesStartIdx = lookupEncoded.length - 1; + for (let i = 0; i < lookupEncoded.length; i++) + hashTree[leavesStartIdx + i] = Blake3256(lookupEncoded[i]); + for (let i = hashTree.length - 2; i > 0; i -= 2) + hashTree[(i - 1) / 2] = Blake3256( + mergeUint8([hashTree[i], hashTree[i + 1]]) + ); + return hashTree; + }; + let digested; + const digest = () => { + if (digested) return digested; + const rootLookupHash = getHashTree()[0]; + const digest2 = { + tag: "V1", + value: { + typeInformationTreeRoot: rootLookupHash, + extrinsicMetadataHash: Blake3256(extrinsicMetadata.enc(extrinsic)), + ...info + } + }; + return digested = Blake3256(metadataDigest.enc(digest2)); + }; + const generateProof = (knownIndexes) => { + const proofData = getProofData(lookupEncoded, knownIndexes); + const hashTree2 = getHashTree(); + const proofs = proofData.proofIdxs.map((idx) => hashTree2[idx]); + return mergeUint8([ + compact.enc(proofData.leaves.length), + ...proofData.leaves, + compact.enc(proofData.leafIdxs.length), + ...proofData.leafIdxs.map((x) => u32.enc(x)), + compact.enc(proofs.length), + ...proofs, + extrinsicMetadata.enc(extrinsic), + extraInfo.enc(info) + ]); + }; + const getProofForExtrinsicPayload = (extrinsicPayload) => { + const typeRefs = [ + extrinsic.callTy, + ...extrinsic.signedExtensions.map((x) => x.includedInExtrinsic), + ...extrinsic.signedExtensions.map((x) => x.includedInSignedData) + ]; + return generateProof( + decodeAndCollectKnownLeafs(extrinsicPayload, typeRefs, lookup) + ); + }; + const getProofForExtrinsicParts = (callData, includedInExtrinsic, includedInSignedData) => { + const bytes = mergeUint8( + [callData, includedInExtrinsic, includedInSignedData].map(toBytes) + ); + return getProofForExtrinsicPayload(bytes); + }; + const getProofForExtrinsic = (transaction, txAdditionalSigned) => { + let [, { version: version2, type }, bytes] = extrinsicDec(transaction); + if (version2 !== extrinsic.version) + throw new Error("Incorrect extrinsic version"); + const typeRefs = type === "signed" ? [ + extrinsic.addressTy, + extrinsic.signatureTy, + ...extrinsic.signedExtensions.map((x) => x.includedInExtrinsic), + extrinsic.callTy + ] : [extrinsic.callTy]; + if (txAdditionalSigned) { + bytes = mergeUint8([bytes, toBytes(txAdditionalSigned)]); + typeRefs.push( + ...extrinsic.signedExtensions.map((x) => x.includedInSignedData) + ); + } + return generateProof(decodeAndCollectKnownLeafs(bytes, typeRefs, lookup)); + }; + return { + digest, + getProofForExtrinsic, + getProofForExtrinsicParts, + getProofForExtrinsicPayload + }; +}; + +export { merkleizeMetadata }; +//# sourceMappingURL=main.mjs.map diff --git a/packages/merkleize-metadata/dist/esm/main.mjs.map b/packages/merkleize-metadata/dist/esm/main.mjs.map new file mode 100644 index 0000000..05c92a4 --- /dev/null +++ b/packages/merkleize-metadata/dist/esm/main.mjs.map @@ -0,0 +1 @@ +{"version":3,"file":"main.mjs","sources":["../../src/main.ts"],"sourcesContent":["import {\n Blake3256,\n HexString,\n compact,\n u32,\n} from \"@pezkuwi/bizinikiwi-bindings\"\nimport {\n ExtraInfo,\n ExtrinsicMetadata,\n LookupValue,\n MetadataDigest,\n ScalePrimitive,\n TypeRef,\n extraInfo,\n extrinsicMetadata,\n lookupType,\n metadataDigest,\n extrinsicDec,\n} from \"./codecs\"\nimport { getAccessibleTypes } from \"./get-accessible-types\"\nimport { getLookup } from \"./get-lookup\"\nimport { getMetadata } from \"./get-metadata\"\nimport { compactTypeRefs, toBytes } from \"./utils\"\nimport { decodeAndCollectKnownLeafs } from \"./decode-and-collect\"\nimport { getProofData } from \"./proof\"\nimport { getDynamicBuilder, getLookupFn } from \"@pezkuwi/metadata-builders\"\nimport { mergeUint8 } from \"@pezkuwi/papi-utils\"\n\nexport interface MetadataMerkleizer {\n /**\n * @returns Digest value of the metadata (aka its merkleized root-hash)\n */\n digest: () => Uint8Array\n\n /**\n * Get proof for an `Extrinsic`.\n *\n * @param transaction Encoded `Extrinsic`, both signed or unsigned.\n * @param txAdditionalSigned Optionally collect types for given\n * `additionalSigned` part of signedExtensions.\n * @returns Encoded `Proof`\n */\n getProofForExtrinsic: (\n transaction: Uint8Array | HexString,\n txAdditionalSigned?: Uint8Array | HexString,\n ) => Uint8Array\n\n /**\n * Get proof for `ExtrinsicPayload` parts.\n *\n * @param callData Call data of the transaction. It has to be\n * bare; i.e.\n * without prepended compact length.\n * @param includedInExtrinsic Extra part of the signed extensions, all of\n * them concatenated.\n * @param includedInSignedData Additional signed part of the signed\n * extensions, all of them concatenated.\n * @returns Encoded `Proof`\n */\n getProofForExtrinsicParts: (\n callData: Uint8Array | HexString,\n includedInExtrinsic: Uint8Array | HexString,\n includedInSignedData: Uint8Array | HexString,\n ) => Uint8Array\n\n /**\n * Get proof for `ExtrinsicPayload`.\n *\n * @param extrinsicPayload Call data, extra part of signedExtensions and\n * additional signed part of signedExtensions\n * concatenated. It has to be bare; i.e. without\n * prepended compact length.\n * @returns Encoded `Proof`\n */\n getProofForExtrinsicPayload: (\n extrinsicPayload: Uint8Array | HexString,\n ) => Uint8Array\n}\n\nconst assertExpected = (name: string, expected: T, received?: T): void => {\n if (received != null && received !== expected)\n throw new Error(\n `${name} not expected. Received ${received} expected ${expected}`,\n )\n}\n\nexport const merkleizeMetadata = (\n metadataBytes: Uint8Array | HexString,\n {\n decimals,\n tokenSymbol,\n ...hinted\n }: { decimals: number; tokenSymbol: string } & Partial,\n): MetadataMerkleizer => {\n const metadata = getMetadata(metadataBytes)\n\n const checkedVersion = metadata.extrinsic.version.includes(4) ? 4 : null\n if (checkedVersion == null) throw new Error(\"Only extrinsic v4 is supported\")\n\n const { ss58Prefix, buildDefinition } = getDynamicBuilder(\n getLookupFn(metadata),\n )\n if (ss58Prefix == null) throw new Error(\"SS58 prefix not found in metadata\")\n assertExpected(\"SS58 prefix\", ss58Prefix, hinted.base58Prefix)\n const version = metadata.pallets\n .find((x) => x.name === \"System\")\n ?.constants.find((x) => x.name === \"Version\")\n if (version == null) throw new Error(\"System.Version constant not found\")\n const { spec_name: specName, spec_version: specVersion } = buildDefinition(\n version.type,\n ).dec(version.value)\n if (typeof specName !== \"string\" || typeof specVersion !== \"number\")\n throw new Error(\"Spec name or spec version not found\")\n assertExpected(\"Spec name\", specName, hinted.specName)\n assertExpected(\"Spec version\", specVersion, hinted.specVersion)\n\n const info: ExtraInfo = {\n decimals,\n tokenSymbol,\n specVersion,\n specName,\n base58Prefix: ss58Prefix,\n }\n const definitions = new Map(\n metadata.lookup.map((value) => [value.id, value]),\n )\n const accessibleTypes = getAccessibleTypes(metadata, definitions)\n const getPrimitive = (frameId: number): ScalePrimitive[\"tag\"] | null => {\n const {\n def: { tag, value },\n } = definitions.get(frameId)!\n\n if (tag === \"primitive\") return value.tag\n\n if ((tag !== \"composite\" && tag !== \"tuple\") || value.length > 1)\n throw new Error(\"The provided definition doesn't map to a primitive\")\n\n return value.length === 0\n ? null // signals `void`\n : getPrimitive(tag === \"tuple\" ? value[0] : value[0].type)\n }\n\n const getTypeRef = (frameId: number): TypeRef => {\n const { def } = definitions.get(frameId)!\n\n if (def.tag === \"primitive\") return { tag: def.value.tag, value: undefined }\n\n if (def.tag === \"compact\") {\n const primitive = getPrimitive(def.value)\n const tag = compactTypeRefs[primitive as \"u8\"]\n if (!tag) throw new Error(\"Invalid primitive for Compact\")\n return { tag, value: undefined }\n }\n\n return accessibleTypes.has(frameId)\n ? { tag: \"perId\", value: accessibleTypes.get(frameId)! }\n : { tag: \"void\", value: undefined }\n }\n\n const extrinsic: ExtrinsicMetadata = {\n version: checkedVersion,\n addressTy: getTypeRef(metadata.extrinsic.address),\n callTy: getTypeRef(metadata.extrinsic.call),\n signatureTy: getTypeRef(metadata.extrinsic.signature),\n signedExtensions: metadata.extrinsic.signedExtensions.map((se) => ({\n identifier: se.identifier,\n includedInExtrinsic: getTypeRef(se.type),\n includedInSignedData: getTypeRef(se.additionalSigned),\n })),\n }\n\n const lookup = getLookup(\n definitions,\n accessibleTypes,\n getTypeRef,\n getPrimitive,\n )\n const lookupEncoded = lookup.map(lookupType.enc)\n\n let hashTree: Array | undefined\n const getHashTree = (): Array => {\n if (hashTree) return hashTree\n\n if (!lookupEncoded.length) return (hashTree = [new Uint8Array(32).fill(0)])\n\n hashTree = new Array(lookupEncoded.length * 2 - 1)\n\n let leavesStartIdx = lookupEncoded.length - 1\n for (let i = 0; i < lookupEncoded.length; i++)\n hashTree[leavesStartIdx + i] = Blake3256(lookupEncoded[i])\n\n for (let i = hashTree.length - 2; i > 0; i -= 2)\n hashTree[(i - 1) / 2] = Blake3256(\n mergeUint8([hashTree[i], hashTree[i + 1]]),\n )\n\n return hashTree\n }\n\n let digested: undefined | Uint8Array\n const digest = () => {\n if (digested) return digested\n const rootLookupHash = getHashTree()[0]\n\n const digest: MetadataDigest = {\n tag: \"V1\",\n value: {\n typeInformationTreeRoot: rootLookupHash,\n extrinsicMetadataHash: Blake3256(extrinsicMetadata.enc(extrinsic)),\n ...info,\n },\n }\n\n return (digested = Blake3256(metadataDigest.enc(digest)))\n }\n\n const generateProof = (knownIndexes: number[]) => {\n const proofData = getProofData(lookupEncoded, knownIndexes)\n\n const hashTree = getHashTree()\n const proofs = proofData.proofIdxs.map((idx) => hashTree[idx])\n\n return mergeUint8([\n compact.enc(proofData.leaves.length),\n ...proofData.leaves,\n compact.enc(proofData.leafIdxs.length),\n ...proofData.leafIdxs.map((x) => u32.enc(x)),\n compact.enc(proofs.length),\n ...proofs,\n extrinsicMetadata.enc(extrinsic),\n extraInfo.enc(info),\n ])\n }\n\n const getProofForExtrinsicPayload = (\n extrinsicPayload: Uint8Array | HexString,\n ) => {\n const typeRefs: Array = [\n extrinsic.callTy,\n ...extrinsic.signedExtensions.map((x) => x.includedInExtrinsic),\n ...extrinsic.signedExtensions.map((x) => x.includedInSignedData),\n ]\n return generateProof(\n decodeAndCollectKnownLeafs(extrinsicPayload, typeRefs, lookup),\n )\n }\n\n const getProofForExtrinsicParts = (\n callData: Uint8Array | HexString,\n includedInExtrinsic: Uint8Array | HexString,\n includedInSignedData: Uint8Array | HexString,\n ) => {\n const bytes = mergeUint8(\n [callData, includedInExtrinsic, includedInSignedData].map(toBytes),\n )\n return getProofForExtrinsicPayload(bytes)\n }\n\n const getProofForExtrinsic = (\n transaction: Uint8Array | HexString,\n txAdditionalSigned?: Uint8Array | HexString,\n ) => {\n let [, { version, type }, bytes] = extrinsicDec(transaction)\n\n if (version !== extrinsic.version)\n throw new Error(\"Incorrect extrinsic version\")\n\n const typeRefs: TypeRef[] =\n type === \"signed\"\n ? [\n extrinsic.addressTy,\n extrinsic.signatureTy,\n ...extrinsic.signedExtensions.map((x) => x.includedInExtrinsic),\n extrinsic.callTy,\n ]\n : [extrinsic.callTy]\n\n if (txAdditionalSigned) {\n bytes = mergeUint8([bytes, toBytes(txAdditionalSigned)])\n typeRefs.push(\n ...extrinsic.signedExtensions.map((x) => x.includedInSignedData),\n )\n }\n\n return generateProof(decodeAndCollectKnownLeafs(bytes, typeRefs, lookup))\n }\n\n return {\n digest,\n getProofForExtrinsic,\n getProofForExtrinsicParts,\n getProofForExtrinsicPayload,\n }\n}\n"],"names":["digest","hashTree","version"],"mappings":"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"} \ No newline at end of file diff --git a/packages/merkleize-metadata/dist/esm/proof.mjs b/packages/merkleize-metadata/dist/esm/proof.mjs new file mode 100644 index 0000000..bd4ed8b --- /dev/null +++ b/packages/merkleize-metadata/dist/esm/proof.mjs @@ -0,0 +1,47 @@ +const getLevelFromIdx = (idx) => Math.log2(idx + 1) | 0; +const getAncestorIdx = (from, nLevels) => (from + 1 >> nLevels) - 1; +function getProofData(leaves, knownLeavesIdxs) { + const knownLeaves = knownLeavesIdxs.map((idx) => leaves[idx]); + const startingIdx = leaves.length - 1; + const leafIdxs = knownLeavesIdxs.map((idx) => startingIdx + idx); + const proofIdxs = []; + if (leafIdxs.length) { + const nLevels = getLevelFromIdx(leafIdxs.at(-1)); + const splitPosition = Math.pow(2, nLevels) - 1; + const splitIdx = leafIdxs.findIndex((x) => x >= splitPosition); + if (splitIdx > 0) { + leafIdxs.unshift(...leafIdxs.splice(splitIdx)); + knownLeaves.unshift(...knownLeaves.splice(splitIdx)); + } + } + let targetIdx = 0; + const traverse = (nodeIdx) => { + if (targetIdx === leafIdxs.length) { + proofIdxs.push(nodeIdx); + return; + } + const target = leafIdxs[targetIdx]; + if (target === nodeIdx) { + ++targetIdx; + return; + } + const currentLevel = getLevelFromIdx(nodeIdx); + const targetLevel = getLevelFromIdx(target); + if (nodeIdx !== getAncestorIdx(target, targetLevel - currentLevel)) { + proofIdxs.push(nodeIdx); + return; + } + const leftSon = 2 * nodeIdx + 1; + traverse(leftSon); + traverse(leftSon + 1); + }; + traverse(0); + return { + leaves: knownLeaves, + leafIdxs, + proofIdxs + }; +} + +export { getProofData }; +//# sourceMappingURL=proof.mjs.map diff --git a/packages/merkleize-metadata/dist/esm/proof.mjs.map b/packages/merkleize-metadata/dist/esm/proof.mjs.map new file mode 100644 index 0000000..892bbcd --- /dev/null +++ b/packages/merkleize-metadata/dist/esm/proof.mjs.map @@ -0,0 +1 @@ +{"version":3,"file":"proof.mjs","sources":["../../src/proof.ts"],"sourcesContent":["const getLevelFromIdx = (idx: number) => Math.log2(idx + 1) | 0\nconst getAncestorIdx = (from: number, nLevels: number) =>\n ((from + 1) >> nLevels) - 1\n\nexport function getProofData(\n leaves: Array,\n knownLeavesIdxs: Array,\n) {\n const knownLeaves = knownLeavesIdxs.map((idx) => leaves[idx])\n\n const startingIdx = leaves.length - 1\n const leafIdxs = knownLeavesIdxs.map((idx) => startingIdx + idx)\n\n const proofIdxs: Array = []\n if (leafIdxs.length) {\n const nLevels = getLevelFromIdx(leafIdxs.at(-1)!)\n const splitPosition = Math.pow(2, nLevels) - 1\n const splitIdx = leafIdxs.findIndex((x) => x >= splitPosition)\n if (splitIdx > 0) {\n leafIdxs.unshift(...leafIdxs.splice(splitIdx))\n knownLeaves.unshift(...knownLeaves.splice(splitIdx))\n }\n }\n\n let targetIdx = 0\n const traverse = (nodeIdx: number): void => {\n if (targetIdx === leafIdxs.length) {\n proofIdxs.push(nodeIdx)\n return\n }\n\n const target = leafIdxs[targetIdx]\n if (target === nodeIdx) {\n ++targetIdx\n return\n }\n\n const currentLevel = getLevelFromIdx(nodeIdx)\n const targetLevel = getLevelFromIdx(target)\n\n if (nodeIdx !== getAncestorIdx(target, targetLevel - currentLevel)) {\n proofIdxs.push(nodeIdx)\n return\n }\n\n const leftSon = 2 * nodeIdx + 1\n traverse(leftSon)\n traverse(leftSon + 1)\n }\n traverse(0)\n\n return {\n leaves: knownLeaves,\n leafIdxs,\n proofIdxs,\n }\n}\n"],"names":[],"mappings":"AAAA,MAAM,kBAAkB,CAAC,GAAA,KAAgB,KAAK,IAAA,CAAK,GAAA,GAAM,CAAC,CAAA,GAAI,CAAA;AAC9D,MAAM,iBAAiB,CAAC,IAAA,EAAc,OAAA,KAAA,CAClC,IAAA,GAAO,KAAM,OAAA,IAAW,CAAA;AAErB,SAAS,YAAA,CACd,QACA,eAAA,EACA;AACA,EAAA,MAAM,cAAc,eAAA,CAAgB,GAAA,CAAI,CAAC,GAAA,KAAQ,MAAA,CAAO,GAAG,CAAC,CAAA;AAE5D,EAAA,MAAM,WAAA,GAAc,OAAO,MAAA,GAAS,CAAA;AACpC,EAAA,MAAM,WAAW,eAAA,CAAgB,GAAA,CAAI,CAAC,GAAA,KAAQ,cAAc,GAAG,CAAA;AAE/D,EAAA,MAAM,YAA2B,EAAC;AAClC,EAAA,IAAI,SAAS,MAAA,EAAQ;AACnB,IAAA,MAAM,OAAA,GAAU,eAAA,CAAgB,QAAA,CAAS,EAAA,CAAG,EAAE,CAAE,CAAA;AAChD,IAAA,MAAM,aAAA,GAAgB,IAAA,CAAK,GAAA,CAAI,CAAA,EAAG,OAAO,CAAA,GAAI,CAAA;AAC7C,IAAA,MAAM,WAAW,QAAA,CAAS,SAAA,CAAU,CAAC,CAAA,KAAM,KAAK,aAAa,CAAA;AAC7D,IAAA,IAAI,WAAW,CAAA,EAAG;AAChB,MAAA,QAAA,CAAS,OAAA,CAAQ,GAAG,QAAA,CAAS,MAAA,CAAO,QAAQ,CAAC,CAAA;AAC7C,MAAA,WAAA,CAAY,OAAA,CAAQ,GAAG,WAAA,CAAY,MAAA,CAAO,QAAQ,CAAC,CAAA;AAAA,IACrD;AAAA,EACF;AAEA,EAAA,IAAI,SAAA,GAAY,CAAA;AAChB,EAAA,MAAM,QAAA,GAAW,CAAC,OAAA,KAA0B;AAC1C,IAAA,IAAI,SAAA,KAAc,SAAS,MAAA,EAAQ;AACjC,MAAA,SAAA,CAAU,KAAK,OAAO,CAAA;AACtB,MAAA;AAAA,IACF;AAEA,IAAA,MAAM,MAAA,GAAS,SAAS,SAAS,CAAA;AACjC,IAAA,IAAI,WAAW,OAAA,EAAS;AACtB,MAAA,EAAE,SAAA;AACF,MAAA;AAAA,IACF;AAEA,IAAA,MAAM,YAAA,GAAe,gBAAgB,OAAO,CAAA;AAC5C,IAAA,MAAM,WAAA,GAAc,gBAAgB,MAAM,CAAA;AAE1C,IAAA,IAAI,OAAA,KAAY,cAAA,CAAe,MAAA,EAAQ,WAAA,GAAc,YAAY,CAAA,EAAG;AAClE,MAAA,SAAA,CAAU,KAAK,OAAO,CAAA;AACtB,MAAA;AAAA,IACF;AAEA,IAAA,MAAM,OAAA,GAAU,IAAI,OAAA,GAAU,CAAA;AAC9B,IAAA,QAAA,CAAS,OAAO,CAAA;AAChB,IAAA,QAAA,CAAS,UAAU,CAAC,CAAA;AAAA,EACtB,CAAA;AACA,EAAA,QAAA,CAAS,CAAC,CAAA;AAEV,EAAA,OAAO;AAAA,IACL,MAAA,EAAQ,WAAA;AAAA,IACR,QAAA;AAAA,IACA;AAAA,GACF;AACF;;;;"} \ No newline at end of file diff --git a/packages/merkleize-metadata/dist/esm/utils.mjs b/packages/merkleize-metadata/dist/esm/utils.mjs new file mode 100644 index 0000000..b954c44 --- /dev/null +++ b/packages/merkleize-metadata/dist/esm/utils.mjs @@ -0,0 +1,15 @@ +import { fromHex } from '@pezkuwi/papi-utils'; + +const toBytes = (input) => typeof input === "string" ? fromHex(input) : input; +const compactTypeRefs = { + null: "void", + u8: "compactU8", + u16: "compactU16", + u32: "compactU32", + u64: "compactU64", + u128: "compactU128", + u256: "compactU256" +}; + +export { compactTypeRefs, toBytes }; +//# sourceMappingURL=utils.mjs.map diff --git a/packages/merkleize-metadata/dist/esm/utils.mjs.map b/packages/merkleize-metadata/dist/esm/utils.mjs.map new file mode 100644 index 0000000..6c0a2d5 --- /dev/null +++ b/packages/merkleize-metadata/dist/esm/utils.mjs.map @@ -0,0 +1 @@ +{"version":3,"file":"utils.mjs","sources":["../../src/utils.ts"],"sourcesContent":["import { type HexString } from \"@pezkuwi/bizinikiwi-bindings\"\nimport { fromHex } from \"@pezkuwi/papi-utils\"\n\nexport const toBytes = (input: Uint8Array | HexString) =>\n typeof input === \"string\" ? fromHex(input) : input\n\nexport const compactTypeRefs = {\n null: \"void\" as const,\n u8: \"compactU8\" as const,\n u16: \"compactU16\" as const,\n u32: \"compactU32\" as const,\n u64: \"compactU64\" as const,\n u128: \"compactU128\" as const,\n u256: \"compactU256\" as const,\n}\n"],"names":[],"mappings":";;AAGO,MAAM,OAAA,GAAU,CAAC,KAAA,KACtB,OAAO,UAAU,QAAA,GAAW,OAAA,CAAQ,KAAK,CAAA,GAAI;AAExC,MAAM,eAAA,GAAkB;AAAA,EAC7B,IAAA,EAAM,MAAA;AAAA,EACN,EAAA,EAAI,WAAA;AAAA,EACJ,GAAA,EAAK,YAAA;AAAA,EACL,GAAA,EAAK,YAAA;AAAA,EACL,GAAA,EAAK,YAAA;AAAA,EACL,IAAA,EAAM,aAAA;AAAA,EACN,IAAA,EAAM;AACR;;;;"} \ No newline at end of file diff --git a/packages/merkleize-metadata/dist/index.d.ts b/packages/merkleize-metadata/dist/index.d.ts new file mode 100644 index 0000000..8674130 --- /dev/null +++ b/packages/merkleize-metadata/dist/index.d.ts @@ -0,0 +1,13471 @@ +import * as _pezkuwi_bizinikiwi_bindings from '@pezkuwi/bizinikiwi-bindings'; +import { CodecType, Codec, HexString } from '@pezkuwi/bizinikiwi-bindings'; + +declare const extraInfo: [_pezkuwi_bizinikiwi_bindings.Encoder<{ + specVersion: number; + specName: string; + base58Prefix: number; + decimals: number; + tokenSymbol: string; +}>, _pezkuwi_bizinikiwi_bindings.Decoder<{ + specVersion: number; + specName: string; + base58Prefix: number; + decimals: number; + tokenSymbol: string; +}>] & { + enc: _pezkuwi_bizinikiwi_bindings.Encoder<{ + specVersion: number; + specName: string; + base58Prefix: number; + decimals: number; + tokenSymbol: string; + }>; + dec: _pezkuwi_bizinikiwi_bindings.Decoder<{ + specVersion: number; + specName: string; + base58Prefix: number; + decimals: number; + tokenSymbol: string; + }>; +} & { + inner: { + specVersion: Codec; + specName: Codec; + base58Prefix: Codec; + decimals: Codec; + tokenSymbol: Codec; + }; +}; +type ExtraInfo = CodecType; +declare const hash: Codec>; +declare const typeRef: [_pezkuwi_bizinikiwi_bindings.Encoder<{ + tag: "bool"; + value: undefined; +} | { + tag: "char"; + value: undefined; +} | { + tag: "str"; + value: undefined; +} | { + tag: "u8"; + value: undefined; +} | { + tag: "u16"; + value: undefined; +} | { + tag: "u32"; + value: undefined; +} | { + tag: "u64"; + value: undefined; +} | { + tag: "u128"; + value: undefined; +} | { + tag: "u256"; + value: undefined; +} | { + tag: "i8"; + value: undefined; +} | { + tag: "i16"; + value: undefined; +} | { + tag: "i32"; + value: undefined; +} | { + tag: "i64"; + value: undefined; +} | { + tag: "i128"; + value: undefined; +} | { + tag: "i256"; + value: undefined; +} | { + tag: "compactU8"; + value: undefined; +} | { + tag: "compactU16"; + value: undefined; +} | { + tag: "compactU32"; + value: undefined; +} | { + tag: "compactU64"; + value: undefined; +} | { + tag: "compactU128"; + value: undefined; +} | { + tag: "compactU256"; + value: undefined; +} | { + tag: "void"; + value: undefined; +} | { + tag: "perId"; + value: number; +}>, _pezkuwi_bizinikiwi_bindings.Decoder<{ + tag: "bool"; + value: undefined; +} | { + tag: "char"; + value: undefined; +} | { + tag: "str"; + value: undefined; +} | { + tag: "u8"; + value: undefined; +} | { + tag: "u16"; + value: undefined; +} | { + tag: "u32"; + value: undefined; +} | { + tag: "u64"; + value: undefined; +} | { + tag: "u128"; + value: undefined; +} | { + tag: "u256"; + value: undefined; +} | { + tag: "i8"; + value: undefined; +} | { + tag: "i16"; + value: undefined; +} | { + tag: "i32"; + value: undefined; +} | { + tag: "i64"; + value: undefined; +} | { + tag: "i128"; + value: undefined; +} | { + tag: "i256"; + value: undefined; +} | { + tag: "compactU8"; + value: undefined; +} | { + tag: "compactU16"; + value: undefined; +} | { + tag: "compactU32"; + value: undefined; +} | { + tag: "compactU64"; + value: undefined; +} | { + tag: "compactU128"; + value: undefined; +} | { + tag: "compactU256"; + value: undefined; +} | { + tag: "void"; + value: undefined; +} | { + tag: "perId"; + value: number; +}>] & { + enc: _pezkuwi_bizinikiwi_bindings.Encoder<{ + tag: "bool"; + value: undefined; + } | { + tag: "char"; + value: undefined; + } | { + tag: "str"; + value: undefined; + } | { + tag: "u8"; + value: undefined; + } | { + tag: "u16"; + value: undefined; + } | { + tag: "u32"; + value: undefined; + } | { + tag: "u64"; + value: undefined; + } | { + tag: "u128"; + value: undefined; + } | { + tag: "u256"; + value: undefined; + } | { + tag: "i8"; + value: undefined; + } | { + tag: "i16"; + value: undefined; + } | { + tag: "i32"; + value: undefined; + } | { + tag: "i64"; + value: undefined; + } | { + tag: "i128"; + value: undefined; + } | { + tag: "i256"; + value: undefined; + } | { + tag: "compactU8"; + value: undefined; + } | { + tag: "compactU16"; + value: undefined; + } | { + tag: "compactU32"; + value: undefined; + } | { + tag: "compactU64"; + value: undefined; + } | { + tag: "compactU128"; + value: undefined; + } | { + tag: "compactU256"; + value: undefined; + } | { + tag: "void"; + value: undefined; + } | { + tag: "perId"; + value: number; + }>; + dec: _pezkuwi_bizinikiwi_bindings.Decoder<{ + tag: "bool"; + value: undefined; + } | { + tag: "char"; + value: undefined; + } | { + tag: "str"; + value: undefined; + } | { + tag: "u8"; + value: undefined; + } | { + tag: "u16"; + value: undefined; + } | { + tag: "u32"; + value: undefined; + } | { + tag: "u64"; + value: undefined; + } | { + tag: "u128"; + value: undefined; + } | { + tag: "u256"; + value: undefined; + } | { + tag: "i8"; + value: undefined; + } | { + tag: "i16"; + value: undefined; + } | { + tag: "i32"; + value: undefined; + } | { + tag: "i64"; + value: undefined; + } | { + tag: "i128"; + value: undefined; + } | { + tag: "i256"; + value: undefined; + } | { + tag: "compactU8"; + value: undefined; + } | { + tag: "compactU16"; + value: undefined; + } | { + tag: "compactU32"; + value: undefined; + } | { + tag: "compactU64"; + value: undefined; + } | { + tag: "compactU128"; + value: undefined; + } | { + tag: "compactU256"; + value: undefined; + } | { + tag: "void"; + value: undefined; + } | { + tag: "perId"; + value: number; + }>; +} & { + inner: { + bool: Codec; + char: Codec; + str: Codec; + u8: Codec; + u16: Codec; + u32: Codec; + u64: Codec; + u128: Codec; + u256: Codec; + i8: Codec; + i16: Codec; + i32: Codec; + i64: Codec; + i128: Codec; + i256: Codec; + compactU8: Codec; + compactU16: Codec; + compactU32: Codec; + compactU64: Codec; + compactU128: Codec; + compactU256: Codec; + void: Codec; + perId: Codec; + }; +}; +type TypeRef = CodecType; +declare const lookupType: [_pezkuwi_bizinikiwi_bindings.Encoder<{ + path: string[]; + typeDef: { + tag: "composite"; + value: { + name: string | undefined; + ty: { + tag: "bool"; + value: undefined; + } | { + tag: "char"; + value: undefined; + } | { + tag: "str"; + value: undefined; + } | { + tag: "u8"; + value: undefined; + } | { + tag: "u16"; + value: undefined; + } | { + tag: "u32"; + value: undefined; + } | { + tag: "u64"; + value: undefined; + } | { + tag: "u128"; + value: undefined; + } | { + tag: "u256"; + value: undefined; + } | { + tag: "i8"; + value: undefined; + } | { + tag: "i16"; + value: undefined; + } | { + tag: "i32"; + value: undefined; + } | { + tag: "i64"; + value: undefined; + } | { + tag: "i128"; + value: undefined; + } | { + tag: "i256"; + value: undefined; + } | { + tag: "compactU8"; + value: undefined; + } | { + tag: "compactU16"; + value: undefined; + } | { + tag: "compactU32"; + value: undefined; + } | { + tag: "compactU64"; + value: undefined; + } | { + tag: "compactU128"; + value: undefined; + } | { + tag: "compactU256"; + value: undefined; + } | { + tag: "void"; + value: undefined; + } | { + tag: "perId"; + value: number; + }; + typeName: string | undefined; + }[]; + } | { + tag: "enumeration"; + value: { + name: string; + fields: { + name: string | undefined; + ty: { + tag: "bool"; + value: undefined; + } | { + tag: "char"; + value: undefined; + } | { + tag: "str"; + value: undefined; + } | { + tag: "u8"; + value: undefined; + } | { + tag: "u16"; + value: undefined; + } | { + tag: "u32"; + value: undefined; + } | { + tag: "u64"; + value: undefined; + } | { + tag: "u128"; + value: undefined; + } | { + tag: "u256"; + value: undefined; + } | { + tag: "i8"; + value: undefined; + } | { + tag: "i16"; + value: undefined; + } | { + tag: "i32"; + value: undefined; + } | { + tag: "i64"; + value: undefined; + } | { + tag: "i128"; + value: undefined; + } | { + tag: "i256"; + value: undefined; + } | { + tag: "compactU8"; + value: undefined; + } | { + tag: "compactU16"; + value: undefined; + } | { + tag: "compactU32"; + value: undefined; + } | { + tag: "compactU64"; + value: undefined; + } | { + tag: "compactU128"; + value: undefined; + } | { + tag: "compactU256"; + value: undefined; + } | { + tag: "void"; + value: undefined; + } | { + tag: "perId"; + value: number; + }; + typeName: string | undefined; + }[]; + index: number; + }; + } | { + tag: "sequence"; + value: { + tag: "bool"; + value: undefined; + } | { + tag: "char"; + value: undefined; + } | { + tag: "str"; + value: undefined; + } | { + tag: "u8"; + value: undefined; + } | { + tag: "u16"; + value: undefined; + } | { + tag: "u32"; + value: undefined; + } | { + tag: "u64"; + value: undefined; + } | { + tag: "u128"; + value: undefined; + } | { + tag: "u256"; + value: undefined; + } | { + tag: "i8"; + value: undefined; + } | { + tag: "i16"; + value: undefined; + } | { + tag: "i32"; + value: undefined; + } | { + tag: "i64"; + value: undefined; + } | { + tag: "i128"; + value: undefined; + } | { + tag: "i256"; + value: undefined; + } | { + tag: "compactU8"; + value: undefined; + } | { + tag: "compactU16"; + value: undefined; + } | { + tag: "compactU32"; + value: undefined; + } | { + tag: "compactU64"; + value: undefined; + } | { + tag: "compactU128"; + value: undefined; + } | { + tag: "compactU256"; + value: undefined; + } | { + tag: "void"; + value: undefined; + } | { + tag: "perId"; + value: number; + }; + } | { + tag: "array"; + value: { + len: number; + typeParam: { + tag: "bool"; + value: undefined; + } | { + tag: "char"; + value: undefined; + } | { + tag: "str"; + value: undefined; + } | { + tag: "u8"; + value: undefined; + } | { + tag: "u16"; + value: undefined; + } | { + tag: "u32"; + value: undefined; + } | { + tag: "u64"; + value: undefined; + } | { + tag: "u128"; + value: undefined; + } | { + tag: "u256"; + value: undefined; + } | { + tag: "i8"; + value: undefined; + } | { + tag: "i16"; + value: undefined; + } | { + tag: "i32"; + value: undefined; + } | { + tag: "i64"; + value: undefined; + } | { + tag: "i128"; + value: undefined; + } | { + tag: "i256"; + value: undefined; + } | { + tag: "compactU8"; + value: undefined; + } | { + tag: "compactU16"; + value: undefined; + } | { + tag: "compactU32"; + value: undefined; + } | { + tag: "compactU64"; + value: undefined; + } | { + tag: "compactU128"; + value: undefined; + } | { + tag: "compactU256"; + value: undefined; + } | { + tag: "void"; + value: undefined; + } | { + tag: "perId"; + value: number; + }; + }; + } | { + tag: "tuple"; + value: ({ + tag: "bool"; + value: undefined; + } | { + tag: "char"; + value: undefined; + } | { + tag: "str"; + value: undefined; + } | { + tag: "u8"; + value: undefined; + } | { + tag: "u16"; + value: undefined; + } | { + tag: "u32"; + value: undefined; + } | { + tag: "u64"; + value: undefined; + } | { + tag: "u128"; + value: undefined; + } | { + tag: "u256"; + value: undefined; + } | { + tag: "i8"; + value: undefined; + } | { + tag: "i16"; + value: undefined; + } | { + tag: "i32"; + value: undefined; + } | { + tag: "i64"; + value: undefined; + } | { + tag: "i128"; + value: undefined; + } | { + tag: "i256"; + value: undefined; + } | { + tag: "compactU8"; + value: undefined; + } | { + tag: "compactU16"; + value: undefined; + } | { + tag: "compactU32"; + value: undefined; + } | { + tag: "compactU64"; + value: undefined; + } | { + tag: "compactU128"; + value: undefined; + } | { + tag: "compactU256"; + value: undefined; + } | { + tag: "void"; + value: undefined; + } | { + tag: "perId"; + value: number; + })[]; + } | { + tag: "bitSequence"; + value: { + numBytes: number; + leastSignificantBitFirst: boolean; + }; + }; + typeId: number; +}>, _pezkuwi_bizinikiwi_bindings.Decoder<{ + path: string[]; + typeDef: { + tag: "composite"; + value: { + name: string | undefined; + ty: { + tag: "bool"; + value: undefined; + } | { + tag: "char"; + value: undefined; + } | { + tag: "str"; + value: undefined; + } | { + tag: "u8"; + value: undefined; + } | { + tag: "u16"; + value: undefined; + } | { + tag: "u32"; + value: undefined; + } | { + tag: "u64"; + value: undefined; + } | { + tag: "u128"; + value: undefined; + } | { + tag: "u256"; + value: undefined; + } | { + tag: "i8"; + value: undefined; + } | { + tag: "i16"; + value: undefined; + } | { + tag: "i32"; + value: undefined; + } | { + tag: "i64"; + value: undefined; + } | { + tag: "i128"; + value: undefined; + } | { + tag: "i256"; + value: undefined; + } | { + tag: "compactU8"; + value: undefined; + } | { + tag: "compactU16"; + value: undefined; + } | { + tag: "compactU32"; + value: undefined; + } | { + tag: "compactU64"; + value: undefined; + } | { + tag: "compactU128"; + value: undefined; + } | { + tag: "compactU256"; + value: undefined; + } | { + tag: "void"; + value: undefined; + } | { + tag: "perId"; + value: number; + }; + typeName: string | undefined; + }[]; + } | { + tag: "enumeration"; + value: { + name: string; + fields: { + name: string | undefined; + ty: { + tag: "bool"; + value: undefined; + } | { + tag: "char"; + value: undefined; + } | { + tag: "str"; + value: undefined; + } | { + tag: "u8"; + value: undefined; + } | { + tag: "u16"; + value: undefined; + } | { + tag: "u32"; + value: undefined; + } | { + tag: "u64"; + value: undefined; + } | { + tag: "u128"; + value: undefined; + } | { + tag: "u256"; + value: undefined; + } | { + tag: "i8"; + value: undefined; + } | { + tag: "i16"; + value: undefined; + } | { + tag: "i32"; + value: undefined; + } | { + tag: "i64"; + value: undefined; + } | { + tag: "i128"; + value: undefined; + } | { + tag: "i256"; + value: undefined; + } | { + tag: "compactU8"; + value: undefined; + } | { + tag: "compactU16"; + value: undefined; + } | { + tag: "compactU32"; + value: undefined; + } | { + tag: "compactU64"; + value: undefined; + } | { + tag: "compactU128"; + value: undefined; + } | { + tag: "compactU256"; + value: undefined; + } | { + tag: "void"; + value: undefined; + } | { + tag: "perId"; + value: number; + }; + typeName: string | undefined; + }[]; + index: number; + }; + } | { + tag: "sequence"; + value: { + tag: "bool"; + value: undefined; + } | { + tag: "char"; + value: undefined; + } | { + tag: "str"; + value: undefined; + } | { + tag: "u8"; + value: undefined; + } | { + tag: "u16"; + value: undefined; + } | { + tag: "u32"; + value: undefined; + } | { + tag: "u64"; + value: undefined; + } | { + tag: "u128"; + value: undefined; + } | { + tag: "u256"; + value: undefined; + } | { + tag: "i8"; + value: undefined; + } | { + tag: "i16"; + value: undefined; + } | { + tag: "i32"; + value: undefined; + } | { + tag: "i64"; + value: undefined; + } | { + tag: "i128"; + value: undefined; + } | { + tag: "i256"; + value: undefined; + } | { + tag: "compactU8"; + value: undefined; + } | { + tag: "compactU16"; + value: undefined; + } | { + tag: "compactU32"; + value: undefined; + } | { + tag: "compactU64"; + value: undefined; + } | { + tag: "compactU128"; + value: undefined; + } | { + tag: "compactU256"; + value: undefined; + } | { + tag: "void"; + value: undefined; + } | { + tag: "perId"; + value: number; + }; + } | { + tag: "array"; + value: { + len: number; + typeParam: { + tag: "bool"; + value: undefined; + } | { + tag: "char"; + value: undefined; + } | { + tag: "str"; + value: undefined; + } | { + tag: "u8"; + value: undefined; + } | { + tag: "u16"; + value: undefined; + } | { + tag: "u32"; + value: undefined; + } | { + tag: "u64"; + value: undefined; + } | { + tag: "u128"; + value: undefined; + } | { + tag: "u256"; + value: undefined; + } | { + tag: "i8"; + value: undefined; + } | { + tag: "i16"; + value: undefined; + } | { + tag: "i32"; + value: undefined; + } | { + tag: "i64"; + value: undefined; + } | { + tag: "i128"; + value: undefined; + } | { + tag: "i256"; + value: undefined; + } | { + tag: "compactU8"; + value: undefined; + } | { + tag: "compactU16"; + value: undefined; + } | { + tag: "compactU32"; + value: undefined; + } | { + tag: "compactU64"; + value: undefined; + } | { + tag: "compactU128"; + value: undefined; + } | { + tag: "compactU256"; + value: undefined; + } | { + tag: "void"; + value: undefined; + } | { + tag: "perId"; + value: number; + }; + }; + } | { + tag: "tuple"; + value: ({ + tag: "bool"; + value: undefined; + } | { + tag: "char"; + value: undefined; + } | { + tag: "str"; + value: undefined; + } | { + tag: "u8"; + value: undefined; + } | { + tag: "u16"; + value: undefined; + } | { + tag: "u32"; + value: undefined; + } | { + tag: "u64"; + value: undefined; + } | { + tag: "u128"; + value: undefined; + } | { + tag: "u256"; + value: undefined; + } | { + tag: "i8"; + value: undefined; + } | { + tag: "i16"; + value: undefined; + } | { + tag: "i32"; + value: undefined; + } | { + tag: "i64"; + value: undefined; + } | { + tag: "i128"; + value: undefined; + } | { + tag: "i256"; + value: undefined; + } | { + tag: "compactU8"; + value: undefined; + } | { + tag: "compactU16"; + value: undefined; + } | { + tag: "compactU32"; + value: undefined; + } | { + tag: "compactU64"; + value: undefined; + } | { + tag: "compactU128"; + value: undefined; + } | { + tag: "compactU256"; + value: undefined; + } | { + tag: "void"; + value: undefined; + } | { + tag: "perId"; + value: number; + })[]; + } | { + tag: "bitSequence"; + value: { + numBytes: number; + leastSignificantBitFirst: boolean; + }; + }; + typeId: number; +}>] & { + enc: _pezkuwi_bizinikiwi_bindings.Encoder<{ + path: string[]; + typeDef: { + tag: "composite"; + value: { + name: string | undefined; + ty: { + tag: "bool"; + value: undefined; + } | { + tag: "char"; + value: undefined; + } | { + tag: "str"; + value: undefined; + } | { + tag: "u8"; + value: undefined; + } | { + tag: "u16"; + value: undefined; + } | { + tag: "u32"; + value: undefined; + } | { + tag: "u64"; + value: undefined; + } | { + tag: "u128"; + value: undefined; + } | { + tag: "u256"; + value: undefined; + } | { + tag: "i8"; + value: undefined; + } | { + tag: "i16"; + value: undefined; + } | { + tag: "i32"; + value: undefined; + } | { + tag: "i64"; + value: undefined; + } | { + tag: "i128"; + value: undefined; + } | { + tag: "i256"; + value: undefined; + } | { + tag: "compactU8"; + value: undefined; + } | { + tag: "compactU16"; + value: undefined; + } | { + tag: "compactU32"; + value: undefined; + } | { + tag: "compactU64"; + value: undefined; + } | { + tag: "compactU128"; + value: undefined; + } | { + tag: "compactU256"; + value: undefined; + } | { + tag: "void"; + value: undefined; + } | { + tag: "perId"; + value: number; + }; + typeName: string | undefined; + }[]; + } | { + tag: "enumeration"; + value: { + name: string; + fields: { + name: string | undefined; + ty: { + tag: "bool"; + value: undefined; + } | { + tag: "char"; + value: undefined; + } | { + tag: "str"; + value: undefined; + } | { + tag: "u8"; + value: undefined; + } | { + tag: "u16"; + value: undefined; + } | { + tag: "u32"; + value: undefined; + } | { + tag: "u64"; + value: undefined; + } | { + tag: "u128"; + value: undefined; + } | { + tag: "u256"; + value: undefined; + } | { + tag: "i8"; + value: undefined; + } | { + tag: "i16"; + value: undefined; + } | { + tag: "i32"; + value: undefined; + } | { + tag: "i64"; + value: undefined; + } | { + tag: "i128"; + value: undefined; + } | { + tag: "i256"; + value: undefined; + } | { + tag: "compactU8"; + value: undefined; + } | { + tag: "compactU16"; + value: undefined; + } | { + tag: "compactU32"; + value: undefined; + } | { + tag: "compactU64"; + value: undefined; + } | { + tag: "compactU128"; + value: undefined; + } | { + tag: "compactU256"; + value: undefined; + } | { + tag: "void"; + value: undefined; + } | { + tag: "perId"; + value: number; + }; + typeName: string | undefined; + }[]; + index: number; + }; + } | { + tag: "sequence"; + value: { + tag: "bool"; + value: undefined; + } | { + tag: "char"; + value: undefined; + } | { + tag: "str"; + value: undefined; + } | { + tag: "u8"; + value: undefined; + } | { + tag: "u16"; + value: undefined; + } | { + tag: "u32"; + value: undefined; + } | { + tag: "u64"; + value: undefined; + } | { + tag: "u128"; + value: undefined; + } | { + tag: "u256"; + value: undefined; + } | { + tag: "i8"; + value: undefined; + } | { + tag: "i16"; + value: undefined; + } | { + tag: "i32"; + value: undefined; + } | { + tag: "i64"; + value: undefined; + } | { + tag: "i128"; + value: undefined; + } | { + tag: "i256"; + value: undefined; + } | { + tag: "compactU8"; + value: undefined; + } | { + tag: "compactU16"; + value: undefined; + } | { + tag: "compactU32"; + value: undefined; + } | { + tag: "compactU64"; + value: undefined; + } | { + tag: "compactU128"; + value: undefined; + } | { + tag: "compactU256"; + value: undefined; + } | { + tag: "void"; + value: undefined; + } | { + tag: "perId"; + value: number; + }; + } | { + tag: "array"; + value: { + len: number; + typeParam: { + tag: "bool"; + value: undefined; + } | { + tag: "char"; + value: undefined; + } | { + tag: "str"; + value: undefined; + } | { + tag: "u8"; + value: undefined; + } | { + tag: "u16"; + value: undefined; + } | { + tag: "u32"; + value: undefined; + } | { + tag: "u64"; + value: undefined; + } | { + tag: "u128"; + value: undefined; + } | { + tag: "u256"; + value: undefined; + } | { + tag: "i8"; + value: undefined; + } | { + tag: "i16"; + value: undefined; + } | { + tag: "i32"; + value: undefined; + } | { + tag: "i64"; + value: undefined; + } | { + tag: "i128"; + value: undefined; + } | { + tag: "i256"; + value: undefined; + } | { + tag: "compactU8"; + value: undefined; + } | { + tag: "compactU16"; + value: undefined; + } | { + tag: "compactU32"; + value: undefined; + } | { + tag: "compactU64"; + value: undefined; + } | { + tag: "compactU128"; + value: undefined; + } | { + tag: "compactU256"; + value: undefined; + } | { + tag: "void"; + value: undefined; + } | { + tag: "perId"; + value: number; + }; + }; + } | { + tag: "tuple"; + value: ({ + tag: "bool"; + value: undefined; + } | { + tag: "char"; + value: undefined; + } | { + tag: "str"; + value: undefined; + } | { + tag: "u8"; + value: undefined; + } | { + tag: "u16"; + value: undefined; + } | { + tag: "u32"; + value: undefined; + } | { + tag: "u64"; + value: undefined; + } | { + tag: "u128"; + value: undefined; + } | { + tag: "u256"; + value: undefined; + } | { + tag: "i8"; + value: undefined; + } | { + tag: "i16"; + value: undefined; + } | { + tag: "i32"; + value: undefined; + } | { + tag: "i64"; + value: undefined; + } | { + tag: "i128"; + value: undefined; + } | { + tag: "i256"; + value: undefined; + } | { + tag: "compactU8"; + value: undefined; + } | { + tag: "compactU16"; + value: undefined; + } | { + tag: "compactU32"; + value: undefined; + } | { + tag: "compactU64"; + value: undefined; + } | { + tag: "compactU128"; + value: undefined; + } | { + tag: "compactU256"; + value: undefined; + } | { + tag: "void"; + value: undefined; + } | { + tag: "perId"; + value: number; + })[]; + } | { + tag: "bitSequence"; + value: { + numBytes: number; + leastSignificantBitFirst: boolean; + }; + }; + typeId: number; + }>; + dec: _pezkuwi_bizinikiwi_bindings.Decoder<{ + path: string[]; + typeDef: { + tag: "composite"; + value: { + name: string | undefined; + ty: { + tag: "bool"; + value: undefined; + } | { + tag: "char"; + value: undefined; + } | { + tag: "str"; + value: undefined; + } | { + tag: "u8"; + value: undefined; + } | { + tag: "u16"; + value: undefined; + } | { + tag: "u32"; + value: undefined; + } | { + tag: "u64"; + value: undefined; + } | { + tag: "u128"; + value: undefined; + } | { + tag: "u256"; + value: undefined; + } | { + tag: "i8"; + value: undefined; + } | { + tag: "i16"; + value: undefined; + } | { + tag: "i32"; + value: undefined; + } | { + tag: "i64"; + value: undefined; + } | { + tag: "i128"; + value: undefined; + } | { + tag: "i256"; + value: undefined; + } | { + tag: "compactU8"; + value: undefined; + } | { + tag: "compactU16"; + value: undefined; + } | { + tag: "compactU32"; + value: undefined; + } | { + tag: "compactU64"; + value: undefined; + } | { + tag: "compactU128"; + value: undefined; + } | { + tag: "compactU256"; + value: undefined; + } | { + tag: "void"; + value: undefined; + } | { + tag: "perId"; + value: number; + }; + typeName: string | undefined; + }[]; + } | { + tag: "enumeration"; + value: { + name: string; + fields: { + name: string | undefined; + ty: { + tag: "bool"; + value: undefined; + } | { + tag: "char"; + value: undefined; + } | { + tag: "str"; + value: undefined; + } | { + tag: "u8"; + value: undefined; + } | { + tag: "u16"; + value: undefined; + } | { + tag: "u32"; + value: undefined; + } | { + tag: "u64"; + value: undefined; + } | { + tag: "u128"; + value: undefined; + } | { + tag: "u256"; + value: undefined; + } | { + tag: "i8"; + value: undefined; + } | { + tag: "i16"; + value: undefined; + } | { + tag: "i32"; + value: undefined; + } | { + tag: "i64"; + value: undefined; + } | { + tag: "i128"; + value: undefined; + } | { + tag: "i256"; + value: undefined; + } | { + tag: "compactU8"; + value: undefined; + } | { + tag: "compactU16"; + value: undefined; + } | { + tag: "compactU32"; + value: undefined; + } | { + tag: "compactU64"; + value: undefined; + } | { + tag: "compactU128"; + value: undefined; + } | { + tag: "compactU256"; + value: undefined; + } | { + tag: "void"; + value: undefined; + } | { + tag: "perId"; + value: number; + }; + typeName: string | undefined; + }[]; + index: number; + }; + } | { + tag: "sequence"; + value: { + tag: "bool"; + value: undefined; + } | { + tag: "char"; + value: undefined; + } | { + tag: "str"; + value: undefined; + } | { + tag: "u8"; + value: undefined; + } | { + tag: "u16"; + value: undefined; + } | { + tag: "u32"; + value: undefined; + } | { + tag: "u64"; + value: undefined; + } | { + tag: "u128"; + value: undefined; + } | { + tag: "u256"; + value: undefined; + } | { + tag: "i8"; + value: undefined; + } | { + tag: "i16"; + value: undefined; + } | { + tag: "i32"; + value: undefined; + } | { + tag: "i64"; + value: undefined; + } | { + tag: "i128"; + value: undefined; + } | { + tag: "i256"; + value: undefined; + } | { + tag: "compactU8"; + value: undefined; + } | { + tag: "compactU16"; + value: undefined; + } | { + tag: "compactU32"; + value: undefined; + } | { + tag: "compactU64"; + value: undefined; + } | { + tag: "compactU128"; + value: undefined; + } | { + tag: "compactU256"; + value: undefined; + } | { + tag: "void"; + value: undefined; + } | { + tag: "perId"; + value: number; + }; + } | { + tag: "array"; + value: { + len: number; + typeParam: { + tag: "bool"; + value: undefined; + } | { + tag: "char"; + value: undefined; + } | { + tag: "str"; + value: undefined; + } | { + tag: "u8"; + value: undefined; + } | { + tag: "u16"; + value: undefined; + } | { + tag: "u32"; + value: undefined; + } | { + tag: "u64"; + value: undefined; + } | { + tag: "u128"; + value: undefined; + } | { + tag: "u256"; + value: undefined; + } | { + tag: "i8"; + value: undefined; + } | { + tag: "i16"; + value: undefined; + } | { + tag: "i32"; + value: undefined; + } | { + tag: "i64"; + value: undefined; + } | { + tag: "i128"; + value: undefined; + } | { + tag: "i256"; + value: undefined; + } | { + tag: "compactU8"; + value: undefined; + } | { + tag: "compactU16"; + value: undefined; + } | { + tag: "compactU32"; + value: undefined; + } | { + tag: "compactU64"; + value: undefined; + } | { + tag: "compactU128"; + value: undefined; + } | { + tag: "compactU256"; + value: undefined; + } | { + tag: "void"; + value: undefined; + } | { + tag: "perId"; + value: number; + }; + }; + } | { + tag: "tuple"; + value: ({ + tag: "bool"; + value: undefined; + } | { + tag: "char"; + value: undefined; + } | { + tag: "str"; + value: undefined; + } | { + tag: "u8"; + value: undefined; + } | { + tag: "u16"; + value: undefined; + } | { + tag: "u32"; + value: undefined; + } | { + tag: "u64"; + value: undefined; + } | { + tag: "u128"; + value: undefined; + } | { + tag: "u256"; + value: undefined; + } | { + tag: "i8"; + value: undefined; + } | { + tag: "i16"; + value: undefined; + } | { + tag: "i32"; + value: undefined; + } | { + tag: "i64"; + value: undefined; + } | { + tag: "i128"; + value: undefined; + } | { + tag: "i256"; + value: undefined; + } | { + tag: "compactU8"; + value: undefined; + } | { + tag: "compactU16"; + value: undefined; + } | { + tag: "compactU32"; + value: undefined; + } | { + tag: "compactU64"; + value: undefined; + } | { + tag: "compactU128"; + value: undefined; + } | { + tag: "compactU256"; + value: undefined; + } | { + tag: "void"; + value: undefined; + } | { + tag: "perId"; + value: number; + })[]; + } | { + tag: "bitSequence"; + value: { + numBytes: number; + leastSignificantBitFirst: boolean; + }; + }; + typeId: number; + }>; +} & { + inner: { + path: [_pezkuwi_bizinikiwi_bindings.Encoder, _pezkuwi_bizinikiwi_bindings.Decoder] & { + enc: _pezkuwi_bizinikiwi_bindings.Encoder; + dec: _pezkuwi_bizinikiwi_bindings.Decoder; + } & { + inner: Codec; + }; + typeDef: [_pezkuwi_bizinikiwi_bindings.Encoder<{ + tag: "composite"; + value: { + name: string | undefined; + ty: { + tag: "bool"; + value: undefined; + } | { + tag: "char"; + value: undefined; + } | { + tag: "str"; + value: undefined; + } | { + tag: "u8"; + value: undefined; + } | { + tag: "u16"; + value: undefined; + } | { + tag: "u32"; + value: undefined; + } | { + tag: "u64"; + value: undefined; + } | { + tag: "u128"; + value: undefined; + } | { + tag: "u256"; + value: undefined; + } | { + tag: "i8"; + value: undefined; + } | { + tag: "i16"; + value: undefined; + } | { + tag: "i32"; + value: undefined; + } | { + tag: "i64"; + value: undefined; + } | { + tag: "i128"; + value: undefined; + } | { + tag: "i256"; + value: undefined; + } | { + tag: "compactU8"; + value: undefined; + } | { + tag: "compactU16"; + value: undefined; + } | { + tag: "compactU32"; + value: undefined; + } | { + tag: "compactU64"; + value: undefined; + } | { + tag: "compactU128"; + value: undefined; + } | { + tag: "compactU256"; + value: undefined; + } | { + tag: "void"; + value: undefined; + } | { + tag: "perId"; + value: number; + }; + typeName: string | undefined; + }[]; + } | { + tag: "enumeration"; + value: { + name: string; + fields: { + name: string | undefined; + ty: { + tag: "bool"; + value: undefined; + } | { + tag: "char"; + value: undefined; + } | { + tag: "str"; + value: undefined; + } | { + tag: "u8"; + value: undefined; + } | { + tag: "u16"; + value: undefined; + } | { + tag: "u32"; + value: undefined; + } | { + tag: "u64"; + value: undefined; + } | { + tag: "u128"; + value: undefined; + } | { + tag: "u256"; + value: undefined; + } | { + tag: "i8"; + value: undefined; + } | { + tag: "i16"; + value: undefined; + } | { + tag: "i32"; + value: undefined; + } | { + tag: "i64"; + value: undefined; + } | { + tag: "i128"; + value: undefined; + } | { + tag: "i256"; + value: undefined; + } | { + tag: "compactU8"; + value: undefined; + } | { + tag: "compactU16"; + value: undefined; + } | { + tag: "compactU32"; + value: undefined; + } | { + tag: "compactU64"; + value: undefined; + } | { + tag: "compactU128"; + value: undefined; + } | { + tag: "compactU256"; + value: undefined; + } | { + tag: "void"; + value: undefined; + } | { + tag: "perId"; + value: number; + }; + typeName: string | undefined; + }[]; + index: number; + }; + } | { + tag: "sequence"; + value: { + tag: "bool"; + value: undefined; + } | { + tag: "char"; + value: undefined; + } | { + tag: "str"; + value: undefined; + } | { + tag: "u8"; + value: undefined; + } | { + tag: "u16"; + value: undefined; + } | { + tag: "u32"; + value: undefined; + } | { + tag: "u64"; + value: undefined; + } | { + tag: "u128"; + value: undefined; + } | { + tag: "u256"; + value: undefined; + } | { + tag: "i8"; + value: undefined; + } | { + tag: "i16"; + value: undefined; + } | { + tag: "i32"; + value: undefined; + } | { + tag: "i64"; + value: undefined; + } | { + tag: "i128"; + value: undefined; + } | { + tag: "i256"; + value: undefined; + } | { + tag: "compactU8"; + value: undefined; + } | { + tag: "compactU16"; + value: undefined; + } | { + tag: "compactU32"; + value: undefined; + } | { + tag: "compactU64"; + value: undefined; + } | { + tag: "compactU128"; + value: undefined; + } | { + tag: "compactU256"; + value: undefined; + } | { + tag: "void"; + value: undefined; + } | { + tag: "perId"; + value: number; + }; + } | { + tag: "array"; + value: { + len: number; + typeParam: { + tag: "bool"; + value: undefined; + } | { + tag: "char"; + value: undefined; + } | { + tag: "str"; + value: undefined; + } | { + tag: "u8"; + value: undefined; + } | { + tag: "u16"; + value: undefined; + } | { + tag: "u32"; + value: undefined; + } | { + tag: "u64"; + value: undefined; + } | { + tag: "u128"; + value: undefined; + } | { + tag: "u256"; + value: undefined; + } | { + tag: "i8"; + value: undefined; + } | { + tag: "i16"; + value: undefined; + } | { + tag: "i32"; + value: undefined; + } | { + tag: "i64"; + value: undefined; + } | { + tag: "i128"; + value: undefined; + } | { + tag: "i256"; + value: undefined; + } | { + tag: "compactU8"; + value: undefined; + } | { + tag: "compactU16"; + value: undefined; + } | { + tag: "compactU32"; + value: undefined; + } | { + tag: "compactU64"; + value: undefined; + } | { + tag: "compactU128"; + value: undefined; + } | { + tag: "compactU256"; + value: undefined; + } | { + tag: "void"; + value: undefined; + } | { + tag: "perId"; + value: number; + }; + }; + } | { + tag: "tuple"; + value: ({ + tag: "bool"; + value: undefined; + } | { + tag: "char"; + value: undefined; + } | { + tag: "str"; + value: undefined; + } | { + tag: "u8"; + value: undefined; + } | { + tag: "u16"; + value: undefined; + } | { + tag: "u32"; + value: undefined; + } | { + tag: "u64"; + value: undefined; + } | { + tag: "u128"; + value: undefined; + } | { + tag: "u256"; + value: undefined; + } | { + tag: "i8"; + value: undefined; + } | { + tag: "i16"; + value: undefined; + } | { + tag: "i32"; + value: undefined; + } | { + tag: "i64"; + value: undefined; + } | { + tag: "i128"; + value: undefined; + } | { + tag: "i256"; + value: undefined; + } | { + tag: "compactU8"; + value: undefined; + } | { + tag: "compactU16"; + value: undefined; + } | { + tag: "compactU32"; + value: undefined; + } | { + tag: "compactU64"; + value: undefined; + } | { + tag: "compactU128"; + value: undefined; + } | { + tag: "compactU256"; + value: undefined; + } | { + tag: "void"; + value: undefined; + } | { + tag: "perId"; + value: number; + })[]; + } | { + tag: "bitSequence"; + value: { + numBytes: number; + leastSignificantBitFirst: boolean; + }; + }>, _pezkuwi_bizinikiwi_bindings.Decoder<{ + tag: "composite"; + value: { + name: string | undefined; + ty: { + tag: "bool"; + value: undefined; + } | { + tag: "char"; + value: undefined; + } | { + tag: "str"; + value: undefined; + } | { + tag: "u8"; + value: undefined; + } | { + tag: "u16"; + value: undefined; + } | { + tag: "u32"; + value: undefined; + } | { + tag: "u64"; + value: undefined; + } | { + tag: "u128"; + value: undefined; + } | { + tag: "u256"; + value: undefined; + } | { + tag: "i8"; + value: undefined; + } | { + tag: "i16"; + value: undefined; + } | { + tag: "i32"; + value: undefined; + } | { + tag: "i64"; + value: undefined; + } | { + tag: "i128"; + value: undefined; + } | { + tag: "i256"; + value: undefined; + } | { + tag: "compactU8"; + value: undefined; + } | { + tag: "compactU16"; + value: undefined; + } | { + tag: "compactU32"; + value: undefined; + } | { + tag: "compactU64"; + value: undefined; + } | { + tag: "compactU128"; + value: undefined; + } | { + tag: "compactU256"; + value: undefined; + } | { + tag: "void"; + value: undefined; + } | { + tag: "perId"; + value: number; + }; + typeName: string | undefined; + }[]; + } | { + tag: "enumeration"; + value: { + name: string; + fields: { + name: string | undefined; + ty: { + tag: "bool"; + value: undefined; + } | { + tag: "char"; + value: undefined; + } | { + tag: "str"; + value: undefined; + } | { + tag: "u8"; + value: undefined; + } | { + tag: "u16"; + value: undefined; + } | { + tag: "u32"; + value: undefined; + } | { + tag: "u64"; + value: undefined; + } | { + tag: "u128"; + value: undefined; + } | { + tag: "u256"; + value: undefined; + } | { + tag: "i8"; + value: undefined; + } | { + tag: "i16"; + value: undefined; + } | { + tag: "i32"; + value: undefined; + } | { + tag: "i64"; + value: undefined; + } | { + tag: "i128"; + value: undefined; + } | { + tag: "i256"; + value: undefined; + } | { + tag: "compactU8"; + value: undefined; + } | { + tag: "compactU16"; + value: undefined; + } | { + tag: "compactU32"; + value: undefined; + } | { + tag: "compactU64"; + value: undefined; + } | { + tag: "compactU128"; + value: undefined; + } | { + tag: "compactU256"; + value: undefined; + } | { + tag: "void"; + value: undefined; + } | { + tag: "perId"; + value: number; + }; + typeName: string | undefined; + }[]; + index: number; + }; + } | { + tag: "sequence"; + value: { + tag: "bool"; + value: undefined; + } | { + tag: "char"; + value: undefined; + } | { + tag: "str"; + value: undefined; + } | { + tag: "u8"; + value: undefined; + } | { + tag: "u16"; + value: undefined; + } | { + tag: "u32"; + value: undefined; + } | { + tag: "u64"; + value: undefined; + } | { + tag: "u128"; + value: undefined; + } | { + tag: "u256"; + value: undefined; + } | { + tag: "i8"; + value: undefined; + } | { + tag: "i16"; + value: undefined; + } | { + tag: "i32"; + value: undefined; + } | { + tag: "i64"; + value: undefined; + } | { + tag: "i128"; + value: undefined; + } | { + tag: "i256"; + value: undefined; + } | { + tag: "compactU8"; + value: undefined; + } | { + tag: "compactU16"; + value: undefined; + } | { + tag: "compactU32"; + value: undefined; + } | { + tag: "compactU64"; + value: undefined; + } | { + tag: "compactU128"; + value: undefined; + } | { + tag: "compactU256"; + value: undefined; + } | { + tag: "void"; + value: undefined; + } | { + tag: "perId"; + value: number; + }; + } | { + tag: "array"; + value: { + len: number; + typeParam: { + tag: "bool"; + value: undefined; + } | { + tag: "char"; + value: undefined; + } | { + tag: "str"; + value: undefined; + } | { + tag: "u8"; + value: undefined; + } | { + tag: "u16"; + value: undefined; + } | { + tag: "u32"; + value: undefined; + } | { + tag: "u64"; + value: undefined; + } | { + tag: "u128"; + value: undefined; + } | { + tag: "u256"; + value: undefined; + } | { + tag: "i8"; + value: undefined; + } | { + tag: "i16"; + value: undefined; + } | { + tag: "i32"; + value: undefined; + } | { + tag: "i64"; + value: undefined; + } | { + tag: "i128"; + value: undefined; + } | { + tag: "i256"; + value: undefined; + } | { + tag: "compactU8"; + value: undefined; + } | { + tag: "compactU16"; + value: undefined; + } | { + tag: "compactU32"; + value: undefined; + } | { + tag: "compactU64"; + value: undefined; + } | { + tag: "compactU128"; + value: undefined; + } | { + tag: "compactU256"; + value: undefined; + } | { + tag: "void"; + value: undefined; + } | { + tag: "perId"; + value: number; + }; + }; + } | { + tag: "tuple"; + value: ({ + tag: "bool"; + value: undefined; + } | { + tag: "char"; + value: undefined; + } | { + tag: "str"; + value: undefined; + } | { + tag: "u8"; + value: undefined; + } | { + tag: "u16"; + value: undefined; + } | { + tag: "u32"; + value: undefined; + } | { + tag: "u64"; + value: undefined; + } | { + tag: "u128"; + value: undefined; + } | { + tag: "u256"; + value: undefined; + } | { + tag: "i8"; + value: undefined; + } | { + tag: "i16"; + value: undefined; + } | { + tag: "i32"; + value: undefined; + } | { + tag: "i64"; + value: undefined; + } | { + tag: "i128"; + value: undefined; + } | { + tag: "i256"; + value: undefined; + } | { + tag: "compactU8"; + value: undefined; + } | { + tag: "compactU16"; + value: undefined; + } | { + tag: "compactU32"; + value: undefined; + } | { + tag: "compactU64"; + value: undefined; + } | { + tag: "compactU128"; + value: undefined; + } | { + tag: "compactU256"; + value: undefined; + } | { + tag: "void"; + value: undefined; + } | { + tag: "perId"; + value: number; + })[]; + } | { + tag: "bitSequence"; + value: { + numBytes: number; + leastSignificantBitFirst: boolean; + }; + }>] & { + enc: _pezkuwi_bizinikiwi_bindings.Encoder<{ + tag: "composite"; + value: { + name: string | undefined; + ty: { + tag: "bool"; + value: undefined; + } | { + tag: "char"; + value: undefined; + } | { + tag: "str"; + value: undefined; + } | { + tag: "u8"; + value: undefined; + } | { + tag: "u16"; + value: undefined; + } | { + tag: "u32"; + value: undefined; + } | { + tag: "u64"; + value: undefined; + } | { + tag: "u128"; + value: undefined; + } | { + tag: "u256"; + value: undefined; + } | { + tag: "i8"; + value: undefined; + } | { + tag: "i16"; + value: undefined; + } | { + tag: "i32"; + value: undefined; + } | { + tag: "i64"; + value: undefined; + } | { + tag: "i128"; + value: undefined; + } | { + tag: "i256"; + value: undefined; + } | { + tag: "compactU8"; + value: undefined; + } | { + tag: "compactU16"; + value: undefined; + } | { + tag: "compactU32"; + value: undefined; + } | { + tag: "compactU64"; + value: undefined; + } | { + tag: "compactU128"; + value: undefined; + } | { + tag: "compactU256"; + value: undefined; + } | { + tag: "void"; + value: undefined; + } | { + tag: "perId"; + value: number; + }; + typeName: string | undefined; + }[]; + } | { + tag: "enumeration"; + value: { + name: string; + fields: { + name: string | undefined; + ty: { + tag: "bool"; + value: undefined; + } | { + tag: "char"; + value: undefined; + } | { + tag: "str"; + value: undefined; + } | { + tag: "u8"; + value: undefined; + } | { + tag: "u16"; + value: undefined; + } | { + tag: "u32"; + value: undefined; + } | { + tag: "u64"; + value: undefined; + } | { + tag: "u128"; + value: undefined; + } | { + tag: "u256"; + value: undefined; + } | { + tag: "i8"; + value: undefined; + } | { + tag: "i16"; + value: undefined; + } | { + tag: "i32"; + value: undefined; + } | { + tag: "i64"; + value: undefined; + } | { + tag: "i128"; + value: undefined; + } | { + tag: "i256"; + value: undefined; + } | { + tag: "compactU8"; + value: undefined; + } | { + tag: "compactU16"; + value: undefined; + } | { + tag: "compactU32"; + value: undefined; + } | { + tag: "compactU64"; + value: undefined; + } | { + tag: "compactU128"; + value: undefined; + } | { + tag: "compactU256"; + value: undefined; + } | { + tag: "void"; + value: undefined; + } | { + tag: "perId"; + value: number; + }; + typeName: string | undefined; + }[]; + index: number; + }; + } | { + tag: "sequence"; + value: { + tag: "bool"; + value: undefined; + } | { + tag: "char"; + value: undefined; + } | { + tag: "str"; + value: undefined; + } | { + tag: "u8"; + value: undefined; + } | { + tag: "u16"; + value: undefined; + } | { + tag: "u32"; + value: undefined; + } | { + tag: "u64"; + value: undefined; + } | { + tag: "u128"; + value: undefined; + } | { + tag: "u256"; + value: undefined; + } | { + tag: "i8"; + value: undefined; + } | { + tag: "i16"; + value: undefined; + } | { + tag: "i32"; + value: undefined; + } | { + tag: "i64"; + value: undefined; + } | { + tag: "i128"; + value: undefined; + } | { + tag: "i256"; + value: undefined; + } | { + tag: "compactU8"; + value: undefined; + } | { + tag: "compactU16"; + value: undefined; + } | { + tag: "compactU32"; + value: undefined; + } | { + tag: "compactU64"; + value: undefined; + } | { + tag: "compactU128"; + value: undefined; + } | { + tag: "compactU256"; + value: undefined; + } | { + tag: "void"; + value: undefined; + } | { + tag: "perId"; + value: number; + }; + } | { + tag: "array"; + value: { + len: number; + typeParam: { + tag: "bool"; + value: undefined; + } | { + tag: "char"; + value: undefined; + } | { + tag: "str"; + value: undefined; + } | { + tag: "u8"; + value: undefined; + } | { + tag: "u16"; + value: undefined; + } | { + tag: "u32"; + value: undefined; + } | { + tag: "u64"; + value: undefined; + } | { + tag: "u128"; + value: undefined; + } | { + tag: "u256"; + value: undefined; + } | { + tag: "i8"; + value: undefined; + } | { + tag: "i16"; + value: undefined; + } | { + tag: "i32"; + value: undefined; + } | { + tag: "i64"; + value: undefined; + } | { + tag: "i128"; + value: undefined; + } | { + tag: "i256"; + value: undefined; + } | { + tag: "compactU8"; + value: undefined; + } | { + tag: "compactU16"; + value: undefined; + } | { + tag: "compactU32"; + value: undefined; + } | { + tag: "compactU64"; + value: undefined; + } | { + tag: "compactU128"; + value: undefined; + } | { + tag: "compactU256"; + value: undefined; + } | { + tag: "void"; + value: undefined; + } | { + tag: "perId"; + value: number; + }; + }; + } | { + tag: "tuple"; + value: ({ + tag: "bool"; + value: undefined; + } | { + tag: "char"; + value: undefined; + } | { + tag: "str"; + value: undefined; + } | { + tag: "u8"; + value: undefined; + } | { + tag: "u16"; + value: undefined; + } | { + tag: "u32"; + value: undefined; + } | { + tag: "u64"; + value: undefined; + } | { + tag: "u128"; + value: undefined; + } | { + tag: "u256"; + value: undefined; + } | { + tag: "i8"; + value: undefined; + } | { + tag: "i16"; + value: undefined; + } | { + tag: "i32"; + value: undefined; + } | { + tag: "i64"; + value: undefined; + } | { + tag: "i128"; + value: undefined; + } | { + tag: "i256"; + value: undefined; + } | { + tag: "compactU8"; + value: undefined; + } | { + tag: "compactU16"; + value: undefined; + } | { + tag: "compactU32"; + value: undefined; + } | { + tag: "compactU64"; + value: undefined; + } | { + tag: "compactU128"; + value: undefined; + } | { + tag: "compactU256"; + value: undefined; + } | { + tag: "void"; + value: undefined; + } | { + tag: "perId"; + value: number; + })[]; + } | { + tag: "bitSequence"; + value: { + numBytes: number; + leastSignificantBitFirst: boolean; + }; + }>; + dec: _pezkuwi_bizinikiwi_bindings.Decoder<{ + tag: "composite"; + value: { + name: string | undefined; + ty: { + tag: "bool"; + value: undefined; + } | { + tag: "char"; + value: undefined; + } | { + tag: "str"; + value: undefined; + } | { + tag: "u8"; + value: undefined; + } | { + tag: "u16"; + value: undefined; + } | { + tag: "u32"; + value: undefined; + } | { + tag: "u64"; + value: undefined; + } | { + tag: "u128"; + value: undefined; + } | { + tag: "u256"; + value: undefined; + } | { + tag: "i8"; + value: undefined; + } | { + tag: "i16"; + value: undefined; + } | { + tag: "i32"; + value: undefined; + } | { + tag: "i64"; + value: undefined; + } | { + tag: "i128"; + value: undefined; + } | { + tag: "i256"; + value: undefined; + } | { + tag: "compactU8"; + value: undefined; + } | { + tag: "compactU16"; + value: undefined; + } | { + tag: "compactU32"; + value: undefined; + } | { + tag: "compactU64"; + value: undefined; + } | { + tag: "compactU128"; + value: undefined; + } | { + tag: "compactU256"; + value: undefined; + } | { + tag: "void"; + value: undefined; + } | { + tag: "perId"; + value: number; + }; + typeName: string | undefined; + }[]; + } | { + tag: "enumeration"; + value: { + name: string; + fields: { + name: string | undefined; + ty: { + tag: "bool"; + value: undefined; + } | { + tag: "char"; + value: undefined; + } | { + tag: "str"; + value: undefined; + } | { + tag: "u8"; + value: undefined; + } | { + tag: "u16"; + value: undefined; + } | { + tag: "u32"; + value: undefined; + } | { + tag: "u64"; + value: undefined; + } | { + tag: "u128"; + value: undefined; + } | { + tag: "u256"; + value: undefined; + } | { + tag: "i8"; + value: undefined; + } | { + tag: "i16"; + value: undefined; + } | { + tag: "i32"; + value: undefined; + } | { + tag: "i64"; + value: undefined; + } | { + tag: "i128"; + value: undefined; + } | { + tag: "i256"; + value: undefined; + } | { + tag: "compactU8"; + value: undefined; + } | { + tag: "compactU16"; + value: undefined; + } | { + tag: "compactU32"; + value: undefined; + } | { + tag: "compactU64"; + value: undefined; + } | { + tag: "compactU128"; + value: undefined; + } | { + tag: "compactU256"; + value: undefined; + } | { + tag: "void"; + value: undefined; + } | { + tag: "perId"; + value: number; + }; + typeName: string | undefined; + }[]; + index: number; + }; + } | { + tag: "sequence"; + value: { + tag: "bool"; + value: undefined; + } | { + tag: "char"; + value: undefined; + } | { + tag: "str"; + value: undefined; + } | { + tag: "u8"; + value: undefined; + } | { + tag: "u16"; + value: undefined; + } | { + tag: "u32"; + value: undefined; + } | { + tag: "u64"; + value: undefined; + } | { + tag: "u128"; + value: undefined; + } | { + tag: "u256"; + value: undefined; + } | { + tag: "i8"; + value: undefined; + } | { + tag: "i16"; + value: undefined; + } | { + tag: "i32"; + value: undefined; + } | { + tag: "i64"; + value: undefined; + } | { + tag: "i128"; + value: undefined; + } | { + tag: "i256"; + value: undefined; + } | { + tag: "compactU8"; + value: undefined; + } | { + tag: "compactU16"; + value: undefined; + } | { + tag: "compactU32"; + value: undefined; + } | { + tag: "compactU64"; + value: undefined; + } | { + tag: "compactU128"; + value: undefined; + } | { + tag: "compactU256"; + value: undefined; + } | { + tag: "void"; + value: undefined; + } | { + tag: "perId"; + value: number; + }; + } | { + tag: "array"; + value: { + len: number; + typeParam: { + tag: "bool"; + value: undefined; + } | { + tag: "char"; + value: undefined; + } | { + tag: "str"; + value: undefined; + } | { + tag: "u8"; + value: undefined; + } | { + tag: "u16"; + value: undefined; + } | { + tag: "u32"; + value: undefined; + } | { + tag: "u64"; + value: undefined; + } | { + tag: "u128"; + value: undefined; + } | { + tag: "u256"; + value: undefined; + } | { + tag: "i8"; + value: undefined; + } | { + tag: "i16"; + value: undefined; + } | { + tag: "i32"; + value: undefined; + } | { + tag: "i64"; + value: undefined; + } | { + tag: "i128"; + value: undefined; + } | { + tag: "i256"; + value: undefined; + } | { + tag: "compactU8"; + value: undefined; + } | { + tag: "compactU16"; + value: undefined; + } | { + tag: "compactU32"; + value: undefined; + } | { + tag: "compactU64"; + value: undefined; + } | { + tag: "compactU128"; + value: undefined; + } | { + tag: "compactU256"; + value: undefined; + } | { + tag: "void"; + value: undefined; + } | { + tag: "perId"; + value: number; + }; + }; + } | { + tag: "tuple"; + value: ({ + tag: "bool"; + value: undefined; + } | { + tag: "char"; + value: undefined; + } | { + tag: "str"; + value: undefined; + } | { + tag: "u8"; + value: undefined; + } | { + tag: "u16"; + value: undefined; + } | { + tag: "u32"; + value: undefined; + } | { + tag: "u64"; + value: undefined; + } | { + tag: "u128"; + value: undefined; + } | { + tag: "u256"; + value: undefined; + } | { + tag: "i8"; + value: undefined; + } | { + tag: "i16"; + value: undefined; + } | { + tag: "i32"; + value: undefined; + } | { + tag: "i64"; + value: undefined; + } | { + tag: "i128"; + value: undefined; + } | { + tag: "i256"; + value: undefined; + } | { + tag: "compactU8"; + value: undefined; + } | { + tag: "compactU16"; + value: undefined; + } | { + tag: "compactU32"; + value: undefined; + } | { + tag: "compactU64"; + value: undefined; + } | { + tag: "compactU128"; + value: undefined; + } | { + tag: "compactU256"; + value: undefined; + } | { + tag: "void"; + value: undefined; + } | { + tag: "perId"; + value: number; + })[]; + } | { + tag: "bitSequence"; + value: { + numBytes: number; + leastSignificantBitFirst: boolean; + }; + }>; + } & { + inner: { + composite: [_pezkuwi_bizinikiwi_bindings.Encoder<{ + name: string | undefined; + ty: { + tag: "bool"; + value: undefined; + } | { + tag: "char"; + value: undefined; + } | { + tag: "str"; + value: undefined; + } | { + tag: "u8"; + value: undefined; + } | { + tag: "u16"; + value: undefined; + } | { + tag: "u32"; + value: undefined; + } | { + tag: "u64"; + value: undefined; + } | { + tag: "u128"; + value: undefined; + } | { + tag: "u256"; + value: undefined; + } | { + tag: "i8"; + value: undefined; + } | { + tag: "i16"; + value: undefined; + } | { + tag: "i32"; + value: undefined; + } | { + tag: "i64"; + value: undefined; + } | { + tag: "i128"; + value: undefined; + } | { + tag: "i256"; + value: undefined; + } | { + tag: "compactU8"; + value: undefined; + } | { + tag: "compactU16"; + value: undefined; + } | { + tag: "compactU32"; + value: undefined; + } | { + tag: "compactU64"; + value: undefined; + } | { + tag: "compactU128"; + value: undefined; + } | { + tag: "compactU256"; + value: undefined; + } | { + tag: "void"; + value: undefined; + } | { + tag: "perId"; + value: number; + }; + typeName: string | undefined; + }[]>, _pezkuwi_bizinikiwi_bindings.Decoder<{ + name: string | undefined; + ty: { + tag: "bool"; + value: undefined; + } | { + tag: "char"; + value: undefined; + } | { + tag: "str"; + value: undefined; + } | { + tag: "u8"; + value: undefined; + } | { + tag: "u16"; + value: undefined; + } | { + tag: "u32"; + value: undefined; + } | { + tag: "u64"; + value: undefined; + } | { + tag: "u128"; + value: undefined; + } | { + tag: "u256"; + value: undefined; + } | { + tag: "i8"; + value: undefined; + } | { + tag: "i16"; + value: undefined; + } | { + tag: "i32"; + value: undefined; + } | { + tag: "i64"; + value: undefined; + } | { + tag: "i128"; + value: undefined; + } | { + tag: "i256"; + value: undefined; + } | { + tag: "compactU8"; + value: undefined; + } | { + tag: "compactU16"; + value: undefined; + } | { + tag: "compactU32"; + value: undefined; + } | { + tag: "compactU64"; + value: undefined; + } | { + tag: "compactU128"; + value: undefined; + } | { + tag: "compactU256"; + value: undefined; + } | { + tag: "void"; + value: undefined; + } | { + tag: "perId"; + value: number; + }; + typeName: string | undefined; + }[]>] & { + enc: _pezkuwi_bizinikiwi_bindings.Encoder<{ + name: string | undefined; + ty: { + tag: "bool"; + value: undefined; + } | { + tag: "char"; + value: undefined; + } | { + tag: "str"; + value: undefined; + } | { + tag: "u8"; + value: undefined; + } | { + tag: "u16"; + value: undefined; + } | { + tag: "u32"; + value: undefined; + } | { + tag: "u64"; + value: undefined; + } | { + tag: "u128"; + value: undefined; + } | { + tag: "u256"; + value: undefined; + } | { + tag: "i8"; + value: undefined; + } | { + tag: "i16"; + value: undefined; + } | { + tag: "i32"; + value: undefined; + } | { + tag: "i64"; + value: undefined; + } | { + tag: "i128"; + value: undefined; + } | { + tag: "i256"; + value: undefined; + } | { + tag: "compactU8"; + value: undefined; + } | { + tag: "compactU16"; + value: undefined; + } | { + tag: "compactU32"; + value: undefined; + } | { + tag: "compactU64"; + value: undefined; + } | { + tag: "compactU128"; + value: undefined; + } | { + tag: "compactU256"; + value: undefined; + } | { + tag: "void"; + value: undefined; + } | { + tag: "perId"; + value: number; + }; + typeName: string | undefined; + }[]>; + dec: _pezkuwi_bizinikiwi_bindings.Decoder<{ + name: string | undefined; + ty: { + tag: "bool"; + value: undefined; + } | { + tag: "char"; + value: undefined; + } | { + tag: "str"; + value: undefined; + } | { + tag: "u8"; + value: undefined; + } | { + tag: "u16"; + value: undefined; + } | { + tag: "u32"; + value: undefined; + } | { + tag: "u64"; + value: undefined; + } | { + tag: "u128"; + value: undefined; + } | { + tag: "u256"; + value: undefined; + } | { + tag: "i8"; + value: undefined; + } | { + tag: "i16"; + value: undefined; + } | { + tag: "i32"; + value: undefined; + } | { + tag: "i64"; + value: undefined; + } | { + tag: "i128"; + value: undefined; + } | { + tag: "i256"; + value: undefined; + } | { + tag: "compactU8"; + value: undefined; + } | { + tag: "compactU16"; + value: undefined; + } | { + tag: "compactU32"; + value: undefined; + } | { + tag: "compactU64"; + value: undefined; + } | { + tag: "compactU128"; + value: undefined; + } | { + tag: "compactU256"; + value: undefined; + } | { + tag: "void"; + value: undefined; + } | { + tag: "perId"; + value: number; + }; + typeName: string | undefined; + }[]>; + } & { + inner: Codec<{ + name: string | undefined; + ty: { + tag: "bool"; + value: undefined; + } | { + tag: "char"; + value: undefined; + } | { + tag: "str"; + value: undefined; + } | { + tag: "u8"; + value: undefined; + } | { + tag: "u16"; + value: undefined; + } | { + tag: "u32"; + value: undefined; + } | { + tag: "u64"; + value: undefined; + } | { + tag: "u128"; + value: undefined; + } | { + tag: "u256"; + value: undefined; + } | { + tag: "i8"; + value: undefined; + } | { + tag: "i16"; + value: undefined; + } | { + tag: "i32"; + value: undefined; + } | { + tag: "i64"; + value: undefined; + } | { + tag: "i128"; + value: undefined; + } | { + tag: "i256"; + value: undefined; + } | { + tag: "compactU8"; + value: undefined; + } | { + tag: "compactU16"; + value: undefined; + } | { + tag: "compactU32"; + value: undefined; + } | { + tag: "compactU64"; + value: undefined; + } | { + tag: "compactU128"; + value: undefined; + } | { + tag: "compactU256"; + value: undefined; + } | { + tag: "void"; + value: undefined; + } | { + tag: "perId"; + value: number; + }; + typeName: string | undefined; + }>; + }; + enumeration: [_pezkuwi_bizinikiwi_bindings.Encoder<{ + name: string; + fields: { + name: string | undefined; + ty: { + tag: "bool"; + value: undefined; + } | { + tag: "char"; + value: undefined; + } | { + tag: "str"; + value: undefined; + } | { + tag: "u8"; + value: undefined; + } | { + tag: "u16"; + value: undefined; + } | { + tag: "u32"; + value: undefined; + } | { + tag: "u64"; + value: undefined; + } | { + tag: "u128"; + value: undefined; + } | { + tag: "u256"; + value: undefined; + } | { + tag: "i8"; + value: undefined; + } | { + tag: "i16"; + value: undefined; + } | { + tag: "i32"; + value: undefined; + } | { + tag: "i64"; + value: undefined; + } | { + tag: "i128"; + value: undefined; + } | { + tag: "i256"; + value: undefined; + } | { + tag: "compactU8"; + value: undefined; + } | { + tag: "compactU16"; + value: undefined; + } | { + tag: "compactU32"; + value: undefined; + } | { + tag: "compactU64"; + value: undefined; + } | { + tag: "compactU128"; + value: undefined; + } | { + tag: "compactU256"; + value: undefined; + } | { + tag: "void"; + value: undefined; + } | { + tag: "perId"; + value: number; + }; + typeName: string | undefined; + }[]; + index: number; + }>, _pezkuwi_bizinikiwi_bindings.Decoder<{ + name: string; + fields: { + name: string | undefined; + ty: { + tag: "bool"; + value: undefined; + } | { + tag: "char"; + value: undefined; + } | { + tag: "str"; + value: undefined; + } | { + tag: "u8"; + value: undefined; + } | { + tag: "u16"; + value: undefined; + } | { + tag: "u32"; + value: undefined; + } | { + tag: "u64"; + value: undefined; + } | { + tag: "u128"; + value: undefined; + } | { + tag: "u256"; + value: undefined; + } | { + tag: "i8"; + value: undefined; + } | { + tag: "i16"; + value: undefined; + } | { + tag: "i32"; + value: undefined; + } | { + tag: "i64"; + value: undefined; + } | { + tag: "i128"; + value: undefined; + } | { + tag: "i256"; + value: undefined; + } | { + tag: "compactU8"; + value: undefined; + } | { + tag: "compactU16"; + value: undefined; + } | { + tag: "compactU32"; + value: undefined; + } | { + tag: "compactU64"; + value: undefined; + } | { + tag: "compactU128"; + value: undefined; + } | { + tag: "compactU256"; + value: undefined; + } | { + tag: "void"; + value: undefined; + } | { + tag: "perId"; + value: number; + }; + typeName: string | undefined; + }[]; + index: number; + }>] & { + enc: _pezkuwi_bizinikiwi_bindings.Encoder<{ + name: string; + fields: { + name: string | undefined; + ty: { + tag: "bool"; + value: undefined; + } | { + tag: "char"; + value: undefined; + } | { + tag: "str"; + value: undefined; + } | { + tag: "u8"; + value: undefined; + } | { + tag: "u16"; + value: undefined; + } | { + tag: "u32"; + value: undefined; + } | { + tag: "u64"; + value: undefined; + } | { + tag: "u128"; + value: undefined; + } | { + tag: "u256"; + value: undefined; + } | { + tag: "i8"; + value: undefined; + } | { + tag: "i16"; + value: undefined; + } | { + tag: "i32"; + value: undefined; + } | { + tag: "i64"; + value: undefined; + } | { + tag: "i128"; + value: undefined; + } | { + tag: "i256"; + value: undefined; + } | { + tag: "compactU8"; + value: undefined; + } | { + tag: "compactU16"; + value: undefined; + } | { + tag: "compactU32"; + value: undefined; + } | { + tag: "compactU64"; + value: undefined; + } | { + tag: "compactU128"; + value: undefined; + } | { + tag: "compactU256"; + value: undefined; + } | { + tag: "void"; + value: undefined; + } | { + tag: "perId"; + value: number; + }; + typeName: string | undefined; + }[]; + index: number; + }>; + dec: _pezkuwi_bizinikiwi_bindings.Decoder<{ + name: string; + fields: { + name: string | undefined; + ty: { + tag: "bool"; + value: undefined; + } | { + tag: "char"; + value: undefined; + } | { + tag: "str"; + value: undefined; + } | { + tag: "u8"; + value: undefined; + } | { + tag: "u16"; + value: undefined; + } | { + tag: "u32"; + value: undefined; + } | { + tag: "u64"; + value: undefined; + } | { + tag: "u128"; + value: undefined; + } | { + tag: "u256"; + value: undefined; + } | { + tag: "i8"; + value: undefined; + } | { + tag: "i16"; + value: undefined; + } | { + tag: "i32"; + value: undefined; + } | { + tag: "i64"; + value: undefined; + } | { + tag: "i128"; + value: undefined; + } | { + tag: "i256"; + value: undefined; + } | { + tag: "compactU8"; + value: undefined; + } | { + tag: "compactU16"; + value: undefined; + } | { + tag: "compactU32"; + value: undefined; + } | { + tag: "compactU64"; + value: undefined; + } | { + tag: "compactU128"; + value: undefined; + } | { + tag: "compactU256"; + value: undefined; + } | { + tag: "void"; + value: undefined; + } | { + tag: "perId"; + value: number; + }; + typeName: string | undefined; + }[]; + index: number; + }>; + } & { + inner: { + name: Codec; + fields: [_pezkuwi_bizinikiwi_bindings.Encoder<{ + name: string | undefined; + ty: { + tag: "bool"; + value: undefined; + } | { + tag: "char"; + value: undefined; + } | { + tag: "str"; + value: undefined; + } | { + tag: "u8"; + value: undefined; + } | { + tag: "u16"; + value: undefined; + } | { + tag: "u32"; + value: undefined; + } | { + tag: "u64"; + value: undefined; + } | { + tag: "u128"; + value: undefined; + } | { + tag: "u256"; + value: undefined; + } | { + tag: "i8"; + value: undefined; + } | { + tag: "i16"; + value: undefined; + } | { + tag: "i32"; + value: undefined; + } | { + tag: "i64"; + value: undefined; + } | { + tag: "i128"; + value: undefined; + } | { + tag: "i256"; + value: undefined; + } | { + tag: "compactU8"; + value: undefined; + } | { + tag: "compactU16"; + value: undefined; + } | { + tag: "compactU32"; + value: undefined; + } | { + tag: "compactU64"; + value: undefined; + } | { + tag: "compactU128"; + value: undefined; + } | { + tag: "compactU256"; + value: undefined; + } | { + tag: "void"; + value: undefined; + } | { + tag: "perId"; + value: number; + }; + typeName: string | undefined; + }[]>, _pezkuwi_bizinikiwi_bindings.Decoder<{ + name: string | undefined; + ty: { + tag: "bool"; + value: undefined; + } | { + tag: "char"; + value: undefined; + } | { + tag: "str"; + value: undefined; + } | { + tag: "u8"; + value: undefined; + } | { + tag: "u16"; + value: undefined; + } | { + tag: "u32"; + value: undefined; + } | { + tag: "u64"; + value: undefined; + } | { + tag: "u128"; + value: undefined; + } | { + tag: "u256"; + value: undefined; + } | { + tag: "i8"; + value: undefined; + } | { + tag: "i16"; + value: undefined; + } | { + tag: "i32"; + value: undefined; + } | { + tag: "i64"; + value: undefined; + } | { + tag: "i128"; + value: undefined; + } | { + tag: "i256"; + value: undefined; + } | { + tag: "compactU8"; + value: undefined; + } | { + tag: "compactU16"; + value: undefined; + } | { + tag: "compactU32"; + value: undefined; + } | { + tag: "compactU64"; + value: undefined; + } | { + tag: "compactU128"; + value: undefined; + } | { + tag: "compactU256"; + value: undefined; + } | { + tag: "void"; + value: undefined; + } | { + tag: "perId"; + value: number; + }; + typeName: string | undefined; + }[]>] & { + enc: _pezkuwi_bizinikiwi_bindings.Encoder<{ + name: string | undefined; + ty: { + tag: "bool"; + value: undefined; + } | { + tag: "char"; + value: undefined; + } | { + tag: "str"; + value: undefined; + } | { + tag: "u8"; + value: undefined; + } | { + tag: "u16"; + value: undefined; + } | { + tag: "u32"; + value: undefined; + } | { + tag: "u64"; + value: undefined; + } | { + tag: "u128"; + value: undefined; + } | { + tag: "u256"; + value: undefined; + } | { + tag: "i8"; + value: undefined; + } | { + tag: "i16"; + value: undefined; + } | { + tag: "i32"; + value: undefined; + } | { + tag: "i64"; + value: undefined; + } | { + tag: "i128"; + value: undefined; + } | { + tag: "i256"; + value: undefined; + } | { + tag: "compactU8"; + value: undefined; + } | { + tag: "compactU16"; + value: undefined; + } | { + tag: "compactU32"; + value: undefined; + } | { + tag: "compactU64"; + value: undefined; + } | { + tag: "compactU128"; + value: undefined; + } | { + tag: "compactU256"; + value: undefined; + } | { + tag: "void"; + value: undefined; + } | { + tag: "perId"; + value: number; + }; + typeName: string | undefined; + }[]>; + dec: _pezkuwi_bizinikiwi_bindings.Decoder<{ + name: string | undefined; + ty: { + tag: "bool"; + value: undefined; + } | { + tag: "char"; + value: undefined; + } | { + tag: "str"; + value: undefined; + } | { + tag: "u8"; + value: undefined; + } | { + tag: "u16"; + value: undefined; + } | { + tag: "u32"; + value: undefined; + } | { + tag: "u64"; + value: undefined; + } | { + tag: "u128"; + value: undefined; + } | { + tag: "u256"; + value: undefined; + } | { + tag: "i8"; + value: undefined; + } | { + tag: "i16"; + value: undefined; + } | { + tag: "i32"; + value: undefined; + } | { + tag: "i64"; + value: undefined; + } | { + tag: "i128"; + value: undefined; + } | { + tag: "i256"; + value: undefined; + } | { + tag: "compactU8"; + value: undefined; + } | { + tag: "compactU16"; + value: undefined; + } | { + tag: "compactU32"; + value: undefined; + } | { + tag: "compactU64"; + value: undefined; + } | { + tag: "compactU128"; + value: undefined; + } | { + tag: "compactU256"; + value: undefined; + } | { + tag: "void"; + value: undefined; + } | { + tag: "perId"; + value: number; + }; + typeName: string | undefined; + }[]>; + } & { + inner: Codec<{ + name: string | undefined; + ty: { + tag: "bool"; + value: undefined; + } | { + tag: "char"; + value: undefined; + } | { + tag: "str"; + value: undefined; + } | { + tag: "u8"; + value: undefined; + } | { + tag: "u16"; + value: undefined; + } | { + tag: "u32"; + value: undefined; + } | { + tag: "u64"; + value: undefined; + } | { + tag: "u128"; + value: undefined; + } | { + tag: "u256"; + value: undefined; + } | { + tag: "i8"; + value: undefined; + } | { + tag: "i16"; + value: undefined; + } | { + tag: "i32"; + value: undefined; + } | { + tag: "i64"; + value: undefined; + } | { + tag: "i128"; + value: undefined; + } | { + tag: "i256"; + value: undefined; + } | { + tag: "compactU8"; + value: undefined; + } | { + tag: "compactU16"; + value: undefined; + } | { + tag: "compactU32"; + value: undefined; + } | { + tag: "compactU64"; + value: undefined; + } | { + tag: "compactU128"; + value: undefined; + } | { + tag: "compactU256"; + value: undefined; + } | { + tag: "void"; + value: undefined; + } | { + tag: "perId"; + value: number; + }; + typeName: string | undefined; + }>; + }; + index: Codec; + }; + }; + sequence: [_pezkuwi_bizinikiwi_bindings.Encoder<{ + tag: "bool"; + value: undefined; + } | { + tag: "char"; + value: undefined; + } | { + tag: "str"; + value: undefined; + } | { + tag: "u8"; + value: undefined; + } | { + tag: "u16"; + value: undefined; + } | { + tag: "u32"; + value: undefined; + } | { + tag: "u64"; + value: undefined; + } | { + tag: "u128"; + value: undefined; + } | { + tag: "u256"; + value: undefined; + } | { + tag: "i8"; + value: undefined; + } | { + tag: "i16"; + value: undefined; + } | { + tag: "i32"; + value: undefined; + } | { + tag: "i64"; + value: undefined; + } | { + tag: "i128"; + value: undefined; + } | { + tag: "i256"; + value: undefined; + } | { + tag: "compactU8"; + value: undefined; + } | { + tag: "compactU16"; + value: undefined; + } | { + tag: "compactU32"; + value: undefined; + } | { + tag: "compactU64"; + value: undefined; + } | { + tag: "compactU128"; + value: undefined; + } | { + tag: "compactU256"; + value: undefined; + } | { + tag: "void"; + value: undefined; + } | { + tag: "perId"; + value: number; + }>, _pezkuwi_bizinikiwi_bindings.Decoder<{ + tag: "bool"; + value: undefined; + } | { + tag: "char"; + value: undefined; + } | { + tag: "str"; + value: undefined; + } | { + tag: "u8"; + value: undefined; + } | { + tag: "u16"; + value: undefined; + } | { + tag: "u32"; + value: undefined; + } | { + tag: "u64"; + value: undefined; + } | { + tag: "u128"; + value: undefined; + } | { + tag: "u256"; + value: undefined; + } | { + tag: "i8"; + value: undefined; + } | { + tag: "i16"; + value: undefined; + } | { + tag: "i32"; + value: undefined; + } | { + tag: "i64"; + value: undefined; + } | { + tag: "i128"; + value: undefined; + } | { + tag: "i256"; + value: undefined; + } | { + tag: "compactU8"; + value: undefined; + } | { + tag: "compactU16"; + value: undefined; + } | { + tag: "compactU32"; + value: undefined; + } | { + tag: "compactU64"; + value: undefined; + } | { + tag: "compactU128"; + value: undefined; + } | { + tag: "compactU256"; + value: undefined; + } | { + tag: "void"; + value: undefined; + } | { + tag: "perId"; + value: number; + }>] & { + enc: _pezkuwi_bizinikiwi_bindings.Encoder<{ + tag: "bool"; + value: undefined; + } | { + tag: "char"; + value: undefined; + } | { + tag: "str"; + value: undefined; + } | { + tag: "u8"; + value: undefined; + } | { + tag: "u16"; + value: undefined; + } | { + tag: "u32"; + value: undefined; + } | { + tag: "u64"; + value: undefined; + } | { + tag: "u128"; + value: undefined; + } | { + tag: "u256"; + value: undefined; + } | { + tag: "i8"; + value: undefined; + } | { + tag: "i16"; + value: undefined; + } | { + tag: "i32"; + value: undefined; + } | { + tag: "i64"; + value: undefined; + } | { + tag: "i128"; + value: undefined; + } | { + tag: "i256"; + value: undefined; + } | { + tag: "compactU8"; + value: undefined; + } | { + tag: "compactU16"; + value: undefined; + } | { + tag: "compactU32"; + value: undefined; + } | { + tag: "compactU64"; + value: undefined; + } | { + tag: "compactU128"; + value: undefined; + } | { + tag: "compactU256"; + value: undefined; + } | { + tag: "void"; + value: undefined; + } | { + tag: "perId"; + value: number; + }>; + dec: _pezkuwi_bizinikiwi_bindings.Decoder<{ + tag: "bool"; + value: undefined; + } | { + tag: "char"; + value: undefined; + } | { + tag: "str"; + value: undefined; + } | { + tag: "u8"; + value: undefined; + } | { + tag: "u16"; + value: undefined; + } | { + tag: "u32"; + value: undefined; + } | { + tag: "u64"; + value: undefined; + } | { + tag: "u128"; + value: undefined; + } | { + tag: "u256"; + value: undefined; + } | { + tag: "i8"; + value: undefined; + } | { + tag: "i16"; + value: undefined; + } | { + tag: "i32"; + value: undefined; + } | { + tag: "i64"; + value: undefined; + } | { + tag: "i128"; + value: undefined; + } | { + tag: "i256"; + value: undefined; + } | { + tag: "compactU8"; + value: undefined; + } | { + tag: "compactU16"; + value: undefined; + } | { + tag: "compactU32"; + value: undefined; + } | { + tag: "compactU64"; + value: undefined; + } | { + tag: "compactU128"; + value: undefined; + } | { + tag: "compactU256"; + value: undefined; + } | { + tag: "void"; + value: undefined; + } | { + tag: "perId"; + value: number; + }>; + } & { + inner: { + bool: Codec; + char: Codec; + str: Codec; + u8: Codec; + u16: Codec; + u32: Codec; + u64: Codec; + u128: Codec; + u256: Codec; + i8: Codec; + i16: Codec; + i32: Codec; + i64: Codec; + i128: Codec; + i256: Codec; + compactU8: Codec; + compactU16: Codec; + compactU32: Codec; + compactU64: Codec; + compactU128: Codec; + compactU256: Codec; + void: Codec; + perId: Codec; + }; + }; + array: [_pezkuwi_bizinikiwi_bindings.Encoder<{ + len: number; + typeParam: { + tag: "bool"; + value: undefined; + } | { + tag: "char"; + value: undefined; + } | { + tag: "str"; + value: undefined; + } | { + tag: "u8"; + value: undefined; + } | { + tag: "u16"; + value: undefined; + } | { + tag: "u32"; + value: undefined; + } | { + tag: "u64"; + value: undefined; + } | { + tag: "u128"; + value: undefined; + } | { + tag: "u256"; + value: undefined; + } | { + tag: "i8"; + value: undefined; + } | { + tag: "i16"; + value: undefined; + } | { + tag: "i32"; + value: undefined; + } | { + tag: "i64"; + value: undefined; + } | { + tag: "i128"; + value: undefined; + } | { + tag: "i256"; + value: undefined; + } | { + tag: "compactU8"; + value: undefined; + } | { + tag: "compactU16"; + value: undefined; + } | { + tag: "compactU32"; + value: undefined; + } | { + tag: "compactU64"; + value: undefined; + } | { + tag: "compactU128"; + value: undefined; + } | { + tag: "compactU256"; + value: undefined; + } | { + tag: "void"; + value: undefined; + } | { + tag: "perId"; + value: number; + }; + }>, _pezkuwi_bizinikiwi_bindings.Decoder<{ + len: number; + typeParam: { + tag: "bool"; + value: undefined; + } | { + tag: "char"; + value: undefined; + } | { + tag: "str"; + value: undefined; + } | { + tag: "u8"; + value: undefined; + } | { + tag: "u16"; + value: undefined; + } | { + tag: "u32"; + value: undefined; + } | { + tag: "u64"; + value: undefined; + } | { + tag: "u128"; + value: undefined; + } | { + tag: "u256"; + value: undefined; + } | { + tag: "i8"; + value: undefined; + } | { + tag: "i16"; + value: undefined; + } | { + tag: "i32"; + value: undefined; + } | { + tag: "i64"; + value: undefined; + } | { + tag: "i128"; + value: undefined; + } | { + tag: "i256"; + value: undefined; + } | { + tag: "compactU8"; + value: undefined; + } | { + tag: "compactU16"; + value: undefined; + } | { + tag: "compactU32"; + value: undefined; + } | { + tag: "compactU64"; + value: undefined; + } | { + tag: "compactU128"; + value: undefined; + } | { + tag: "compactU256"; + value: undefined; + } | { + tag: "void"; + value: undefined; + } | { + tag: "perId"; + value: number; + }; + }>] & { + enc: _pezkuwi_bizinikiwi_bindings.Encoder<{ + len: number; + typeParam: { + tag: "bool"; + value: undefined; + } | { + tag: "char"; + value: undefined; + } | { + tag: "str"; + value: undefined; + } | { + tag: "u8"; + value: undefined; + } | { + tag: "u16"; + value: undefined; + } | { + tag: "u32"; + value: undefined; + } | { + tag: "u64"; + value: undefined; + } | { + tag: "u128"; + value: undefined; + } | { + tag: "u256"; + value: undefined; + } | { + tag: "i8"; + value: undefined; + } | { + tag: "i16"; + value: undefined; + } | { + tag: "i32"; + value: undefined; + } | { + tag: "i64"; + value: undefined; + } | { + tag: "i128"; + value: undefined; + } | { + tag: "i256"; + value: undefined; + } | { + tag: "compactU8"; + value: undefined; + } | { + tag: "compactU16"; + value: undefined; + } | { + tag: "compactU32"; + value: undefined; + } | { + tag: "compactU64"; + value: undefined; + } | { + tag: "compactU128"; + value: undefined; + } | { + tag: "compactU256"; + value: undefined; + } | { + tag: "void"; + value: undefined; + } | { + tag: "perId"; + value: number; + }; + }>; + dec: _pezkuwi_bizinikiwi_bindings.Decoder<{ + len: number; + typeParam: { + tag: "bool"; + value: undefined; + } | { + tag: "char"; + value: undefined; + } | { + tag: "str"; + value: undefined; + } | { + tag: "u8"; + value: undefined; + } | { + tag: "u16"; + value: undefined; + } | { + tag: "u32"; + value: undefined; + } | { + tag: "u64"; + value: undefined; + } | { + tag: "u128"; + value: undefined; + } | { + tag: "u256"; + value: undefined; + } | { + tag: "i8"; + value: undefined; + } | { + tag: "i16"; + value: undefined; + } | { + tag: "i32"; + value: undefined; + } | { + tag: "i64"; + value: undefined; + } | { + tag: "i128"; + value: undefined; + } | { + tag: "i256"; + value: undefined; + } | { + tag: "compactU8"; + value: undefined; + } | { + tag: "compactU16"; + value: undefined; + } | { + tag: "compactU32"; + value: undefined; + } | { + tag: "compactU64"; + value: undefined; + } | { + tag: "compactU128"; + value: undefined; + } | { + tag: "compactU256"; + value: undefined; + } | { + tag: "void"; + value: undefined; + } | { + tag: "perId"; + value: number; + }; + }>; + } & { + inner: { + len: Codec; + typeParam: [_pezkuwi_bizinikiwi_bindings.Encoder<{ + tag: "bool"; + value: undefined; + } | { + tag: "char"; + value: undefined; + } | { + tag: "str"; + value: undefined; + } | { + tag: "u8"; + value: undefined; + } | { + tag: "u16"; + value: undefined; + } | { + tag: "u32"; + value: undefined; + } | { + tag: "u64"; + value: undefined; + } | { + tag: "u128"; + value: undefined; + } | { + tag: "u256"; + value: undefined; + } | { + tag: "i8"; + value: undefined; + } | { + tag: "i16"; + value: undefined; + } | { + tag: "i32"; + value: undefined; + } | { + tag: "i64"; + value: undefined; + } | { + tag: "i128"; + value: undefined; + } | { + tag: "i256"; + value: undefined; + } | { + tag: "compactU8"; + value: undefined; + } | { + tag: "compactU16"; + value: undefined; + } | { + tag: "compactU32"; + value: undefined; + } | { + tag: "compactU64"; + value: undefined; + } | { + tag: "compactU128"; + value: undefined; + } | { + tag: "compactU256"; + value: undefined; + } | { + tag: "void"; + value: undefined; + } | { + tag: "perId"; + value: number; + }>, _pezkuwi_bizinikiwi_bindings.Decoder<{ + tag: "bool"; + value: undefined; + } | { + tag: "char"; + value: undefined; + } | { + tag: "str"; + value: undefined; + } | { + tag: "u8"; + value: undefined; + } | { + tag: "u16"; + value: undefined; + } | { + tag: "u32"; + value: undefined; + } | { + tag: "u64"; + value: undefined; + } | { + tag: "u128"; + value: undefined; + } | { + tag: "u256"; + value: undefined; + } | { + tag: "i8"; + value: undefined; + } | { + tag: "i16"; + value: undefined; + } | { + tag: "i32"; + value: undefined; + } | { + tag: "i64"; + value: undefined; + } | { + tag: "i128"; + value: undefined; + } | { + tag: "i256"; + value: undefined; + } | { + tag: "compactU8"; + value: undefined; + } | { + tag: "compactU16"; + value: undefined; + } | { + tag: "compactU32"; + value: undefined; + } | { + tag: "compactU64"; + value: undefined; + } | { + tag: "compactU128"; + value: undefined; + } | { + tag: "compactU256"; + value: undefined; + } | { + tag: "void"; + value: undefined; + } | { + tag: "perId"; + value: number; + }>] & { + enc: _pezkuwi_bizinikiwi_bindings.Encoder<{ + tag: "bool"; + value: undefined; + } | { + tag: "char"; + value: undefined; + } | { + tag: "str"; + value: undefined; + } | { + tag: "u8"; + value: undefined; + } | { + tag: "u16"; + value: undefined; + } | { + tag: "u32"; + value: undefined; + } | { + tag: "u64"; + value: undefined; + } | { + tag: "u128"; + value: undefined; + } | { + tag: "u256"; + value: undefined; + } | { + tag: "i8"; + value: undefined; + } | { + tag: "i16"; + value: undefined; + } | { + tag: "i32"; + value: undefined; + } | { + tag: "i64"; + value: undefined; + } | { + tag: "i128"; + value: undefined; + } | { + tag: "i256"; + value: undefined; + } | { + tag: "compactU8"; + value: undefined; + } | { + tag: "compactU16"; + value: undefined; + } | { + tag: "compactU32"; + value: undefined; + } | { + tag: "compactU64"; + value: undefined; + } | { + tag: "compactU128"; + value: undefined; + } | { + tag: "compactU256"; + value: undefined; + } | { + tag: "void"; + value: undefined; + } | { + tag: "perId"; + value: number; + }>; + dec: _pezkuwi_bizinikiwi_bindings.Decoder<{ + tag: "bool"; + value: undefined; + } | { + tag: "char"; + value: undefined; + } | { + tag: "str"; + value: undefined; + } | { + tag: "u8"; + value: undefined; + } | { + tag: "u16"; + value: undefined; + } | { + tag: "u32"; + value: undefined; + } | { + tag: "u64"; + value: undefined; + } | { + tag: "u128"; + value: undefined; + } | { + tag: "u256"; + value: undefined; + } | { + tag: "i8"; + value: undefined; + } | { + tag: "i16"; + value: undefined; + } | { + tag: "i32"; + value: undefined; + } | { + tag: "i64"; + value: undefined; + } | { + tag: "i128"; + value: undefined; + } | { + tag: "i256"; + value: undefined; + } | { + tag: "compactU8"; + value: undefined; + } | { + tag: "compactU16"; + value: undefined; + } | { + tag: "compactU32"; + value: undefined; + } | { + tag: "compactU64"; + value: undefined; + } | { + tag: "compactU128"; + value: undefined; + } | { + tag: "compactU256"; + value: undefined; + } | { + tag: "void"; + value: undefined; + } | { + tag: "perId"; + value: number; + }>; + } & { + inner: { + bool: Codec; + char: Codec; + str: Codec; + u8: Codec; + u16: Codec; + u32: Codec; + u64: Codec; + u128: Codec; + u256: Codec; + i8: Codec; + i16: Codec; + i32: Codec; + i64: Codec; + i128: Codec; + i256: Codec; + compactU8: Codec; + compactU16: Codec; + compactU32: Codec; + compactU64: Codec; + compactU128: Codec; + compactU256: Codec; + void: Codec; + perId: Codec; + }; + }; + }; + }; + tuple: [_pezkuwi_bizinikiwi_bindings.Encoder<({ + tag: "bool"; + value: undefined; + } | { + tag: "char"; + value: undefined; + } | { + tag: "str"; + value: undefined; + } | { + tag: "u8"; + value: undefined; + } | { + tag: "u16"; + value: undefined; + } | { + tag: "u32"; + value: undefined; + } | { + tag: "u64"; + value: undefined; + } | { + tag: "u128"; + value: undefined; + } | { + tag: "u256"; + value: undefined; + } | { + tag: "i8"; + value: undefined; + } | { + tag: "i16"; + value: undefined; + } | { + tag: "i32"; + value: undefined; + } | { + tag: "i64"; + value: undefined; + } | { + tag: "i128"; + value: undefined; + } | { + tag: "i256"; + value: undefined; + } | { + tag: "compactU8"; + value: undefined; + } | { + tag: "compactU16"; + value: undefined; + } | { + tag: "compactU32"; + value: undefined; + } | { + tag: "compactU64"; + value: undefined; + } | { + tag: "compactU128"; + value: undefined; + } | { + tag: "compactU256"; + value: undefined; + } | { + tag: "void"; + value: undefined; + } | { + tag: "perId"; + value: number; + })[]>, _pezkuwi_bizinikiwi_bindings.Decoder<({ + tag: "bool"; + value: undefined; + } | { + tag: "char"; + value: undefined; + } | { + tag: "str"; + value: undefined; + } | { + tag: "u8"; + value: undefined; + } | { + tag: "u16"; + value: undefined; + } | { + tag: "u32"; + value: undefined; + } | { + tag: "u64"; + value: undefined; + } | { + tag: "u128"; + value: undefined; + } | { + tag: "u256"; + value: undefined; + } | { + tag: "i8"; + value: undefined; + } | { + tag: "i16"; + value: undefined; + } | { + tag: "i32"; + value: undefined; + } | { + tag: "i64"; + value: undefined; + } | { + tag: "i128"; + value: undefined; + } | { + tag: "i256"; + value: undefined; + } | { + tag: "compactU8"; + value: undefined; + } | { + tag: "compactU16"; + value: undefined; + } | { + tag: "compactU32"; + value: undefined; + } | { + tag: "compactU64"; + value: undefined; + } | { + tag: "compactU128"; + value: undefined; + } | { + tag: "compactU256"; + value: undefined; + } | { + tag: "void"; + value: undefined; + } | { + tag: "perId"; + value: number; + })[]>] & { + enc: _pezkuwi_bizinikiwi_bindings.Encoder<({ + tag: "bool"; + value: undefined; + } | { + tag: "char"; + value: undefined; + } | { + tag: "str"; + value: undefined; + } | { + tag: "u8"; + value: undefined; + } | { + tag: "u16"; + value: undefined; + } | { + tag: "u32"; + value: undefined; + } | { + tag: "u64"; + value: undefined; + } | { + tag: "u128"; + value: undefined; + } | { + tag: "u256"; + value: undefined; + } | { + tag: "i8"; + value: undefined; + } | { + tag: "i16"; + value: undefined; + } | { + tag: "i32"; + value: undefined; + } | { + tag: "i64"; + value: undefined; + } | { + tag: "i128"; + value: undefined; + } | { + tag: "i256"; + value: undefined; + } | { + tag: "compactU8"; + value: undefined; + } | { + tag: "compactU16"; + value: undefined; + } | { + tag: "compactU32"; + value: undefined; + } | { + tag: "compactU64"; + value: undefined; + } | { + tag: "compactU128"; + value: undefined; + } | { + tag: "compactU256"; + value: undefined; + } | { + tag: "void"; + value: undefined; + } | { + tag: "perId"; + value: number; + })[]>; + dec: _pezkuwi_bizinikiwi_bindings.Decoder<({ + tag: "bool"; + value: undefined; + } | { + tag: "char"; + value: undefined; + } | { + tag: "str"; + value: undefined; + } | { + tag: "u8"; + value: undefined; + } | { + tag: "u16"; + value: undefined; + } | { + tag: "u32"; + value: undefined; + } | { + tag: "u64"; + value: undefined; + } | { + tag: "u128"; + value: undefined; + } | { + tag: "u256"; + value: undefined; + } | { + tag: "i8"; + value: undefined; + } | { + tag: "i16"; + value: undefined; + } | { + tag: "i32"; + value: undefined; + } | { + tag: "i64"; + value: undefined; + } | { + tag: "i128"; + value: undefined; + } | { + tag: "i256"; + value: undefined; + } | { + tag: "compactU8"; + value: undefined; + } | { + tag: "compactU16"; + value: undefined; + } | { + tag: "compactU32"; + value: undefined; + } | { + tag: "compactU64"; + value: undefined; + } | { + tag: "compactU128"; + value: undefined; + } | { + tag: "compactU256"; + value: undefined; + } | { + tag: "void"; + value: undefined; + } | { + tag: "perId"; + value: number; + })[]>; + } & { + inner: Codec<{ + tag: "bool"; + value: undefined; + } | { + tag: "char"; + value: undefined; + } | { + tag: "str"; + value: undefined; + } | { + tag: "u8"; + value: undefined; + } | { + tag: "u16"; + value: undefined; + } | { + tag: "u32"; + value: undefined; + } | { + tag: "u64"; + value: undefined; + } | { + tag: "u128"; + value: undefined; + } | { + tag: "u256"; + value: undefined; + } | { + tag: "i8"; + value: undefined; + } | { + tag: "i16"; + value: undefined; + } | { + tag: "i32"; + value: undefined; + } | { + tag: "i64"; + value: undefined; + } | { + tag: "i128"; + value: undefined; + } | { + tag: "i256"; + value: undefined; + } | { + tag: "compactU8"; + value: undefined; + } | { + tag: "compactU16"; + value: undefined; + } | { + tag: "compactU32"; + value: undefined; + } | { + tag: "compactU64"; + value: undefined; + } | { + tag: "compactU128"; + value: undefined; + } | { + tag: "compactU256"; + value: undefined; + } | { + tag: "void"; + value: undefined; + } | { + tag: "perId"; + value: number; + }>; + }; + bitSequence: [_pezkuwi_bizinikiwi_bindings.Encoder<{ + numBytes: number; + leastSignificantBitFirst: boolean; + }>, _pezkuwi_bizinikiwi_bindings.Decoder<{ + numBytes: number; + leastSignificantBitFirst: boolean; + }>] & { + enc: _pezkuwi_bizinikiwi_bindings.Encoder<{ + numBytes: number; + leastSignificantBitFirst: boolean; + }>; + dec: _pezkuwi_bizinikiwi_bindings.Decoder<{ + numBytes: number; + leastSignificantBitFirst: boolean; + }>; + } & { + inner: { + numBytes: Codec; + leastSignificantBitFirst: Codec; + }; + }; + }; + }; + typeId: Codec; + }; +}; +type LookupEntry = CodecType; +type Lookup = Array; +declare const lookup: Codec; +declare const extrinsicMetadata: [_pezkuwi_bizinikiwi_bindings.Encoder<{ + version: number; + addressTy: { + tag: "bool"; + value: undefined; + } | { + tag: "char"; + value: undefined; + } | { + tag: "str"; + value: undefined; + } | { + tag: "u8"; + value: undefined; + } | { + tag: "u16"; + value: undefined; + } | { + tag: "u32"; + value: undefined; + } | { + tag: "u64"; + value: undefined; + } | { + tag: "u128"; + value: undefined; + } | { + tag: "u256"; + value: undefined; + } | { + tag: "i8"; + value: undefined; + } | { + tag: "i16"; + value: undefined; + } | { + tag: "i32"; + value: undefined; + } | { + tag: "i64"; + value: undefined; + } | { + tag: "i128"; + value: undefined; + } | { + tag: "i256"; + value: undefined; + } | { + tag: "compactU8"; + value: undefined; + } | { + tag: "compactU16"; + value: undefined; + } | { + tag: "compactU32"; + value: undefined; + } | { + tag: "compactU64"; + value: undefined; + } | { + tag: "compactU128"; + value: undefined; + } | { + tag: "compactU256"; + value: undefined; + } | { + tag: "void"; + value: undefined; + } | { + tag: "perId"; + value: number; + }; + callTy: { + tag: "bool"; + value: undefined; + } | { + tag: "char"; + value: undefined; + } | { + tag: "str"; + value: undefined; + } | { + tag: "u8"; + value: undefined; + } | { + tag: "u16"; + value: undefined; + } | { + tag: "u32"; + value: undefined; + } | { + tag: "u64"; + value: undefined; + } | { + tag: "u128"; + value: undefined; + } | { + tag: "u256"; + value: undefined; + } | { + tag: "i8"; + value: undefined; + } | { + tag: "i16"; + value: undefined; + } | { + tag: "i32"; + value: undefined; + } | { + tag: "i64"; + value: undefined; + } | { + tag: "i128"; + value: undefined; + } | { + tag: "i256"; + value: undefined; + } | { + tag: "compactU8"; + value: undefined; + } | { + tag: "compactU16"; + value: undefined; + } | { + tag: "compactU32"; + value: undefined; + } | { + tag: "compactU64"; + value: undefined; + } | { + tag: "compactU128"; + value: undefined; + } | { + tag: "compactU256"; + value: undefined; + } | { + tag: "void"; + value: undefined; + } | { + tag: "perId"; + value: number; + }; + signatureTy: { + tag: "bool"; + value: undefined; + } | { + tag: "char"; + value: undefined; + } | { + tag: "str"; + value: undefined; + } | { + tag: "u8"; + value: undefined; + } | { + tag: "u16"; + value: undefined; + } | { + tag: "u32"; + value: undefined; + } | { + tag: "u64"; + value: undefined; + } | { + tag: "u128"; + value: undefined; + } | { + tag: "u256"; + value: undefined; + } | { + tag: "i8"; + value: undefined; + } | { + tag: "i16"; + value: undefined; + } | { + tag: "i32"; + value: undefined; + } | { + tag: "i64"; + value: undefined; + } | { + tag: "i128"; + value: undefined; + } | { + tag: "i256"; + value: undefined; + } | { + tag: "compactU8"; + value: undefined; + } | { + tag: "compactU16"; + value: undefined; + } | { + tag: "compactU32"; + value: undefined; + } | { + tag: "compactU64"; + value: undefined; + } | { + tag: "compactU128"; + value: undefined; + } | { + tag: "compactU256"; + value: undefined; + } | { + tag: "void"; + value: undefined; + } | { + tag: "perId"; + value: number; + }; + signedExtensions: { + identifier: string; + includedInExtrinsic: { + tag: "bool"; + value: undefined; + } | { + tag: "char"; + value: undefined; + } | { + tag: "str"; + value: undefined; + } | { + tag: "u8"; + value: undefined; + } | { + tag: "u16"; + value: undefined; + } | { + tag: "u32"; + value: undefined; + } | { + tag: "u64"; + value: undefined; + } | { + tag: "u128"; + value: undefined; + } | { + tag: "u256"; + value: undefined; + } | { + tag: "i8"; + value: undefined; + } | { + tag: "i16"; + value: undefined; + } | { + tag: "i32"; + value: undefined; + } | { + tag: "i64"; + value: undefined; + } | { + tag: "i128"; + value: undefined; + } | { + tag: "i256"; + value: undefined; + } | { + tag: "compactU8"; + value: undefined; + } | { + tag: "compactU16"; + value: undefined; + } | { + tag: "compactU32"; + value: undefined; + } | { + tag: "compactU64"; + value: undefined; + } | { + tag: "compactU128"; + value: undefined; + } | { + tag: "compactU256"; + value: undefined; + } | { + tag: "void"; + value: undefined; + } | { + tag: "perId"; + value: number; + }; + includedInSignedData: { + tag: "bool"; + value: undefined; + } | { + tag: "char"; + value: undefined; + } | { + tag: "str"; + value: undefined; + } | { + tag: "u8"; + value: undefined; + } | { + tag: "u16"; + value: undefined; + } | { + tag: "u32"; + value: undefined; + } | { + tag: "u64"; + value: undefined; + } | { + tag: "u128"; + value: undefined; + } | { + tag: "u256"; + value: undefined; + } | { + tag: "i8"; + value: undefined; + } | { + tag: "i16"; + value: undefined; + } | { + tag: "i32"; + value: undefined; + } | { + tag: "i64"; + value: undefined; + } | { + tag: "i128"; + value: undefined; + } | { + tag: "i256"; + value: undefined; + } | { + tag: "compactU8"; + value: undefined; + } | { + tag: "compactU16"; + value: undefined; + } | { + tag: "compactU32"; + value: undefined; + } | { + tag: "compactU64"; + value: undefined; + } | { + tag: "compactU128"; + value: undefined; + } | { + tag: "compactU256"; + value: undefined; + } | { + tag: "void"; + value: undefined; + } | { + tag: "perId"; + value: number; + }; + }[]; +}>, _pezkuwi_bizinikiwi_bindings.Decoder<{ + version: number; + addressTy: { + tag: "bool"; + value: undefined; + } | { + tag: "char"; + value: undefined; + } | { + tag: "str"; + value: undefined; + } | { + tag: "u8"; + value: undefined; + } | { + tag: "u16"; + value: undefined; + } | { + tag: "u32"; + value: undefined; + } | { + tag: "u64"; + value: undefined; + } | { + tag: "u128"; + value: undefined; + } | { + tag: "u256"; + value: undefined; + } | { + tag: "i8"; + value: undefined; + } | { + tag: "i16"; + value: undefined; + } | { + tag: "i32"; + value: undefined; + } | { + tag: "i64"; + value: undefined; + } | { + tag: "i128"; + value: undefined; + } | { + tag: "i256"; + value: undefined; + } | { + tag: "compactU8"; + value: undefined; + } | { + tag: "compactU16"; + value: undefined; + } | { + tag: "compactU32"; + value: undefined; + } | { + tag: "compactU64"; + value: undefined; + } | { + tag: "compactU128"; + value: undefined; + } | { + tag: "compactU256"; + value: undefined; + } | { + tag: "void"; + value: undefined; + } | { + tag: "perId"; + value: number; + }; + callTy: { + tag: "bool"; + value: undefined; + } | { + tag: "char"; + value: undefined; + } | { + tag: "str"; + value: undefined; + } | { + tag: "u8"; + value: undefined; + } | { + tag: "u16"; + value: undefined; + } | { + tag: "u32"; + value: undefined; + } | { + tag: "u64"; + value: undefined; + } | { + tag: "u128"; + value: undefined; + } | { + tag: "u256"; + value: undefined; + } | { + tag: "i8"; + value: undefined; + } | { + tag: "i16"; + value: undefined; + } | { + tag: "i32"; + value: undefined; + } | { + tag: "i64"; + value: undefined; + } | { + tag: "i128"; + value: undefined; + } | { + tag: "i256"; + value: undefined; + } | { + tag: "compactU8"; + value: undefined; + } | { + tag: "compactU16"; + value: undefined; + } | { + tag: "compactU32"; + value: undefined; + } | { + tag: "compactU64"; + value: undefined; + } | { + tag: "compactU128"; + value: undefined; + } | { + tag: "compactU256"; + value: undefined; + } | { + tag: "void"; + value: undefined; + } | { + tag: "perId"; + value: number; + }; + signatureTy: { + tag: "bool"; + value: undefined; + } | { + tag: "char"; + value: undefined; + } | { + tag: "str"; + value: undefined; + } | { + tag: "u8"; + value: undefined; + } | { + tag: "u16"; + value: undefined; + } | { + tag: "u32"; + value: undefined; + } | { + tag: "u64"; + value: undefined; + } | { + tag: "u128"; + value: undefined; + } | { + tag: "u256"; + value: undefined; + } | { + tag: "i8"; + value: undefined; + } | { + tag: "i16"; + value: undefined; + } | { + tag: "i32"; + value: undefined; + } | { + tag: "i64"; + value: undefined; + } | { + tag: "i128"; + value: undefined; + } | { + tag: "i256"; + value: undefined; + } | { + tag: "compactU8"; + value: undefined; + } | { + tag: "compactU16"; + value: undefined; + } | { + tag: "compactU32"; + value: undefined; + } | { + tag: "compactU64"; + value: undefined; + } | { + tag: "compactU128"; + value: undefined; + } | { + tag: "compactU256"; + value: undefined; + } | { + tag: "void"; + value: undefined; + } | { + tag: "perId"; + value: number; + }; + signedExtensions: { + identifier: string; + includedInExtrinsic: { + tag: "bool"; + value: undefined; + } | { + tag: "char"; + value: undefined; + } | { + tag: "str"; + value: undefined; + } | { + tag: "u8"; + value: undefined; + } | { + tag: "u16"; + value: undefined; + } | { + tag: "u32"; + value: undefined; + } | { + tag: "u64"; + value: undefined; + } | { + tag: "u128"; + value: undefined; + } | { + tag: "u256"; + value: undefined; + } | { + tag: "i8"; + value: undefined; + } | { + tag: "i16"; + value: undefined; + } | { + tag: "i32"; + value: undefined; + } | { + tag: "i64"; + value: undefined; + } | { + tag: "i128"; + value: undefined; + } | { + tag: "i256"; + value: undefined; + } | { + tag: "compactU8"; + value: undefined; + } | { + tag: "compactU16"; + value: undefined; + } | { + tag: "compactU32"; + value: undefined; + } | { + tag: "compactU64"; + value: undefined; + } | { + tag: "compactU128"; + value: undefined; + } | { + tag: "compactU256"; + value: undefined; + } | { + tag: "void"; + value: undefined; + } | { + tag: "perId"; + value: number; + }; + includedInSignedData: { + tag: "bool"; + value: undefined; + } | { + tag: "char"; + value: undefined; + } | { + tag: "str"; + value: undefined; + } | { + tag: "u8"; + value: undefined; + } | { + tag: "u16"; + value: undefined; + } | { + tag: "u32"; + value: undefined; + } | { + tag: "u64"; + value: undefined; + } | { + tag: "u128"; + value: undefined; + } | { + tag: "u256"; + value: undefined; + } | { + tag: "i8"; + value: undefined; + } | { + tag: "i16"; + value: undefined; + } | { + tag: "i32"; + value: undefined; + } | { + tag: "i64"; + value: undefined; + } | { + tag: "i128"; + value: undefined; + } | { + tag: "i256"; + value: undefined; + } | { + tag: "compactU8"; + value: undefined; + } | { + tag: "compactU16"; + value: undefined; + } | { + tag: "compactU32"; + value: undefined; + } | { + tag: "compactU64"; + value: undefined; + } | { + tag: "compactU128"; + value: undefined; + } | { + tag: "compactU256"; + value: undefined; + } | { + tag: "void"; + value: undefined; + } | { + tag: "perId"; + value: number; + }; + }[]; +}>] & { + enc: _pezkuwi_bizinikiwi_bindings.Encoder<{ + version: number; + addressTy: { + tag: "bool"; + value: undefined; + } | { + tag: "char"; + value: undefined; + } | { + tag: "str"; + value: undefined; + } | { + tag: "u8"; + value: undefined; + } | { + tag: "u16"; + value: undefined; + } | { + tag: "u32"; + value: undefined; + } | { + tag: "u64"; + value: undefined; + } | { + tag: "u128"; + value: undefined; + } | { + tag: "u256"; + value: undefined; + } | { + tag: "i8"; + value: undefined; + } | { + tag: "i16"; + value: undefined; + } | { + tag: "i32"; + value: undefined; + } | { + tag: "i64"; + value: undefined; + } | { + tag: "i128"; + value: undefined; + } | { + tag: "i256"; + value: undefined; + } | { + tag: "compactU8"; + value: undefined; + } | { + tag: "compactU16"; + value: undefined; + } | { + tag: "compactU32"; + value: undefined; + } | { + tag: "compactU64"; + value: undefined; + } | { + tag: "compactU128"; + value: undefined; + } | { + tag: "compactU256"; + value: undefined; + } | { + tag: "void"; + value: undefined; + } | { + tag: "perId"; + value: number; + }; + callTy: { + tag: "bool"; + value: undefined; + } | { + tag: "char"; + value: undefined; + } | { + tag: "str"; + value: undefined; + } | { + tag: "u8"; + value: undefined; + } | { + tag: "u16"; + value: undefined; + } | { + tag: "u32"; + value: undefined; + } | { + tag: "u64"; + value: undefined; + } | { + tag: "u128"; + value: undefined; + } | { + tag: "u256"; + value: undefined; + } | { + tag: "i8"; + value: undefined; + } | { + tag: "i16"; + value: undefined; + } | { + tag: "i32"; + value: undefined; + } | { + tag: "i64"; + value: undefined; + } | { + tag: "i128"; + value: undefined; + } | { + tag: "i256"; + value: undefined; + } | { + tag: "compactU8"; + value: undefined; + } | { + tag: "compactU16"; + value: undefined; + } | { + tag: "compactU32"; + value: undefined; + } | { + tag: "compactU64"; + value: undefined; + } | { + tag: "compactU128"; + value: undefined; + } | { + tag: "compactU256"; + value: undefined; + } | { + tag: "void"; + value: undefined; + } | { + tag: "perId"; + value: number; + }; + signatureTy: { + tag: "bool"; + value: undefined; + } | { + tag: "char"; + value: undefined; + } | { + tag: "str"; + value: undefined; + } | { + tag: "u8"; + value: undefined; + } | { + tag: "u16"; + value: undefined; + } | { + tag: "u32"; + value: undefined; + } | { + tag: "u64"; + value: undefined; + } | { + tag: "u128"; + value: undefined; + } | { + tag: "u256"; + value: undefined; + } | { + tag: "i8"; + value: undefined; + } | { + tag: "i16"; + value: undefined; + } | { + tag: "i32"; + value: undefined; + } | { + tag: "i64"; + value: undefined; + } | { + tag: "i128"; + value: undefined; + } | { + tag: "i256"; + value: undefined; + } | { + tag: "compactU8"; + value: undefined; + } | { + tag: "compactU16"; + value: undefined; + } | { + tag: "compactU32"; + value: undefined; + } | { + tag: "compactU64"; + value: undefined; + } | { + tag: "compactU128"; + value: undefined; + } | { + tag: "compactU256"; + value: undefined; + } | { + tag: "void"; + value: undefined; + } | { + tag: "perId"; + value: number; + }; + signedExtensions: { + identifier: string; + includedInExtrinsic: { + tag: "bool"; + value: undefined; + } | { + tag: "char"; + value: undefined; + } | { + tag: "str"; + value: undefined; + } | { + tag: "u8"; + value: undefined; + } | { + tag: "u16"; + value: undefined; + } | { + tag: "u32"; + value: undefined; + } | { + tag: "u64"; + value: undefined; + } | { + tag: "u128"; + value: undefined; + } | { + tag: "u256"; + value: undefined; + } | { + tag: "i8"; + value: undefined; + } | { + tag: "i16"; + value: undefined; + } | { + tag: "i32"; + value: undefined; + } | { + tag: "i64"; + value: undefined; + } | { + tag: "i128"; + value: undefined; + } | { + tag: "i256"; + value: undefined; + } | { + tag: "compactU8"; + value: undefined; + } | { + tag: "compactU16"; + value: undefined; + } | { + tag: "compactU32"; + value: undefined; + } | { + tag: "compactU64"; + value: undefined; + } | { + tag: "compactU128"; + value: undefined; + } | { + tag: "compactU256"; + value: undefined; + } | { + tag: "void"; + value: undefined; + } | { + tag: "perId"; + value: number; + }; + includedInSignedData: { + tag: "bool"; + value: undefined; + } | { + tag: "char"; + value: undefined; + } | { + tag: "str"; + value: undefined; + } | { + tag: "u8"; + value: undefined; + } | { + tag: "u16"; + value: undefined; + } | { + tag: "u32"; + value: undefined; + } | { + tag: "u64"; + value: undefined; + } | { + tag: "u128"; + value: undefined; + } | { + tag: "u256"; + value: undefined; + } | { + tag: "i8"; + value: undefined; + } | { + tag: "i16"; + value: undefined; + } | { + tag: "i32"; + value: undefined; + } | { + tag: "i64"; + value: undefined; + } | { + tag: "i128"; + value: undefined; + } | { + tag: "i256"; + value: undefined; + } | { + tag: "compactU8"; + value: undefined; + } | { + tag: "compactU16"; + value: undefined; + } | { + tag: "compactU32"; + value: undefined; + } | { + tag: "compactU64"; + value: undefined; + } | { + tag: "compactU128"; + value: undefined; + } | { + tag: "compactU256"; + value: undefined; + } | { + tag: "void"; + value: undefined; + } | { + tag: "perId"; + value: number; + }; + }[]; + }>; + dec: _pezkuwi_bizinikiwi_bindings.Decoder<{ + version: number; + addressTy: { + tag: "bool"; + value: undefined; + } | { + tag: "char"; + value: undefined; + } | { + tag: "str"; + value: undefined; + } | { + tag: "u8"; + value: undefined; + } | { + tag: "u16"; + value: undefined; + } | { + tag: "u32"; + value: undefined; + } | { + tag: "u64"; + value: undefined; + } | { + tag: "u128"; + value: undefined; + } | { + tag: "u256"; + value: undefined; + } | { + tag: "i8"; + value: undefined; + } | { + tag: "i16"; + value: undefined; + } | { + tag: "i32"; + value: undefined; + } | { + tag: "i64"; + value: undefined; + } | { + tag: "i128"; + value: undefined; + } | { + tag: "i256"; + value: undefined; + } | { + tag: "compactU8"; + value: undefined; + } | { + tag: "compactU16"; + value: undefined; + } | { + tag: "compactU32"; + value: undefined; + } | { + tag: "compactU64"; + value: undefined; + } | { + tag: "compactU128"; + value: undefined; + } | { + tag: "compactU256"; + value: undefined; + } | { + tag: "void"; + value: undefined; + } | { + tag: "perId"; + value: number; + }; + callTy: { + tag: "bool"; + value: undefined; + } | { + tag: "char"; + value: undefined; + } | { + tag: "str"; + value: undefined; + } | { + tag: "u8"; + value: undefined; + } | { + tag: "u16"; + value: undefined; + } | { + tag: "u32"; + value: undefined; + } | { + tag: "u64"; + value: undefined; + } | { + tag: "u128"; + value: undefined; + } | { + tag: "u256"; + value: undefined; + } | { + tag: "i8"; + value: undefined; + } | { + tag: "i16"; + value: undefined; + } | { + tag: "i32"; + value: undefined; + } | { + tag: "i64"; + value: undefined; + } | { + tag: "i128"; + value: undefined; + } | { + tag: "i256"; + value: undefined; + } | { + tag: "compactU8"; + value: undefined; + } | { + tag: "compactU16"; + value: undefined; + } | { + tag: "compactU32"; + value: undefined; + } | { + tag: "compactU64"; + value: undefined; + } | { + tag: "compactU128"; + value: undefined; + } | { + tag: "compactU256"; + value: undefined; + } | { + tag: "void"; + value: undefined; + } | { + tag: "perId"; + value: number; + }; + signatureTy: { + tag: "bool"; + value: undefined; + } | { + tag: "char"; + value: undefined; + } | { + tag: "str"; + value: undefined; + } | { + tag: "u8"; + value: undefined; + } | { + tag: "u16"; + value: undefined; + } | { + tag: "u32"; + value: undefined; + } | { + tag: "u64"; + value: undefined; + } | { + tag: "u128"; + value: undefined; + } | { + tag: "u256"; + value: undefined; + } | { + tag: "i8"; + value: undefined; + } | { + tag: "i16"; + value: undefined; + } | { + tag: "i32"; + value: undefined; + } | { + tag: "i64"; + value: undefined; + } | { + tag: "i128"; + value: undefined; + } | { + tag: "i256"; + value: undefined; + } | { + tag: "compactU8"; + value: undefined; + } | { + tag: "compactU16"; + value: undefined; + } | { + tag: "compactU32"; + value: undefined; + } | { + tag: "compactU64"; + value: undefined; + } | { + tag: "compactU128"; + value: undefined; + } | { + tag: "compactU256"; + value: undefined; + } | { + tag: "void"; + value: undefined; + } | { + tag: "perId"; + value: number; + }; + signedExtensions: { + identifier: string; + includedInExtrinsic: { + tag: "bool"; + value: undefined; + } | { + tag: "char"; + value: undefined; + } | { + tag: "str"; + value: undefined; + } | { + tag: "u8"; + value: undefined; + } | { + tag: "u16"; + value: undefined; + } | { + tag: "u32"; + value: undefined; + } | { + tag: "u64"; + value: undefined; + } | { + tag: "u128"; + value: undefined; + } | { + tag: "u256"; + value: undefined; + } | { + tag: "i8"; + value: undefined; + } | { + tag: "i16"; + value: undefined; + } | { + tag: "i32"; + value: undefined; + } | { + tag: "i64"; + value: undefined; + } | { + tag: "i128"; + value: undefined; + } | { + tag: "i256"; + value: undefined; + } | { + tag: "compactU8"; + value: undefined; + } | { + tag: "compactU16"; + value: undefined; + } | { + tag: "compactU32"; + value: undefined; + } | { + tag: "compactU64"; + value: undefined; + } | { + tag: "compactU128"; + value: undefined; + } | { + tag: "compactU256"; + value: undefined; + } | { + tag: "void"; + value: undefined; + } | { + tag: "perId"; + value: number; + }; + includedInSignedData: { + tag: "bool"; + value: undefined; + } | { + tag: "char"; + value: undefined; + } | { + tag: "str"; + value: undefined; + } | { + tag: "u8"; + value: undefined; + } | { + tag: "u16"; + value: undefined; + } | { + tag: "u32"; + value: undefined; + } | { + tag: "u64"; + value: undefined; + } | { + tag: "u128"; + value: undefined; + } | { + tag: "u256"; + value: undefined; + } | { + tag: "i8"; + value: undefined; + } | { + tag: "i16"; + value: undefined; + } | { + tag: "i32"; + value: undefined; + } | { + tag: "i64"; + value: undefined; + } | { + tag: "i128"; + value: undefined; + } | { + tag: "i256"; + value: undefined; + } | { + tag: "compactU8"; + value: undefined; + } | { + tag: "compactU16"; + value: undefined; + } | { + tag: "compactU32"; + value: undefined; + } | { + tag: "compactU64"; + value: undefined; + } | { + tag: "compactU128"; + value: undefined; + } | { + tag: "compactU256"; + value: undefined; + } | { + tag: "void"; + value: undefined; + } | { + tag: "perId"; + value: number; + }; + }[]; + }>; +} & { + inner: { + version: Codec; + addressTy: [_pezkuwi_bizinikiwi_bindings.Encoder<{ + tag: "bool"; + value: undefined; + } | { + tag: "char"; + value: undefined; + } | { + tag: "str"; + value: undefined; + } | { + tag: "u8"; + value: undefined; + } | { + tag: "u16"; + value: undefined; + } | { + tag: "u32"; + value: undefined; + } | { + tag: "u64"; + value: undefined; + } | { + tag: "u128"; + value: undefined; + } | { + tag: "u256"; + value: undefined; + } | { + tag: "i8"; + value: undefined; + } | { + tag: "i16"; + value: undefined; + } | { + tag: "i32"; + value: undefined; + } | { + tag: "i64"; + value: undefined; + } | { + tag: "i128"; + value: undefined; + } | { + tag: "i256"; + value: undefined; + } | { + tag: "compactU8"; + value: undefined; + } | { + tag: "compactU16"; + value: undefined; + } | { + tag: "compactU32"; + value: undefined; + } | { + tag: "compactU64"; + value: undefined; + } | { + tag: "compactU128"; + value: undefined; + } | { + tag: "compactU256"; + value: undefined; + } | { + tag: "void"; + value: undefined; + } | { + tag: "perId"; + value: number; + }>, _pezkuwi_bizinikiwi_bindings.Decoder<{ + tag: "bool"; + value: undefined; + } | { + tag: "char"; + value: undefined; + } | { + tag: "str"; + value: undefined; + } | { + tag: "u8"; + value: undefined; + } | { + tag: "u16"; + value: undefined; + } | { + tag: "u32"; + value: undefined; + } | { + tag: "u64"; + value: undefined; + } | { + tag: "u128"; + value: undefined; + } | { + tag: "u256"; + value: undefined; + } | { + tag: "i8"; + value: undefined; + } | { + tag: "i16"; + value: undefined; + } | { + tag: "i32"; + value: undefined; + } | { + tag: "i64"; + value: undefined; + } | { + tag: "i128"; + value: undefined; + } | { + tag: "i256"; + value: undefined; + } | { + tag: "compactU8"; + value: undefined; + } | { + tag: "compactU16"; + value: undefined; + } | { + tag: "compactU32"; + value: undefined; + } | { + tag: "compactU64"; + value: undefined; + } | { + tag: "compactU128"; + value: undefined; + } | { + tag: "compactU256"; + value: undefined; + } | { + tag: "void"; + value: undefined; + } | { + tag: "perId"; + value: number; + }>] & { + enc: _pezkuwi_bizinikiwi_bindings.Encoder<{ + tag: "bool"; + value: undefined; + } | { + tag: "char"; + value: undefined; + } | { + tag: "str"; + value: undefined; + } | { + tag: "u8"; + value: undefined; + } | { + tag: "u16"; + value: undefined; + } | { + tag: "u32"; + value: undefined; + } | { + tag: "u64"; + value: undefined; + } | { + tag: "u128"; + value: undefined; + } | { + tag: "u256"; + value: undefined; + } | { + tag: "i8"; + value: undefined; + } | { + tag: "i16"; + value: undefined; + } | { + tag: "i32"; + value: undefined; + } | { + tag: "i64"; + value: undefined; + } | { + tag: "i128"; + value: undefined; + } | { + tag: "i256"; + value: undefined; + } | { + tag: "compactU8"; + value: undefined; + } | { + tag: "compactU16"; + value: undefined; + } | { + tag: "compactU32"; + value: undefined; + } | { + tag: "compactU64"; + value: undefined; + } | { + tag: "compactU128"; + value: undefined; + } | { + tag: "compactU256"; + value: undefined; + } | { + tag: "void"; + value: undefined; + } | { + tag: "perId"; + value: number; + }>; + dec: _pezkuwi_bizinikiwi_bindings.Decoder<{ + tag: "bool"; + value: undefined; + } | { + tag: "char"; + value: undefined; + } | { + tag: "str"; + value: undefined; + } | { + tag: "u8"; + value: undefined; + } | { + tag: "u16"; + value: undefined; + } | { + tag: "u32"; + value: undefined; + } | { + tag: "u64"; + value: undefined; + } | { + tag: "u128"; + value: undefined; + } | { + tag: "u256"; + value: undefined; + } | { + tag: "i8"; + value: undefined; + } | { + tag: "i16"; + value: undefined; + } | { + tag: "i32"; + value: undefined; + } | { + tag: "i64"; + value: undefined; + } | { + tag: "i128"; + value: undefined; + } | { + tag: "i256"; + value: undefined; + } | { + tag: "compactU8"; + value: undefined; + } | { + tag: "compactU16"; + value: undefined; + } | { + tag: "compactU32"; + value: undefined; + } | { + tag: "compactU64"; + value: undefined; + } | { + tag: "compactU128"; + value: undefined; + } | { + tag: "compactU256"; + value: undefined; + } | { + tag: "void"; + value: undefined; + } | { + tag: "perId"; + value: number; + }>; + } & { + inner: { + bool: Codec; + char: Codec; + str: Codec; + u8: Codec; + u16: Codec; + u32: Codec; + u64: Codec; + u128: Codec; + u256: Codec; + i8: Codec; + i16: Codec; + i32: Codec; + i64: Codec; + i128: Codec; + i256: Codec; + compactU8: Codec; + compactU16: Codec; + compactU32: Codec; + compactU64: Codec; + compactU128: Codec; + compactU256: Codec; + void: Codec; + perId: Codec; + }; + }; + callTy: [_pezkuwi_bizinikiwi_bindings.Encoder<{ + tag: "bool"; + value: undefined; + } | { + tag: "char"; + value: undefined; + } | { + tag: "str"; + value: undefined; + } | { + tag: "u8"; + value: undefined; + } | { + tag: "u16"; + value: undefined; + } | { + tag: "u32"; + value: undefined; + } | { + tag: "u64"; + value: undefined; + } | { + tag: "u128"; + value: undefined; + } | { + tag: "u256"; + value: undefined; + } | { + tag: "i8"; + value: undefined; + } | { + tag: "i16"; + value: undefined; + } | { + tag: "i32"; + value: undefined; + } | { + tag: "i64"; + value: undefined; + } | { + tag: "i128"; + value: undefined; + } | { + tag: "i256"; + value: undefined; + } | { + tag: "compactU8"; + value: undefined; + } | { + tag: "compactU16"; + value: undefined; + } | { + tag: "compactU32"; + value: undefined; + } | { + tag: "compactU64"; + value: undefined; + } | { + tag: "compactU128"; + value: undefined; + } | { + tag: "compactU256"; + value: undefined; + } | { + tag: "void"; + value: undefined; + } | { + tag: "perId"; + value: number; + }>, _pezkuwi_bizinikiwi_bindings.Decoder<{ + tag: "bool"; + value: undefined; + } | { + tag: "char"; + value: undefined; + } | { + tag: "str"; + value: undefined; + } | { + tag: "u8"; + value: undefined; + } | { + tag: "u16"; + value: undefined; + } | { + tag: "u32"; + value: undefined; + } | { + tag: "u64"; + value: undefined; + } | { + tag: "u128"; + value: undefined; + } | { + tag: "u256"; + value: undefined; + } | { + tag: "i8"; + value: undefined; + } | { + tag: "i16"; + value: undefined; + } | { + tag: "i32"; + value: undefined; + } | { + tag: "i64"; + value: undefined; + } | { + tag: "i128"; + value: undefined; + } | { + tag: "i256"; + value: undefined; + } | { + tag: "compactU8"; + value: undefined; + } | { + tag: "compactU16"; + value: undefined; + } | { + tag: "compactU32"; + value: undefined; + } | { + tag: "compactU64"; + value: undefined; + } | { + tag: "compactU128"; + value: undefined; + } | { + tag: "compactU256"; + value: undefined; + } | { + tag: "void"; + value: undefined; + } | { + tag: "perId"; + value: number; + }>] & { + enc: _pezkuwi_bizinikiwi_bindings.Encoder<{ + tag: "bool"; + value: undefined; + } | { + tag: "char"; + value: undefined; + } | { + tag: "str"; + value: undefined; + } | { + tag: "u8"; + value: undefined; + } | { + tag: "u16"; + value: undefined; + } | { + tag: "u32"; + value: undefined; + } | { + tag: "u64"; + value: undefined; + } | { + tag: "u128"; + value: undefined; + } | { + tag: "u256"; + value: undefined; + } | { + tag: "i8"; + value: undefined; + } | { + tag: "i16"; + value: undefined; + } | { + tag: "i32"; + value: undefined; + } | { + tag: "i64"; + value: undefined; + } | { + tag: "i128"; + value: undefined; + } | { + tag: "i256"; + value: undefined; + } | { + tag: "compactU8"; + value: undefined; + } | { + tag: "compactU16"; + value: undefined; + } | { + tag: "compactU32"; + value: undefined; + } | { + tag: "compactU64"; + value: undefined; + } | { + tag: "compactU128"; + value: undefined; + } | { + tag: "compactU256"; + value: undefined; + } | { + tag: "void"; + value: undefined; + } | { + tag: "perId"; + value: number; + }>; + dec: _pezkuwi_bizinikiwi_bindings.Decoder<{ + tag: "bool"; + value: undefined; + } | { + tag: "char"; + value: undefined; + } | { + tag: "str"; + value: undefined; + } | { + tag: "u8"; + value: undefined; + } | { + tag: "u16"; + value: undefined; + } | { + tag: "u32"; + value: undefined; + } | { + tag: "u64"; + value: undefined; + } | { + tag: "u128"; + value: undefined; + } | { + tag: "u256"; + value: undefined; + } | { + tag: "i8"; + value: undefined; + } | { + tag: "i16"; + value: undefined; + } | { + tag: "i32"; + value: undefined; + } | { + tag: "i64"; + value: undefined; + } | { + tag: "i128"; + value: undefined; + } | { + tag: "i256"; + value: undefined; + } | { + tag: "compactU8"; + value: undefined; + } | { + tag: "compactU16"; + value: undefined; + } | { + tag: "compactU32"; + value: undefined; + } | { + tag: "compactU64"; + value: undefined; + } | { + tag: "compactU128"; + value: undefined; + } | { + tag: "compactU256"; + value: undefined; + } | { + tag: "void"; + value: undefined; + } | { + tag: "perId"; + value: number; + }>; + } & { + inner: { + bool: Codec; + char: Codec; + str: Codec; + u8: Codec; + u16: Codec; + u32: Codec; + u64: Codec; + u128: Codec; + u256: Codec; + i8: Codec; + i16: Codec; + i32: Codec; + i64: Codec; + i128: Codec; + i256: Codec; + compactU8: Codec; + compactU16: Codec; + compactU32: Codec; + compactU64: Codec; + compactU128: Codec; + compactU256: Codec; + void: Codec; + perId: Codec; + }; + }; + signatureTy: [_pezkuwi_bizinikiwi_bindings.Encoder<{ + tag: "bool"; + value: undefined; + } | { + tag: "char"; + value: undefined; + } | { + tag: "str"; + value: undefined; + } | { + tag: "u8"; + value: undefined; + } | { + tag: "u16"; + value: undefined; + } | { + tag: "u32"; + value: undefined; + } | { + tag: "u64"; + value: undefined; + } | { + tag: "u128"; + value: undefined; + } | { + tag: "u256"; + value: undefined; + } | { + tag: "i8"; + value: undefined; + } | { + tag: "i16"; + value: undefined; + } | { + tag: "i32"; + value: undefined; + } | { + tag: "i64"; + value: undefined; + } | { + tag: "i128"; + value: undefined; + } | { + tag: "i256"; + value: undefined; + } | { + tag: "compactU8"; + value: undefined; + } | { + tag: "compactU16"; + value: undefined; + } | { + tag: "compactU32"; + value: undefined; + } | { + tag: "compactU64"; + value: undefined; + } | { + tag: "compactU128"; + value: undefined; + } | { + tag: "compactU256"; + value: undefined; + } | { + tag: "void"; + value: undefined; + } | { + tag: "perId"; + value: number; + }>, _pezkuwi_bizinikiwi_bindings.Decoder<{ + tag: "bool"; + value: undefined; + } | { + tag: "char"; + value: undefined; + } | { + tag: "str"; + value: undefined; + } | { + tag: "u8"; + value: undefined; + } | { + tag: "u16"; + value: undefined; + } | { + tag: "u32"; + value: undefined; + } | { + tag: "u64"; + value: undefined; + } | { + tag: "u128"; + value: undefined; + } | { + tag: "u256"; + value: undefined; + } | { + tag: "i8"; + value: undefined; + } | { + tag: "i16"; + value: undefined; + } | { + tag: "i32"; + value: undefined; + } | { + tag: "i64"; + value: undefined; + } | { + tag: "i128"; + value: undefined; + } | { + tag: "i256"; + value: undefined; + } | { + tag: "compactU8"; + value: undefined; + } | { + tag: "compactU16"; + value: undefined; + } | { + tag: "compactU32"; + value: undefined; + } | { + tag: "compactU64"; + value: undefined; + } | { + tag: "compactU128"; + value: undefined; + } | { + tag: "compactU256"; + value: undefined; + } | { + tag: "void"; + value: undefined; + } | { + tag: "perId"; + value: number; + }>] & { + enc: _pezkuwi_bizinikiwi_bindings.Encoder<{ + tag: "bool"; + value: undefined; + } | { + tag: "char"; + value: undefined; + } | { + tag: "str"; + value: undefined; + } | { + tag: "u8"; + value: undefined; + } | { + tag: "u16"; + value: undefined; + } | { + tag: "u32"; + value: undefined; + } | { + tag: "u64"; + value: undefined; + } | { + tag: "u128"; + value: undefined; + } | { + tag: "u256"; + value: undefined; + } | { + tag: "i8"; + value: undefined; + } | { + tag: "i16"; + value: undefined; + } | { + tag: "i32"; + value: undefined; + } | { + tag: "i64"; + value: undefined; + } | { + tag: "i128"; + value: undefined; + } | { + tag: "i256"; + value: undefined; + } | { + tag: "compactU8"; + value: undefined; + } | { + tag: "compactU16"; + value: undefined; + } | { + tag: "compactU32"; + value: undefined; + } | { + tag: "compactU64"; + value: undefined; + } | { + tag: "compactU128"; + value: undefined; + } | { + tag: "compactU256"; + value: undefined; + } | { + tag: "void"; + value: undefined; + } | { + tag: "perId"; + value: number; + }>; + dec: _pezkuwi_bizinikiwi_bindings.Decoder<{ + tag: "bool"; + value: undefined; + } | { + tag: "char"; + value: undefined; + } | { + tag: "str"; + value: undefined; + } | { + tag: "u8"; + value: undefined; + } | { + tag: "u16"; + value: undefined; + } | { + tag: "u32"; + value: undefined; + } | { + tag: "u64"; + value: undefined; + } | { + tag: "u128"; + value: undefined; + } | { + tag: "u256"; + value: undefined; + } | { + tag: "i8"; + value: undefined; + } | { + tag: "i16"; + value: undefined; + } | { + tag: "i32"; + value: undefined; + } | { + tag: "i64"; + value: undefined; + } | { + tag: "i128"; + value: undefined; + } | { + tag: "i256"; + value: undefined; + } | { + tag: "compactU8"; + value: undefined; + } | { + tag: "compactU16"; + value: undefined; + } | { + tag: "compactU32"; + value: undefined; + } | { + tag: "compactU64"; + value: undefined; + } | { + tag: "compactU128"; + value: undefined; + } | { + tag: "compactU256"; + value: undefined; + } | { + tag: "void"; + value: undefined; + } | { + tag: "perId"; + value: number; + }>; + } & { + inner: { + bool: Codec; + char: Codec; + str: Codec; + u8: Codec; + u16: Codec; + u32: Codec; + u64: Codec; + u128: Codec; + u256: Codec; + i8: Codec; + i16: Codec; + i32: Codec; + i64: Codec; + i128: Codec; + i256: Codec; + compactU8: Codec; + compactU16: Codec; + compactU32: Codec; + compactU64: Codec; + compactU128: Codec; + compactU256: Codec; + void: Codec; + perId: Codec; + }; + }; + signedExtensions: [_pezkuwi_bizinikiwi_bindings.Encoder<{ + identifier: string; + includedInExtrinsic: { + tag: "bool"; + value: undefined; + } | { + tag: "char"; + value: undefined; + } | { + tag: "str"; + value: undefined; + } | { + tag: "u8"; + value: undefined; + } | { + tag: "u16"; + value: undefined; + } | { + tag: "u32"; + value: undefined; + } | { + tag: "u64"; + value: undefined; + } | { + tag: "u128"; + value: undefined; + } | { + tag: "u256"; + value: undefined; + } | { + tag: "i8"; + value: undefined; + } | { + tag: "i16"; + value: undefined; + } | { + tag: "i32"; + value: undefined; + } | { + tag: "i64"; + value: undefined; + } | { + tag: "i128"; + value: undefined; + } | { + tag: "i256"; + value: undefined; + } | { + tag: "compactU8"; + value: undefined; + } | { + tag: "compactU16"; + value: undefined; + } | { + tag: "compactU32"; + value: undefined; + } | { + tag: "compactU64"; + value: undefined; + } | { + tag: "compactU128"; + value: undefined; + } | { + tag: "compactU256"; + value: undefined; + } | { + tag: "void"; + value: undefined; + } | { + tag: "perId"; + value: number; + }; + includedInSignedData: { + tag: "bool"; + value: undefined; + } | { + tag: "char"; + value: undefined; + } | { + tag: "str"; + value: undefined; + } | { + tag: "u8"; + value: undefined; + } | { + tag: "u16"; + value: undefined; + } | { + tag: "u32"; + value: undefined; + } | { + tag: "u64"; + value: undefined; + } | { + tag: "u128"; + value: undefined; + } | { + tag: "u256"; + value: undefined; + } | { + tag: "i8"; + value: undefined; + } | { + tag: "i16"; + value: undefined; + } | { + tag: "i32"; + value: undefined; + } | { + tag: "i64"; + value: undefined; + } | { + tag: "i128"; + value: undefined; + } | { + tag: "i256"; + value: undefined; + } | { + tag: "compactU8"; + value: undefined; + } | { + tag: "compactU16"; + value: undefined; + } | { + tag: "compactU32"; + value: undefined; + } | { + tag: "compactU64"; + value: undefined; + } | { + tag: "compactU128"; + value: undefined; + } | { + tag: "compactU256"; + value: undefined; + } | { + tag: "void"; + value: undefined; + } | { + tag: "perId"; + value: number; + }; + }[]>, _pezkuwi_bizinikiwi_bindings.Decoder<{ + identifier: string; + includedInExtrinsic: { + tag: "bool"; + value: undefined; + } | { + tag: "char"; + value: undefined; + } | { + tag: "str"; + value: undefined; + } | { + tag: "u8"; + value: undefined; + } | { + tag: "u16"; + value: undefined; + } | { + tag: "u32"; + value: undefined; + } | { + tag: "u64"; + value: undefined; + } | { + tag: "u128"; + value: undefined; + } | { + tag: "u256"; + value: undefined; + } | { + tag: "i8"; + value: undefined; + } | { + tag: "i16"; + value: undefined; + } | { + tag: "i32"; + value: undefined; + } | { + tag: "i64"; + value: undefined; + } | { + tag: "i128"; + value: undefined; + } | { + tag: "i256"; + value: undefined; + } | { + tag: "compactU8"; + value: undefined; + } | { + tag: "compactU16"; + value: undefined; + } | { + tag: "compactU32"; + value: undefined; + } | { + tag: "compactU64"; + value: undefined; + } | { + tag: "compactU128"; + value: undefined; + } | { + tag: "compactU256"; + value: undefined; + } | { + tag: "void"; + value: undefined; + } | { + tag: "perId"; + value: number; + }; + includedInSignedData: { + tag: "bool"; + value: undefined; + } | { + tag: "char"; + value: undefined; + } | { + tag: "str"; + value: undefined; + } | { + tag: "u8"; + value: undefined; + } | { + tag: "u16"; + value: undefined; + } | { + tag: "u32"; + value: undefined; + } | { + tag: "u64"; + value: undefined; + } | { + tag: "u128"; + value: undefined; + } | { + tag: "u256"; + value: undefined; + } | { + tag: "i8"; + value: undefined; + } | { + tag: "i16"; + value: undefined; + } | { + tag: "i32"; + value: undefined; + } | { + tag: "i64"; + value: undefined; + } | { + tag: "i128"; + value: undefined; + } | { + tag: "i256"; + value: undefined; + } | { + tag: "compactU8"; + value: undefined; + } | { + tag: "compactU16"; + value: undefined; + } | { + tag: "compactU32"; + value: undefined; + } | { + tag: "compactU64"; + value: undefined; + } | { + tag: "compactU128"; + value: undefined; + } | { + tag: "compactU256"; + value: undefined; + } | { + tag: "void"; + value: undefined; + } | { + tag: "perId"; + value: number; + }; + }[]>] & { + enc: _pezkuwi_bizinikiwi_bindings.Encoder<{ + identifier: string; + includedInExtrinsic: { + tag: "bool"; + value: undefined; + } | { + tag: "char"; + value: undefined; + } | { + tag: "str"; + value: undefined; + } | { + tag: "u8"; + value: undefined; + } | { + tag: "u16"; + value: undefined; + } | { + tag: "u32"; + value: undefined; + } | { + tag: "u64"; + value: undefined; + } | { + tag: "u128"; + value: undefined; + } | { + tag: "u256"; + value: undefined; + } | { + tag: "i8"; + value: undefined; + } | { + tag: "i16"; + value: undefined; + } | { + tag: "i32"; + value: undefined; + } | { + tag: "i64"; + value: undefined; + } | { + tag: "i128"; + value: undefined; + } | { + tag: "i256"; + value: undefined; + } | { + tag: "compactU8"; + value: undefined; + } | { + tag: "compactU16"; + value: undefined; + } | { + tag: "compactU32"; + value: undefined; + } | { + tag: "compactU64"; + value: undefined; + } | { + tag: "compactU128"; + value: undefined; + } | { + tag: "compactU256"; + value: undefined; + } | { + tag: "void"; + value: undefined; + } | { + tag: "perId"; + value: number; + }; + includedInSignedData: { + tag: "bool"; + value: undefined; + } | { + tag: "char"; + value: undefined; + } | { + tag: "str"; + value: undefined; + } | { + tag: "u8"; + value: undefined; + } | { + tag: "u16"; + value: undefined; + } | { + tag: "u32"; + value: undefined; + } | { + tag: "u64"; + value: undefined; + } | { + tag: "u128"; + value: undefined; + } | { + tag: "u256"; + value: undefined; + } | { + tag: "i8"; + value: undefined; + } | { + tag: "i16"; + value: undefined; + } | { + tag: "i32"; + value: undefined; + } | { + tag: "i64"; + value: undefined; + } | { + tag: "i128"; + value: undefined; + } | { + tag: "i256"; + value: undefined; + } | { + tag: "compactU8"; + value: undefined; + } | { + tag: "compactU16"; + value: undefined; + } | { + tag: "compactU32"; + value: undefined; + } | { + tag: "compactU64"; + value: undefined; + } | { + tag: "compactU128"; + value: undefined; + } | { + tag: "compactU256"; + value: undefined; + } | { + tag: "void"; + value: undefined; + } | { + tag: "perId"; + value: number; + }; + }[]>; + dec: _pezkuwi_bizinikiwi_bindings.Decoder<{ + identifier: string; + includedInExtrinsic: { + tag: "bool"; + value: undefined; + } | { + tag: "char"; + value: undefined; + } | { + tag: "str"; + value: undefined; + } | { + tag: "u8"; + value: undefined; + } | { + tag: "u16"; + value: undefined; + } | { + tag: "u32"; + value: undefined; + } | { + tag: "u64"; + value: undefined; + } | { + tag: "u128"; + value: undefined; + } | { + tag: "u256"; + value: undefined; + } | { + tag: "i8"; + value: undefined; + } | { + tag: "i16"; + value: undefined; + } | { + tag: "i32"; + value: undefined; + } | { + tag: "i64"; + value: undefined; + } | { + tag: "i128"; + value: undefined; + } | { + tag: "i256"; + value: undefined; + } | { + tag: "compactU8"; + value: undefined; + } | { + tag: "compactU16"; + value: undefined; + } | { + tag: "compactU32"; + value: undefined; + } | { + tag: "compactU64"; + value: undefined; + } | { + tag: "compactU128"; + value: undefined; + } | { + tag: "compactU256"; + value: undefined; + } | { + tag: "void"; + value: undefined; + } | { + tag: "perId"; + value: number; + }; + includedInSignedData: { + tag: "bool"; + value: undefined; + } | { + tag: "char"; + value: undefined; + } | { + tag: "str"; + value: undefined; + } | { + tag: "u8"; + value: undefined; + } | { + tag: "u16"; + value: undefined; + } | { + tag: "u32"; + value: undefined; + } | { + tag: "u64"; + value: undefined; + } | { + tag: "u128"; + value: undefined; + } | { + tag: "u256"; + value: undefined; + } | { + tag: "i8"; + value: undefined; + } | { + tag: "i16"; + value: undefined; + } | { + tag: "i32"; + value: undefined; + } | { + tag: "i64"; + value: undefined; + } | { + tag: "i128"; + value: undefined; + } | { + tag: "i256"; + value: undefined; + } | { + tag: "compactU8"; + value: undefined; + } | { + tag: "compactU16"; + value: undefined; + } | { + tag: "compactU32"; + value: undefined; + } | { + tag: "compactU64"; + value: undefined; + } | { + tag: "compactU128"; + value: undefined; + } | { + tag: "compactU256"; + value: undefined; + } | { + tag: "void"; + value: undefined; + } | { + tag: "perId"; + value: number; + }; + }[]>; + } & { + inner: Codec<{ + identifier: string; + includedInExtrinsic: { + tag: "bool"; + value: undefined; + } | { + tag: "char"; + value: undefined; + } | { + tag: "str"; + value: undefined; + } | { + tag: "u8"; + value: undefined; + } | { + tag: "u16"; + value: undefined; + } | { + tag: "u32"; + value: undefined; + } | { + tag: "u64"; + value: undefined; + } | { + tag: "u128"; + value: undefined; + } | { + tag: "u256"; + value: undefined; + } | { + tag: "i8"; + value: undefined; + } | { + tag: "i16"; + value: undefined; + } | { + tag: "i32"; + value: undefined; + } | { + tag: "i64"; + value: undefined; + } | { + tag: "i128"; + value: undefined; + } | { + tag: "i256"; + value: undefined; + } | { + tag: "compactU8"; + value: undefined; + } | { + tag: "compactU16"; + value: undefined; + } | { + tag: "compactU32"; + value: undefined; + } | { + tag: "compactU64"; + value: undefined; + } | { + tag: "compactU128"; + value: undefined; + } | { + tag: "compactU256"; + value: undefined; + } | { + tag: "void"; + value: undefined; + } | { + tag: "perId"; + value: number; + }; + includedInSignedData: { + tag: "bool"; + value: undefined; + } | { + tag: "char"; + value: undefined; + } | { + tag: "str"; + value: undefined; + } | { + tag: "u8"; + value: undefined; + } | { + tag: "u16"; + value: undefined; + } | { + tag: "u32"; + value: undefined; + } | { + tag: "u64"; + value: undefined; + } | { + tag: "u128"; + value: undefined; + } | { + tag: "u256"; + value: undefined; + } | { + tag: "i8"; + value: undefined; + } | { + tag: "i16"; + value: undefined; + } | { + tag: "i32"; + value: undefined; + } | { + tag: "i64"; + value: undefined; + } | { + tag: "i128"; + value: undefined; + } | { + tag: "i256"; + value: undefined; + } | { + tag: "compactU8"; + value: undefined; + } | { + tag: "compactU16"; + value: undefined; + } | { + tag: "compactU32"; + value: undefined; + } | { + tag: "compactU64"; + value: undefined; + } | { + tag: "compactU128"; + value: undefined; + } | { + tag: "compactU256"; + value: undefined; + } | { + tag: "void"; + value: undefined; + } | { + tag: "perId"; + value: number; + }; + }>; + }; + }; +}; +type ExtrinsicMetadata = CodecType; +declare const proof: [_pezkuwi_bizinikiwi_bindings.Encoder<{ + leaves: Lookup; + leafIdxs: number[]; + proofs: Uint8Array[]; + extrinsic: { + version: number; + addressTy: { + tag: "bool"; + value: undefined; + } | { + tag: "char"; + value: undefined; + } | { + tag: "str"; + value: undefined; + } | { + tag: "u8"; + value: undefined; + } | { + tag: "u16"; + value: undefined; + } | { + tag: "u32"; + value: undefined; + } | { + tag: "u64"; + value: undefined; + } | { + tag: "u128"; + value: undefined; + } | { + tag: "u256"; + value: undefined; + } | { + tag: "i8"; + value: undefined; + } | { + tag: "i16"; + value: undefined; + } | { + tag: "i32"; + value: undefined; + } | { + tag: "i64"; + value: undefined; + } | { + tag: "i128"; + value: undefined; + } | { + tag: "i256"; + value: undefined; + } | { + tag: "compactU8"; + value: undefined; + } | { + tag: "compactU16"; + value: undefined; + } | { + tag: "compactU32"; + value: undefined; + } | { + tag: "compactU64"; + value: undefined; + } | { + tag: "compactU128"; + value: undefined; + } | { + tag: "compactU256"; + value: undefined; + } | { + tag: "void"; + value: undefined; + } | { + tag: "perId"; + value: number; + }; + callTy: { + tag: "bool"; + value: undefined; + } | { + tag: "char"; + value: undefined; + } | { + tag: "str"; + value: undefined; + } | { + tag: "u8"; + value: undefined; + } | { + tag: "u16"; + value: undefined; + } | { + tag: "u32"; + value: undefined; + } | { + tag: "u64"; + value: undefined; + } | { + tag: "u128"; + value: undefined; + } | { + tag: "u256"; + value: undefined; + } | { + tag: "i8"; + value: undefined; + } | { + tag: "i16"; + value: undefined; + } | { + tag: "i32"; + value: undefined; + } | { + tag: "i64"; + value: undefined; + } | { + tag: "i128"; + value: undefined; + } | { + tag: "i256"; + value: undefined; + } | { + tag: "compactU8"; + value: undefined; + } | { + tag: "compactU16"; + value: undefined; + } | { + tag: "compactU32"; + value: undefined; + } | { + tag: "compactU64"; + value: undefined; + } | { + tag: "compactU128"; + value: undefined; + } | { + tag: "compactU256"; + value: undefined; + } | { + tag: "void"; + value: undefined; + } | { + tag: "perId"; + value: number; + }; + signatureTy: { + tag: "bool"; + value: undefined; + } | { + tag: "char"; + value: undefined; + } | { + tag: "str"; + value: undefined; + } | { + tag: "u8"; + value: undefined; + } | { + tag: "u16"; + value: undefined; + } | { + tag: "u32"; + value: undefined; + } | { + tag: "u64"; + value: undefined; + } | { + tag: "u128"; + value: undefined; + } | { + tag: "u256"; + value: undefined; + } | { + tag: "i8"; + value: undefined; + } | { + tag: "i16"; + value: undefined; + } | { + tag: "i32"; + value: undefined; + } | { + tag: "i64"; + value: undefined; + } | { + tag: "i128"; + value: undefined; + } | { + tag: "i256"; + value: undefined; + } | { + tag: "compactU8"; + value: undefined; + } | { + tag: "compactU16"; + value: undefined; + } | { + tag: "compactU32"; + value: undefined; + } | { + tag: "compactU64"; + value: undefined; + } | { + tag: "compactU128"; + value: undefined; + } | { + tag: "compactU256"; + value: undefined; + } | { + tag: "void"; + value: undefined; + } | { + tag: "perId"; + value: number; + }; + signedExtensions: { + identifier: string; + includedInExtrinsic: { + tag: "bool"; + value: undefined; + } | { + tag: "char"; + value: undefined; + } | { + tag: "str"; + value: undefined; + } | { + tag: "u8"; + value: undefined; + } | { + tag: "u16"; + value: undefined; + } | { + tag: "u32"; + value: undefined; + } | { + tag: "u64"; + value: undefined; + } | { + tag: "u128"; + value: undefined; + } | { + tag: "u256"; + value: undefined; + } | { + tag: "i8"; + value: undefined; + } | { + tag: "i16"; + value: undefined; + } | { + tag: "i32"; + value: undefined; + } | { + tag: "i64"; + value: undefined; + } | { + tag: "i128"; + value: undefined; + } | { + tag: "i256"; + value: undefined; + } | { + tag: "compactU8"; + value: undefined; + } | { + tag: "compactU16"; + value: undefined; + } | { + tag: "compactU32"; + value: undefined; + } | { + tag: "compactU64"; + value: undefined; + } | { + tag: "compactU128"; + value: undefined; + } | { + tag: "compactU256"; + value: undefined; + } | { + tag: "void"; + value: undefined; + } | { + tag: "perId"; + value: number; + }; + includedInSignedData: { + tag: "bool"; + value: undefined; + } | { + tag: "char"; + value: undefined; + } | { + tag: "str"; + value: undefined; + } | { + tag: "u8"; + value: undefined; + } | { + tag: "u16"; + value: undefined; + } | { + tag: "u32"; + value: undefined; + } | { + tag: "u64"; + value: undefined; + } | { + tag: "u128"; + value: undefined; + } | { + tag: "u256"; + value: undefined; + } | { + tag: "i8"; + value: undefined; + } | { + tag: "i16"; + value: undefined; + } | { + tag: "i32"; + value: undefined; + } | { + tag: "i64"; + value: undefined; + } | { + tag: "i128"; + value: undefined; + } | { + tag: "i256"; + value: undefined; + } | { + tag: "compactU8"; + value: undefined; + } | { + tag: "compactU16"; + value: undefined; + } | { + tag: "compactU32"; + value: undefined; + } | { + tag: "compactU64"; + value: undefined; + } | { + tag: "compactU128"; + value: undefined; + } | { + tag: "compactU256"; + value: undefined; + } | { + tag: "void"; + value: undefined; + } | { + tag: "perId"; + value: number; + }; + }[]; + }; + info: { + specVersion: number; + specName: string; + base58Prefix: number; + decimals: number; + tokenSymbol: string; + }; +}>, _pezkuwi_bizinikiwi_bindings.Decoder<{ + leaves: Lookup; + leafIdxs: number[]; + proofs: Uint8Array[]; + extrinsic: { + version: number; + addressTy: { + tag: "bool"; + value: undefined; + } | { + tag: "char"; + value: undefined; + } | { + tag: "str"; + value: undefined; + } | { + tag: "u8"; + value: undefined; + } | { + tag: "u16"; + value: undefined; + } | { + tag: "u32"; + value: undefined; + } | { + tag: "u64"; + value: undefined; + } | { + tag: "u128"; + value: undefined; + } | { + tag: "u256"; + value: undefined; + } | { + tag: "i8"; + value: undefined; + } | { + tag: "i16"; + value: undefined; + } | { + tag: "i32"; + value: undefined; + } | { + tag: "i64"; + value: undefined; + } | { + tag: "i128"; + value: undefined; + } | { + tag: "i256"; + value: undefined; + } | { + tag: "compactU8"; + value: undefined; + } | { + tag: "compactU16"; + value: undefined; + } | { + tag: "compactU32"; + value: undefined; + } | { + tag: "compactU64"; + value: undefined; + } | { + tag: "compactU128"; + value: undefined; + } | { + tag: "compactU256"; + value: undefined; + } | { + tag: "void"; + value: undefined; + } | { + tag: "perId"; + value: number; + }; + callTy: { + tag: "bool"; + value: undefined; + } | { + tag: "char"; + value: undefined; + } | { + tag: "str"; + value: undefined; + } | { + tag: "u8"; + value: undefined; + } | { + tag: "u16"; + value: undefined; + } | { + tag: "u32"; + value: undefined; + } | { + tag: "u64"; + value: undefined; + } | { + tag: "u128"; + value: undefined; + } | { + tag: "u256"; + value: undefined; + } | { + tag: "i8"; + value: undefined; + } | { + tag: "i16"; + value: undefined; + } | { + tag: "i32"; + value: undefined; + } | { + tag: "i64"; + value: undefined; + } | { + tag: "i128"; + value: undefined; + } | { + tag: "i256"; + value: undefined; + } | { + tag: "compactU8"; + value: undefined; + } | { + tag: "compactU16"; + value: undefined; + } | { + tag: "compactU32"; + value: undefined; + } | { + tag: "compactU64"; + value: undefined; + } | { + tag: "compactU128"; + value: undefined; + } | { + tag: "compactU256"; + value: undefined; + } | { + tag: "void"; + value: undefined; + } | { + tag: "perId"; + value: number; + }; + signatureTy: { + tag: "bool"; + value: undefined; + } | { + tag: "char"; + value: undefined; + } | { + tag: "str"; + value: undefined; + } | { + tag: "u8"; + value: undefined; + } | { + tag: "u16"; + value: undefined; + } | { + tag: "u32"; + value: undefined; + } | { + tag: "u64"; + value: undefined; + } | { + tag: "u128"; + value: undefined; + } | { + tag: "u256"; + value: undefined; + } | { + tag: "i8"; + value: undefined; + } | { + tag: "i16"; + value: undefined; + } | { + tag: "i32"; + value: undefined; + } | { + tag: "i64"; + value: undefined; + } | { + tag: "i128"; + value: undefined; + } | { + tag: "i256"; + value: undefined; + } | { + tag: "compactU8"; + value: undefined; + } | { + tag: "compactU16"; + value: undefined; + } | { + tag: "compactU32"; + value: undefined; + } | { + tag: "compactU64"; + value: undefined; + } | { + tag: "compactU128"; + value: undefined; + } | { + tag: "compactU256"; + value: undefined; + } | { + tag: "void"; + value: undefined; + } | { + tag: "perId"; + value: number; + }; + signedExtensions: { + identifier: string; + includedInExtrinsic: { + tag: "bool"; + value: undefined; + } | { + tag: "char"; + value: undefined; + } | { + tag: "str"; + value: undefined; + } | { + tag: "u8"; + value: undefined; + } | { + tag: "u16"; + value: undefined; + } | { + tag: "u32"; + value: undefined; + } | { + tag: "u64"; + value: undefined; + } | { + tag: "u128"; + value: undefined; + } | { + tag: "u256"; + value: undefined; + } | { + tag: "i8"; + value: undefined; + } | { + tag: "i16"; + value: undefined; + } | { + tag: "i32"; + value: undefined; + } | { + tag: "i64"; + value: undefined; + } | { + tag: "i128"; + value: undefined; + } | { + tag: "i256"; + value: undefined; + } | { + tag: "compactU8"; + value: undefined; + } | { + tag: "compactU16"; + value: undefined; + } | { + tag: "compactU32"; + value: undefined; + } | { + tag: "compactU64"; + value: undefined; + } | { + tag: "compactU128"; + value: undefined; + } | { + tag: "compactU256"; + value: undefined; + } | { + tag: "void"; + value: undefined; + } | { + tag: "perId"; + value: number; + }; + includedInSignedData: { + tag: "bool"; + value: undefined; + } | { + tag: "char"; + value: undefined; + } | { + tag: "str"; + value: undefined; + } | { + tag: "u8"; + value: undefined; + } | { + tag: "u16"; + value: undefined; + } | { + tag: "u32"; + value: undefined; + } | { + tag: "u64"; + value: undefined; + } | { + tag: "u128"; + value: undefined; + } | { + tag: "u256"; + value: undefined; + } | { + tag: "i8"; + value: undefined; + } | { + tag: "i16"; + value: undefined; + } | { + tag: "i32"; + value: undefined; + } | { + tag: "i64"; + value: undefined; + } | { + tag: "i128"; + value: undefined; + } | { + tag: "i256"; + value: undefined; + } | { + tag: "compactU8"; + value: undefined; + } | { + tag: "compactU16"; + value: undefined; + } | { + tag: "compactU32"; + value: undefined; + } | { + tag: "compactU64"; + value: undefined; + } | { + tag: "compactU128"; + value: undefined; + } | { + tag: "compactU256"; + value: undefined; + } | { + tag: "void"; + value: undefined; + } | { + tag: "perId"; + value: number; + }; + }[]; + }; + info: { + specVersion: number; + specName: string; + base58Prefix: number; + decimals: number; + tokenSymbol: string; + }; +}>] & { + enc: _pezkuwi_bizinikiwi_bindings.Encoder<{ + leaves: Lookup; + leafIdxs: number[]; + proofs: Uint8Array[]; + extrinsic: { + version: number; + addressTy: { + tag: "bool"; + value: undefined; + } | { + tag: "char"; + value: undefined; + } | { + tag: "str"; + value: undefined; + } | { + tag: "u8"; + value: undefined; + } | { + tag: "u16"; + value: undefined; + } | { + tag: "u32"; + value: undefined; + } | { + tag: "u64"; + value: undefined; + } | { + tag: "u128"; + value: undefined; + } | { + tag: "u256"; + value: undefined; + } | { + tag: "i8"; + value: undefined; + } | { + tag: "i16"; + value: undefined; + } | { + tag: "i32"; + value: undefined; + } | { + tag: "i64"; + value: undefined; + } | { + tag: "i128"; + value: undefined; + } | { + tag: "i256"; + value: undefined; + } | { + tag: "compactU8"; + value: undefined; + } | { + tag: "compactU16"; + value: undefined; + } | { + tag: "compactU32"; + value: undefined; + } | { + tag: "compactU64"; + value: undefined; + } | { + tag: "compactU128"; + value: undefined; + } | { + tag: "compactU256"; + value: undefined; + } | { + tag: "void"; + value: undefined; + } | { + tag: "perId"; + value: number; + }; + callTy: { + tag: "bool"; + value: undefined; + } | { + tag: "char"; + value: undefined; + } | { + tag: "str"; + value: undefined; + } | { + tag: "u8"; + value: undefined; + } | { + tag: "u16"; + value: undefined; + } | { + tag: "u32"; + value: undefined; + } | { + tag: "u64"; + value: undefined; + } | { + tag: "u128"; + value: undefined; + } | { + tag: "u256"; + value: undefined; + } | { + tag: "i8"; + value: undefined; + } | { + tag: "i16"; + value: undefined; + } | { + tag: "i32"; + value: undefined; + } | { + tag: "i64"; + value: undefined; + } | { + tag: "i128"; + value: undefined; + } | { + tag: "i256"; + value: undefined; + } | { + tag: "compactU8"; + value: undefined; + } | { + tag: "compactU16"; + value: undefined; + } | { + tag: "compactU32"; + value: undefined; + } | { + tag: "compactU64"; + value: undefined; + } | { + tag: "compactU128"; + value: undefined; + } | { + tag: "compactU256"; + value: undefined; + } | { + tag: "void"; + value: undefined; + } | { + tag: "perId"; + value: number; + }; + signatureTy: { + tag: "bool"; + value: undefined; + } | { + tag: "char"; + value: undefined; + } | { + tag: "str"; + value: undefined; + } | { + tag: "u8"; + value: undefined; + } | { + tag: "u16"; + value: undefined; + } | { + tag: "u32"; + value: undefined; + } | { + tag: "u64"; + value: undefined; + } | { + tag: "u128"; + value: undefined; + } | { + tag: "u256"; + value: undefined; + } | { + tag: "i8"; + value: undefined; + } | { + tag: "i16"; + value: undefined; + } | { + tag: "i32"; + value: undefined; + } | { + tag: "i64"; + value: undefined; + } | { + tag: "i128"; + value: undefined; + } | { + tag: "i256"; + value: undefined; + } | { + tag: "compactU8"; + value: undefined; + } | { + tag: "compactU16"; + value: undefined; + } | { + tag: "compactU32"; + value: undefined; + } | { + tag: "compactU64"; + value: undefined; + } | { + tag: "compactU128"; + value: undefined; + } | { + tag: "compactU256"; + value: undefined; + } | { + tag: "void"; + value: undefined; + } | { + tag: "perId"; + value: number; + }; + signedExtensions: { + identifier: string; + includedInExtrinsic: { + tag: "bool"; + value: undefined; + } | { + tag: "char"; + value: undefined; + } | { + tag: "str"; + value: undefined; + } | { + tag: "u8"; + value: undefined; + } | { + tag: "u16"; + value: undefined; + } | { + tag: "u32"; + value: undefined; + } | { + tag: "u64"; + value: undefined; + } | { + tag: "u128"; + value: undefined; + } | { + tag: "u256"; + value: undefined; + } | { + tag: "i8"; + value: undefined; + } | { + tag: "i16"; + value: undefined; + } | { + tag: "i32"; + value: undefined; + } | { + tag: "i64"; + value: undefined; + } | { + tag: "i128"; + value: undefined; + } | { + tag: "i256"; + value: undefined; + } | { + tag: "compactU8"; + value: undefined; + } | { + tag: "compactU16"; + value: undefined; + } | { + tag: "compactU32"; + value: undefined; + } | { + tag: "compactU64"; + value: undefined; + } | { + tag: "compactU128"; + value: undefined; + } | { + tag: "compactU256"; + value: undefined; + } | { + tag: "void"; + value: undefined; + } | { + tag: "perId"; + value: number; + }; + includedInSignedData: { + tag: "bool"; + value: undefined; + } | { + tag: "char"; + value: undefined; + } | { + tag: "str"; + value: undefined; + } | { + tag: "u8"; + value: undefined; + } | { + tag: "u16"; + value: undefined; + } | { + tag: "u32"; + value: undefined; + } | { + tag: "u64"; + value: undefined; + } | { + tag: "u128"; + value: undefined; + } | { + tag: "u256"; + value: undefined; + } | { + tag: "i8"; + value: undefined; + } | { + tag: "i16"; + value: undefined; + } | { + tag: "i32"; + value: undefined; + } | { + tag: "i64"; + value: undefined; + } | { + tag: "i128"; + value: undefined; + } | { + tag: "i256"; + value: undefined; + } | { + tag: "compactU8"; + value: undefined; + } | { + tag: "compactU16"; + value: undefined; + } | { + tag: "compactU32"; + value: undefined; + } | { + tag: "compactU64"; + value: undefined; + } | { + tag: "compactU128"; + value: undefined; + } | { + tag: "compactU256"; + value: undefined; + } | { + tag: "void"; + value: undefined; + } | { + tag: "perId"; + value: number; + }; + }[]; + }; + info: { + specVersion: number; + specName: string; + base58Prefix: number; + decimals: number; + tokenSymbol: string; + }; + }>; + dec: _pezkuwi_bizinikiwi_bindings.Decoder<{ + leaves: Lookup; + leafIdxs: number[]; + proofs: Uint8Array[]; + extrinsic: { + version: number; + addressTy: { + tag: "bool"; + value: undefined; + } | { + tag: "char"; + value: undefined; + } | { + tag: "str"; + value: undefined; + } | { + tag: "u8"; + value: undefined; + } | { + tag: "u16"; + value: undefined; + } | { + tag: "u32"; + value: undefined; + } | { + tag: "u64"; + value: undefined; + } | { + tag: "u128"; + value: undefined; + } | { + tag: "u256"; + value: undefined; + } | { + tag: "i8"; + value: undefined; + } | { + tag: "i16"; + value: undefined; + } | { + tag: "i32"; + value: undefined; + } | { + tag: "i64"; + value: undefined; + } | { + tag: "i128"; + value: undefined; + } | { + tag: "i256"; + value: undefined; + } | { + tag: "compactU8"; + value: undefined; + } | { + tag: "compactU16"; + value: undefined; + } | { + tag: "compactU32"; + value: undefined; + } | { + tag: "compactU64"; + value: undefined; + } | { + tag: "compactU128"; + value: undefined; + } | { + tag: "compactU256"; + value: undefined; + } | { + tag: "void"; + value: undefined; + } | { + tag: "perId"; + value: number; + }; + callTy: { + tag: "bool"; + value: undefined; + } | { + tag: "char"; + value: undefined; + } | { + tag: "str"; + value: undefined; + } | { + tag: "u8"; + value: undefined; + } | { + tag: "u16"; + value: undefined; + } | { + tag: "u32"; + value: undefined; + } | { + tag: "u64"; + value: undefined; + } | { + tag: "u128"; + value: undefined; + } | { + tag: "u256"; + value: undefined; + } | { + tag: "i8"; + value: undefined; + } | { + tag: "i16"; + value: undefined; + } | { + tag: "i32"; + value: undefined; + } | { + tag: "i64"; + value: undefined; + } | { + tag: "i128"; + value: undefined; + } | { + tag: "i256"; + value: undefined; + } | { + tag: "compactU8"; + value: undefined; + } | { + tag: "compactU16"; + value: undefined; + } | { + tag: "compactU32"; + value: undefined; + } | { + tag: "compactU64"; + value: undefined; + } | { + tag: "compactU128"; + value: undefined; + } | { + tag: "compactU256"; + value: undefined; + } | { + tag: "void"; + value: undefined; + } | { + tag: "perId"; + value: number; + }; + signatureTy: { + tag: "bool"; + value: undefined; + } | { + tag: "char"; + value: undefined; + } | { + tag: "str"; + value: undefined; + } | { + tag: "u8"; + value: undefined; + } | { + tag: "u16"; + value: undefined; + } | { + tag: "u32"; + value: undefined; + } | { + tag: "u64"; + value: undefined; + } | { + tag: "u128"; + value: undefined; + } | { + tag: "u256"; + value: undefined; + } | { + tag: "i8"; + value: undefined; + } | { + tag: "i16"; + value: undefined; + } | { + tag: "i32"; + value: undefined; + } | { + tag: "i64"; + value: undefined; + } | { + tag: "i128"; + value: undefined; + } | { + tag: "i256"; + value: undefined; + } | { + tag: "compactU8"; + value: undefined; + } | { + tag: "compactU16"; + value: undefined; + } | { + tag: "compactU32"; + value: undefined; + } | { + tag: "compactU64"; + value: undefined; + } | { + tag: "compactU128"; + value: undefined; + } | { + tag: "compactU256"; + value: undefined; + } | { + tag: "void"; + value: undefined; + } | { + tag: "perId"; + value: number; + }; + signedExtensions: { + identifier: string; + includedInExtrinsic: { + tag: "bool"; + value: undefined; + } | { + tag: "char"; + value: undefined; + } | { + tag: "str"; + value: undefined; + } | { + tag: "u8"; + value: undefined; + } | { + tag: "u16"; + value: undefined; + } | { + tag: "u32"; + value: undefined; + } | { + tag: "u64"; + value: undefined; + } | { + tag: "u128"; + value: undefined; + } | { + tag: "u256"; + value: undefined; + } | { + tag: "i8"; + value: undefined; + } | { + tag: "i16"; + value: undefined; + } | { + tag: "i32"; + value: undefined; + } | { + tag: "i64"; + value: undefined; + } | { + tag: "i128"; + value: undefined; + } | { + tag: "i256"; + value: undefined; + } | { + tag: "compactU8"; + value: undefined; + } | { + tag: "compactU16"; + value: undefined; + } | { + tag: "compactU32"; + value: undefined; + } | { + tag: "compactU64"; + value: undefined; + } | { + tag: "compactU128"; + value: undefined; + } | { + tag: "compactU256"; + value: undefined; + } | { + tag: "void"; + value: undefined; + } | { + tag: "perId"; + value: number; + }; + includedInSignedData: { + tag: "bool"; + value: undefined; + } | { + tag: "char"; + value: undefined; + } | { + tag: "str"; + value: undefined; + } | { + tag: "u8"; + value: undefined; + } | { + tag: "u16"; + value: undefined; + } | { + tag: "u32"; + value: undefined; + } | { + tag: "u64"; + value: undefined; + } | { + tag: "u128"; + value: undefined; + } | { + tag: "u256"; + value: undefined; + } | { + tag: "i8"; + value: undefined; + } | { + tag: "i16"; + value: undefined; + } | { + tag: "i32"; + value: undefined; + } | { + tag: "i64"; + value: undefined; + } | { + tag: "i128"; + value: undefined; + } | { + tag: "i256"; + value: undefined; + } | { + tag: "compactU8"; + value: undefined; + } | { + tag: "compactU16"; + value: undefined; + } | { + tag: "compactU32"; + value: undefined; + } | { + tag: "compactU64"; + value: undefined; + } | { + tag: "compactU128"; + value: undefined; + } | { + tag: "compactU256"; + value: undefined; + } | { + tag: "void"; + value: undefined; + } | { + tag: "perId"; + value: number; + }; + }[]; + }; + info: { + specVersion: number; + specName: string; + base58Prefix: number; + decimals: number; + tokenSymbol: string; + }; + }>; +} & { + inner: { + leaves: Codec; + leafIdxs: [_pezkuwi_bizinikiwi_bindings.Encoder, _pezkuwi_bizinikiwi_bindings.Decoder] & { + enc: _pezkuwi_bizinikiwi_bindings.Encoder; + dec: _pezkuwi_bizinikiwi_bindings.Decoder; + } & { + inner: Codec; + }; + proofs: [_pezkuwi_bizinikiwi_bindings.Encoder[]>, _pezkuwi_bizinikiwi_bindings.Decoder[]>] & { + enc: _pezkuwi_bizinikiwi_bindings.Encoder[]>; + dec: _pezkuwi_bizinikiwi_bindings.Decoder[]>; + } & { + inner: Codec>; + }; + extrinsic: [_pezkuwi_bizinikiwi_bindings.Encoder<{ + version: number; + addressTy: { + tag: "bool"; + value: undefined; + } | { + tag: "char"; + value: undefined; + } | { + tag: "str"; + value: undefined; + } | { + tag: "u8"; + value: undefined; + } | { + tag: "u16"; + value: undefined; + } | { + tag: "u32"; + value: undefined; + } | { + tag: "u64"; + value: undefined; + } | { + tag: "u128"; + value: undefined; + } | { + tag: "u256"; + value: undefined; + } | { + tag: "i8"; + value: undefined; + } | { + tag: "i16"; + value: undefined; + } | { + tag: "i32"; + value: undefined; + } | { + tag: "i64"; + value: undefined; + } | { + tag: "i128"; + value: undefined; + } | { + tag: "i256"; + value: undefined; + } | { + tag: "compactU8"; + value: undefined; + } | { + tag: "compactU16"; + value: undefined; + } | { + tag: "compactU32"; + value: undefined; + } | { + tag: "compactU64"; + value: undefined; + } | { + tag: "compactU128"; + value: undefined; + } | { + tag: "compactU256"; + value: undefined; + } | { + tag: "void"; + value: undefined; + } | { + tag: "perId"; + value: number; + }; + callTy: { + tag: "bool"; + value: undefined; + } | { + tag: "char"; + value: undefined; + } | { + tag: "str"; + value: undefined; + } | { + tag: "u8"; + value: undefined; + } | { + tag: "u16"; + value: undefined; + } | { + tag: "u32"; + value: undefined; + } | { + tag: "u64"; + value: undefined; + } | { + tag: "u128"; + value: undefined; + } | { + tag: "u256"; + value: undefined; + } | { + tag: "i8"; + value: undefined; + } | { + tag: "i16"; + value: undefined; + } | { + tag: "i32"; + value: undefined; + } | { + tag: "i64"; + value: undefined; + } | { + tag: "i128"; + value: undefined; + } | { + tag: "i256"; + value: undefined; + } | { + tag: "compactU8"; + value: undefined; + } | { + tag: "compactU16"; + value: undefined; + } | { + tag: "compactU32"; + value: undefined; + } | { + tag: "compactU64"; + value: undefined; + } | { + tag: "compactU128"; + value: undefined; + } | { + tag: "compactU256"; + value: undefined; + } | { + tag: "void"; + value: undefined; + } | { + tag: "perId"; + value: number; + }; + signatureTy: { + tag: "bool"; + value: undefined; + } | { + tag: "char"; + value: undefined; + } | { + tag: "str"; + value: undefined; + } | { + tag: "u8"; + value: undefined; + } | { + tag: "u16"; + value: undefined; + } | { + tag: "u32"; + value: undefined; + } | { + tag: "u64"; + value: undefined; + } | { + tag: "u128"; + value: undefined; + } | { + tag: "u256"; + value: undefined; + } | { + tag: "i8"; + value: undefined; + } | { + tag: "i16"; + value: undefined; + } | { + tag: "i32"; + value: undefined; + } | { + tag: "i64"; + value: undefined; + } | { + tag: "i128"; + value: undefined; + } | { + tag: "i256"; + value: undefined; + } | { + tag: "compactU8"; + value: undefined; + } | { + tag: "compactU16"; + value: undefined; + } | { + tag: "compactU32"; + value: undefined; + } | { + tag: "compactU64"; + value: undefined; + } | { + tag: "compactU128"; + value: undefined; + } | { + tag: "compactU256"; + value: undefined; + } | { + tag: "void"; + value: undefined; + } | { + tag: "perId"; + value: number; + }; + signedExtensions: { + identifier: string; + includedInExtrinsic: { + tag: "bool"; + value: undefined; + } | { + tag: "char"; + value: undefined; + } | { + tag: "str"; + value: undefined; + } | { + tag: "u8"; + value: undefined; + } | { + tag: "u16"; + value: undefined; + } | { + tag: "u32"; + value: undefined; + } | { + tag: "u64"; + value: undefined; + } | { + tag: "u128"; + value: undefined; + } | { + tag: "u256"; + value: undefined; + } | { + tag: "i8"; + value: undefined; + } | { + tag: "i16"; + value: undefined; + } | { + tag: "i32"; + value: undefined; + } | { + tag: "i64"; + value: undefined; + } | { + tag: "i128"; + value: undefined; + } | { + tag: "i256"; + value: undefined; + } | { + tag: "compactU8"; + value: undefined; + } | { + tag: "compactU16"; + value: undefined; + } | { + tag: "compactU32"; + value: undefined; + } | { + tag: "compactU64"; + value: undefined; + } | { + tag: "compactU128"; + value: undefined; + } | { + tag: "compactU256"; + value: undefined; + } | { + tag: "void"; + value: undefined; + } | { + tag: "perId"; + value: number; + }; + includedInSignedData: { + tag: "bool"; + value: undefined; + } | { + tag: "char"; + value: undefined; + } | { + tag: "str"; + value: undefined; + } | { + tag: "u8"; + value: undefined; + } | { + tag: "u16"; + value: undefined; + } | { + tag: "u32"; + value: undefined; + } | { + tag: "u64"; + value: undefined; + } | { + tag: "u128"; + value: undefined; + } | { + tag: "u256"; + value: undefined; + } | { + tag: "i8"; + value: undefined; + } | { + tag: "i16"; + value: undefined; + } | { + tag: "i32"; + value: undefined; + } | { + tag: "i64"; + value: undefined; + } | { + tag: "i128"; + value: undefined; + } | { + tag: "i256"; + value: undefined; + } | { + tag: "compactU8"; + value: undefined; + } | { + tag: "compactU16"; + value: undefined; + } | { + tag: "compactU32"; + value: undefined; + } | { + tag: "compactU64"; + value: undefined; + } | { + tag: "compactU128"; + value: undefined; + } | { + tag: "compactU256"; + value: undefined; + } | { + tag: "void"; + value: undefined; + } | { + tag: "perId"; + value: number; + }; + }[]; + }>, _pezkuwi_bizinikiwi_bindings.Decoder<{ + version: number; + addressTy: { + tag: "bool"; + value: undefined; + } | { + tag: "char"; + value: undefined; + } | { + tag: "str"; + value: undefined; + } | { + tag: "u8"; + value: undefined; + } | { + tag: "u16"; + value: undefined; + } | { + tag: "u32"; + value: undefined; + } | { + tag: "u64"; + value: undefined; + } | { + tag: "u128"; + value: undefined; + } | { + tag: "u256"; + value: undefined; + } | { + tag: "i8"; + value: undefined; + } | { + tag: "i16"; + value: undefined; + } | { + tag: "i32"; + value: undefined; + } | { + tag: "i64"; + value: undefined; + } | { + tag: "i128"; + value: undefined; + } | { + tag: "i256"; + value: undefined; + } | { + tag: "compactU8"; + value: undefined; + } | { + tag: "compactU16"; + value: undefined; + } | { + tag: "compactU32"; + value: undefined; + } | { + tag: "compactU64"; + value: undefined; + } | { + tag: "compactU128"; + value: undefined; + } | { + tag: "compactU256"; + value: undefined; + } | { + tag: "void"; + value: undefined; + } | { + tag: "perId"; + value: number; + }; + callTy: { + tag: "bool"; + value: undefined; + } | { + tag: "char"; + value: undefined; + } | { + tag: "str"; + value: undefined; + } | { + tag: "u8"; + value: undefined; + } | { + tag: "u16"; + value: undefined; + } | { + tag: "u32"; + value: undefined; + } | { + tag: "u64"; + value: undefined; + } | { + tag: "u128"; + value: undefined; + } | { + tag: "u256"; + value: undefined; + } | { + tag: "i8"; + value: undefined; + } | { + tag: "i16"; + value: undefined; + } | { + tag: "i32"; + value: undefined; + } | { + tag: "i64"; + value: undefined; + } | { + tag: "i128"; + value: undefined; + } | { + tag: "i256"; + value: undefined; + } | { + tag: "compactU8"; + value: undefined; + } | { + tag: "compactU16"; + value: undefined; + } | { + tag: "compactU32"; + value: undefined; + } | { + tag: "compactU64"; + value: undefined; + } | { + tag: "compactU128"; + value: undefined; + } | { + tag: "compactU256"; + value: undefined; + } | { + tag: "void"; + value: undefined; + } | { + tag: "perId"; + value: number; + }; + signatureTy: { + tag: "bool"; + value: undefined; + } | { + tag: "char"; + value: undefined; + } | { + tag: "str"; + value: undefined; + } | { + tag: "u8"; + value: undefined; + } | { + tag: "u16"; + value: undefined; + } | { + tag: "u32"; + value: undefined; + } | { + tag: "u64"; + value: undefined; + } | { + tag: "u128"; + value: undefined; + } | { + tag: "u256"; + value: undefined; + } | { + tag: "i8"; + value: undefined; + } | { + tag: "i16"; + value: undefined; + } | { + tag: "i32"; + value: undefined; + } | { + tag: "i64"; + value: undefined; + } | { + tag: "i128"; + value: undefined; + } | { + tag: "i256"; + value: undefined; + } | { + tag: "compactU8"; + value: undefined; + } | { + tag: "compactU16"; + value: undefined; + } | { + tag: "compactU32"; + value: undefined; + } | { + tag: "compactU64"; + value: undefined; + } | { + tag: "compactU128"; + value: undefined; + } | { + tag: "compactU256"; + value: undefined; + } | { + tag: "void"; + value: undefined; + } | { + tag: "perId"; + value: number; + }; + signedExtensions: { + identifier: string; + includedInExtrinsic: { + tag: "bool"; + value: undefined; + } | { + tag: "char"; + value: undefined; + } | { + tag: "str"; + value: undefined; + } | { + tag: "u8"; + value: undefined; + } | { + tag: "u16"; + value: undefined; + } | { + tag: "u32"; + value: undefined; + } | { + tag: "u64"; + value: undefined; + } | { + tag: "u128"; + value: undefined; + } | { + tag: "u256"; + value: undefined; + } | { + tag: "i8"; + value: undefined; + } | { + tag: "i16"; + value: undefined; + } | { + tag: "i32"; + value: undefined; + } | { + tag: "i64"; + value: undefined; + } | { + tag: "i128"; + value: undefined; + } | { + tag: "i256"; + value: undefined; + } | { + tag: "compactU8"; + value: undefined; + } | { + tag: "compactU16"; + value: undefined; + } | { + tag: "compactU32"; + value: undefined; + } | { + tag: "compactU64"; + value: undefined; + } | { + tag: "compactU128"; + value: undefined; + } | { + tag: "compactU256"; + value: undefined; + } | { + tag: "void"; + value: undefined; + } | { + tag: "perId"; + value: number; + }; + includedInSignedData: { + tag: "bool"; + value: undefined; + } | { + tag: "char"; + value: undefined; + } | { + tag: "str"; + value: undefined; + } | { + tag: "u8"; + value: undefined; + } | { + tag: "u16"; + value: undefined; + } | { + tag: "u32"; + value: undefined; + } | { + tag: "u64"; + value: undefined; + } | { + tag: "u128"; + value: undefined; + } | { + tag: "u256"; + value: undefined; + } | { + tag: "i8"; + value: undefined; + } | { + tag: "i16"; + value: undefined; + } | { + tag: "i32"; + value: undefined; + } | { + tag: "i64"; + value: undefined; + } | { + tag: "i128"; + value: undefined; + } | { + tag: "i256"; + value: undefined; + } | { + tag: "compactU8"; + value: undefined; + } | { + tag: "compactU16"; + value: undefined; + } | { + tag: "compactU32"; + value: undefined; + } | { + tag: "compactU64"; + value: undefined; + } | { + tag: "compactU128"; + value: undefined; + } | { + tag: "compactU256"; + value: undefined; + } | { + tag: "void"; + value: undefined; + } | { + tag: "perId"; + value: number; + }; + }[]; + }>] & { + enc: _pezkuwi_bizinikiwi_bindings.Encoder<{ + version: number; + addressTy: { + tag: "bool"; + value: undefined; + } | { + tag: "char"; + value: undefined; + } | { + tag: "str"; + value: undefined; + } | { + tag: "u8"; + value: undefined; + } | { + tag: "u16"; + value: undefined; + } | { + tag: "u32"; + value: undefined; + } | { + tag: "u64"; + value: undefined; + } | { + tag: "u128"; + value: undefined; + } | { + tag: "u256"; + value: undefined; + } | { + tag: "i8"; + value: undefined; + } | { + tag: "i16"; + value: undefined; + } | { + tag: "i32"; + value: undefined; + } | { + tag: "i64"; + value: undefined; + } | { + tag: "i128"; + value: undefined; + } | { + tag: "i256"; + value: undefined; + } | { + tag: "compactU8"; + value: undefined; + } | { + tag: "compactU16"; + value: undefined; + } | { + tag: "compactU32"; + value: undefined; + } | { + tag: "compactU64"; + value: undefined; + } | { + tag: "compactU128"; + value: undefined; + } | { + tag: "compactU256"; + value: undefined; + } | { + tag: "void"; + value: undefined; + } | { + tag: "perId"; + value: number; + }; + callTy: { + tag: "bool"; + value: undefined; + } | { + tag: "char"; + value: undefined; + } | { + tag: "str"; + value: undefined; + } | { + tag: "u8"; + value: undefined; + } | { + tag: "u16"; + value: undefined; + } | { + tag: "u32"; + value: undefined; + } | { + tag: "u64"; + value: undefined; + } | { + tag: "u128"; + value: undefined; + } | { + tag: "u256"; + value: undefined; + } | { + tag: "i8"; + value: undefined; + } | { + tag: "i16"; + value: undefined; + } | { + tag: "i32"; + value: undefined; + } | { + tag: "i64"; + value: undefined; + } | { + tag: "i128"; + value: undefined; + } | { + tag: "i256"; + value: undefined; + } | { + tag: "compactU8"; + value: undefined; + } | { + tag: "compactU16"; + value: undefined; + } | { + tag: "compactU32"; + value: undefined; + } | { + tag: "compactU64"; + value: undefined; + } | { + tag: "compactU128"; + value: undefined; + } | { + tag: "compactU256"; + value: undefined; + } | { + tag: "void"; + value: undefined; + } | { + tag: "perId"; + value: number; + }; + signatureTy: { + tag: "bool"; + value: undefined; + } | { + tag: "char"; + value: undefined; + } | { + tag: "str"; + value: undefined; + } | { + tag: "u8"; + value: undefined; + } | { + tag: "u16"; + value: undefined; + } | { + tag: "u32"; + value: undefined; + } | { + tag: "u64"; + value: undefined; + } | { + tag: "u128"; + value: undefined; + } | { + tag: "u256"; + value: undefined; + } | { + tag: "i8"; + value: undefined; + } | { + tag: "i16"; + value: undefined; + } | { + tag: "i32"; + value: undefined; + } | { + tag: "i64"; + value: undefined; + } | { + tag: "i128"; + value: undefined; + } | { + tag: "i256"; + value: undefined; + } | { + tag: "compactU8"; + value: undefined; + } | { + tag: "compactU16"; + value: undefined; + } | { + tag: "compactU32"; + value: undefined; + } | { + tag: "compactU64"; + value: undefined; + } | { + tag: "compactU128"; + value: undefined; + } | { + tag: "compactU256"; + value: undefined; + } | { + tag: "void"; + value: undefined; + } | { + tag: "perId"; + value: number; + }; + signedExtensions: { + identifier: string; + includedInExtrinsic: { + tag: "bool"; + value: undefined; + } | { + tag: "char"; + value: undefined; + } | { + tag: "str"; + value: undefined; + } | { + tag: "u8"; + value: undefined; + } | { + tag: "u16"; + value: undefined; + } | { + tag: "u32"; + value: undefined; + } | { + tag: "u64"; + value: undefined; + } | { + tag: "u128"; + value: undefined; + } | { + tag: "u256"; + value: undefined; + } | { + tag: "i8"; + value: undefined; + } | { + tag: "i16"; + value: undefined; + } | { + tag: "i32"; + value: undefined; + } | { + tag: "i64"; + value: undefined; + } | { + tag: "i128"; + value: undefined; + } | { + tag: "i256"; + value: undefined; + } | { + tag: "compactU8"; + value: undefined; + } | { + tag: "compactU16"; + value: undefined; + } | { + tag: "compactU32"; + value: undefined; + } | { + tag: "compactU64"; + value: undefined; + } | { + tag: "compactU128"; + value: undefined; + } | { + tag: "compactU256"; + value: undefined; + } | { + tag: "void"; + value: undefined; + } | { + tag: "perId"; + value: number; + }; + includedInSignedData: { + tag: "bool"; + value: undefined; + } | { + tag: "char"; + value: undefined; + } | { + tag: "str"; + value: undefined; + } | { + tag: "u8"; + value: undefined; + } | { + tag: "u16"; + value: undefined; + } | { + tag: "u32"; + value: undefined; + } | { + tag: "u64"; + value: undefined; + } | { + tag: "u128"; + value: undefined; + } | { + tag: "u256"; + value: undefined; + } | { + tag: "i8"; + value: undefined; + } | { + tag: "i16"; + value: undefined; + } | { + tag: "i32"; + value: undefined; + } | { + tag: "i64"; + value: undefined; + } | { + tag: "i128"; + value: undefined; + } | { + tag: "i256"; + value: undefined; + } | { + tag: "compactU8"; + value: undefined; + } | { + tag: "compactU16"; + value: undefined; + } | { + tag: "compactU32"; + value: undefined; + } | { + tag: "compactU64"; + value: undefined; + } | { + tag: "compactU128"; + value: undefined; + } | { + tag: "compactU256"; + value: undefined; + } | { + tag: "void"; + value: undefined; + } | { + tag: "perId"; + value: number; + }; + }[]; + }>; + dec: _pezkuwi_bizinikiwi_bindings.Decoder<{ + version: number; + addressTy: { + tag: "bool"; + value: undefined; + } | { + tag: "char"; + value: undefined; + } | { + tag: "str"; + value: undefined; + } | { + tag: "u8"; + value: undefined; + } | { + tag: "u16"; + value: undefined; + } | { + tag: "u32"; + value: undefined; + } | { + tag: "u64"; + value: undefined; + } | { + tag: "u128"; + value: undefined; + } | { + tag: "u256"; + value: undefined; + } | { + tag: "i8"; + value: undefined; + } | { + tag: "i16"; + value: undefined; + } | { + tag: "i32"; + value: undefined; + } | { + tag: "i64"; + value: undefined; + } | { + tag: "i128"; + value: undefined; + } | { + tag: "i256"; + value: undefined; + } | { + tag: "compactU8"; + value: undefined; + } | { + tag: "compactU16"; + value: undefined; + } | { + tag: "compactU32"; + value: undefined; + } | { + tag: "compactU64"; + value: undefined; + } | { + tag: "compactU128"; + value: undefined; + } | { + tag: "compactU256"; + value: undefined; + } | { + tag: "void"; + value: undefined; + } | { + tag: "perId"; + value: number; + }; + callTy: { + tag: "bool"; + value: undefined; + } | { + tag: "char"; + value: undefined; + } | { + tag: "str"; + value: undefined; + } | { + tag: "u8"; + value: undefined; + } | { + tag: "u16"; + value: undefined; + } | { + tag: "u32"; + value: undefined; + } | { + tag: "u64"; + value: undefined; + } | { + tag: "u128"; + value: undefined; + } | { + tag: "u256"; + value: undefined; + } | { + tag: "i8"; + value: undefined; + } | { + tag: "i16"; + value: undefined; + } | { + tag: "i32"; + value: undefined; + } | { + tag: "i64"; + value: undefined; + } | { + tag: "i128"; + value: undefined; + } | { + tag: "i256"; + value: undefined; + } | { + tag: "compactU8"; + value: undefined; + } | { + tag: "compactU16"; + value: undefined; + } | { + tag: "compactU32"; + value: undefined; + } | { + tag: "compactU64"; + value: undefined; + } | { + tag: "compactU128"; + value: undefined; + } | { + tag: "compactU256"; + value: undefined; + } | { + tag: "void"; + value: undefined; + } | { + tag: "perId"; + value: number; + }; + signatureTy: { + tag: "bool"; + value: undefined; + } | { + tag: "char"; + value: undefined; + } | { + tag: "str"; + value: undefined; + } | { + tag: "u8"; + value: undefined; + } | { + tag: "u16"; + value: undefined; + } | { + tag: "u32"; + value: undefined; + } | { + tag: "u64"; + value: undefined; + } | { + tag: "u128"; + value: undefined; + } | { + tag: "u256"; + value: undefined; + } | { + tag: "i8"; + value: undefined; + } | { + tag: "i16"; + value: undefined; + } | { + tag: "i32"; + value: undefined; + } | { + tag: "i64"; + value: undefined; + } | { + tag: "i128"; + value: undefined; + } | { + tag: "i256"; + value: undefined; + } | { + tag: "compactU8"; + value: undefined; + } | { + tag: "compactU16"; + value: undefined; + } | { + tag: "compactU32"; + value: undefined; + } | { + tag: "compactU64"; + value: undefined; + } | { + tag: "compactU128"; + value: undefined; + } | { + tag: "compactU256"; + value: undefined; + } | { + tag: "void"; + value: undefined; + } | { + tag: "perId"; + value: number; + }; + signedExtensions: { + identifier: string; + includedInExtrinsic: { + tag: "bool"; + value: undefined; + } | { + tag: "char"; + value: undefined; + } | { + tag: "str"; + value: undefined; + } | { + tag: "u8"; + value: undefined; + } | { + tag: "u16"; + value: undefined; + } | { + tag: "u32"; + value: undefined; + } | { + tag: "u64"; + value: undefined; + } | { + tag: "u128"; + value: undefined; + } | { + tag: "u256"; + value: undefined; + } | { + tag: "i8"; + value: undefined; + } | { + tag: "i16"; + value: undefined; + } | { + tag: "i32"; + value: undefined; + } | { + tag: "i64"; + value: undefined; + } | { + tag: "i128"; + value: undefined; + } | { + tag: "i256"; + value: undefined; + } | { + tag: "compactU8"; + value: undefined; + } | { + tag: "compactU16"; + value: undefined; + } | { + tag: "compactU32"; + value: undefined; + } | { + tag: "compactU64"; + value: undefined; + } | { + tag: "compactU128"; + value: undefined; + } | { + tag: "compactU256"; + value: undefined; + } | { + tag: "void"; + value: undefined; + } | { + tag: "perId"; + value: number; + }; + includedInSignedData: { + tag: "bool"; + value: undefined; + } | { + tag: "char"; + value: undefined; + } | { + tag: "str"; + value: undefined; + } | { + tag: "u8"; + value: undefined; + } | { + tag: "u16"; + value: undefined; + } | { + tag: "u32"; + value: undefined; + } | { + tag: "u64"; + value: undefined; + } | { + tag: "u128"; + value: undefined; + } | { + tag: "u256"; + value: undefined; + } | { + tag: "i8"; + value: undefined; + } | { + tag: "i16"; + value: undefined; + } | { + tag: "i32"; + value: undefined; + } | { + tag: "i64"; + value: undefined; + } | { + tag: "i128"; + value: undefined; + } | { + tag: "i256"; + value: undefined; + } | { + tag: "compactU8"; + value: undefined; + } | { + tag: "compactU16"; + value: undefined; + } | { + tag: "compactU32"; + value: undefined; + } | { + tag: "compactU64"; + value: undefined; + } | { + tag: "compactU128"; + value: undefined; + } | { + tag: "compactU256"; + value: undefined; + } | { + tag: "void"; + value: undefined; + } | { + tag: "perId"; + value: number; + }; + }[]; + }>; + } & { + inner: { + version: Codec; + addressTy: [_pezkuwi_bizinikiwi_bindings.Encoder<{ + tag: "bool"; + value: undefined; + } | { + tag: "char"; + value: undefined; + } | { + tag: "str"; + value: undefined; + } | { + tag: "u8"; + value: undefined; + } | { + tag: "u16"; + value: undefined; + } | { + tag: "u32"; + value: undefined; + } | { + tag: "u64"; + value: undefined; + } | { + tag: "u128"; + value: undefined; + } | { + tag: "u256"; + value: undefined; + } | { + tag: "i8"; + value: undefined; + } | { + tag: "i16"; + value: undefined; + } | { + tag: "i32"; + value: undefined; + } | { + tag: "i64"; + value: undefined; + } | { + tag: "i128"; + value: undefined; + } | { + tag: "i256"; + value: undefined; + } | { + tag: "compactU8"; + value: undefined; + } | { + tag: "compactU16"; + value: undefined; + } | { + tag: "compactU32"; + value: undefined; + } | { + tag: "compactU64"; + value: undefined; + } | { + tag: "compactU128"; + value: undefined; + } | { + tag: "compactU256"; + value: undefined; + } | { + tag: "void"; + value: undefined; + } | { + tag: "perId"; + value: number; + }>, _pezkuwi_bizinikiwi_bindings.Decoder<{ + tag: "bool"; + value: undefined; + } | { + tag: "char"; + value: undefined; + } | { + tag: "str"; + value: undefined; + } | { + tag: "u8"; + value: undefined; + } | { + tag: "u16"; + value: undefined; + } | { + tag: "u32"; + value: undefined; + } | { + tag: "u64"; + value: undefined; + } | { + tag: "u128"; + value: undefined; + } | { + tag: "u256"; + value: undefined; + } | { + tag: "i8"; + value: undefined; + } | { + tag: "i16"; + value: undefined; + } | { + tag: "i32"; + value: undefined; + } | { + tag: "i64"; + value: undefined; + } | { + tag: "i128"; + value: undefined; + } | { + tag: "i256"; + value: undefined; + } | { + tag: "compactU8"; + value: undefined; + } | { + tag: "compactU16"; + value: undefined; + } | { + tag: "compactU32"; + value: undefined; + } | { + tag: "compactU64"; + value: undefined; + } | { + tag: "compactU128"; + value: undefined; + } | { + tag: "compactU256"; + value: undefined; + } | { + tag: "void"; + value: undefined; + } | { + tag: "perId"; + value: number; + }>] & { + enc: _pezkuwi_bizinikiwi_bindings.Encoder<{ + tag: "bool"; + value: undefined; + } | { + tag: "char"; + value: undefined; + } | { + tag: "str"; + value: undefined; + } | { + tag: "u8"; + value: undefined; + } | { + tag: "u16"; + value: undefined; + } | { + tag: "u32"; + value: undefined; + } | { + tag: "u64"; + value: undefined; + } | { + tag: "u128"; + value: undefined; + } | { + tag: "u256"; + value: undefined; + } | { + tag: "i8"; + value: undefined; + } | { + tag: "i16"; + value: undefined; + } | { + tag: "i32"; + value: undefined; + } | { + tag: "i64"; + value: undefined; + } | { + tag: "i128"; + value: undefined; + } | { + tag: "i256"; + value: undefined; + } | { + tag: "compactU8"; + value: undefined; + } | { + tag: "compactU16"; + value: undefined; + } | { + tag: "compactU32"; + value: undefined; + } | { + tag: "compactU64"; + value: undefined; + } | { + tag: "compactU128"; + value: undefined; + } | { + tag: "compactU256"; + value: undefined; + } | { + tag: "void"; + value: undefined; + } | { + tag: "perId"; + value: number; + }>; + dec: _pezkuwi_bizinikiwi_bindings.Decoder<{ + tag: "bool"; + value: undefined; + } | { + tag: "char"; + value: undefined; + } | { + tag: "str"; + value: undefined; + } | { + tag: "u8"; + value: undefined; + } | { + tag: "u16"; + value: undefined; + } | { + tag: "u32"; + value: undefined; + } | { + tag: "u64"; + value: undefined; + } | { + tag: "u128"; + value: undefined; + } | { + tag: "u256"; + value: undefined; + } | { + tag: "i8"; + value: undefined; + } | { + tag: "i16"; + value: undefined; + } | { + tag: "i32"; + value: undefined; + } | { + tag: "i64"; + value: undefined; + } | { + tag: "i128"; + value: undefined; + } | { + tag: "i256"; + value: undefined; + } | { + tag: "compactU8"; + value: undefined; + } | { + tag: "compactU16"; + value: undefined; + } | { + tag: "compactU32"; + value: undefined; + } | { + tag: "compactU64"; + value: undefined; + } | { + tag: "compactU128"; + value: undefined; + } | { + tag: "compactU256"; + value: undefined; + } | { + tag: "void"; + value: undefined; + } | { + tag: "perId"; + value: number; + }>; + } & { + inner: { + bool: Codec; + char: Codec; + str: Codec; + u8: Codec; + u16: Codec; + u32: Codec; + u64: Codec; + u128: Codec; + u256: Codec; + i8: Codec; + i16: Codec; + i32: Codec; + i64: Codec; + i128: Codec; + i256: Codec; + compactU8: Codec; + compactU16: Codec; + compactU32: Codec; + compactU64: Codec; + compactU128: Codec; + compactU256: Codec; + void: Codec; + perId: Codec; + }; + }; + callTy: [_pezkuwi_bizinikiwi_bindings.Encoder<{ + tag: "bool"; + value: undefined; + } | { + tag: "char"; + value: undefined; + } | { + tag: "str"; + value: undefined; + } | { + tag: "u8"; + value: undefined; + } | { + tag: "u16"; + value: undefined; + } | { + tag: "u32"; + value: undefined; + } | { + tag: "u64"; + value: undefined; + } | { + tag: "u128"; + value: undefined; + } | { + tag: "u256"; + value: undefined; + } | { + tag: "i8"; + value: undefined; + } | { + tag: "i16"; + value: undefined; + } | { + tag: "i32"; + value: undefined; + } | { + tag: "i64"; + value: undefined; + } | { + tag: "i128"; + value: undefined; + } | { + tag: "i256"; + value: undefined; + } | { + tag: "compactU8"; + value: undefined; + } | { + tag: "compactU16"; + value: undefined; + } | { + tag: "compactU32"; + value: undefined; + } | { + tag: "compactU64"; + value: undefined; + } | { + tag: "compactU128"; + value: undefined; + } | { + tag: "compactU256"; + value: undefined; + } | { + tag: "void"; + value: undefined; + } | { + tag: "perId"; + value: number; + }>, _pezkuwi_bizinikiwi_bindings.Decoder<{ + tag: "bool"; + value: undefined; + } | { + tag: "char"; + value: undefined; + } | { + tag: "str"; + value: undefined; + } | { + tag: "u8"; + value: undefined; + } | { + tag: "u16"; + value: undefined; + } | { + tag: "u32"; + value: undefined; + } | { + tag: "u64"; + value: undefined; + } | { + tag: "u128"; + value: undefined; + } | { + tag: "u256"; + value: undefined; + } | { + tag: "i8"; + value: undefined; + } | { + tag: "i16"; + value: undefined; + } | { + tag: "i32"; + value: undefined; + } | { + tag: "i64"; + value: undefined; + } | { + tag: "i128"; + value: undefined; + } | { + tag: "i256"; + value: undefined; + } | { + tag: "compactU8"; + value: undefined; + } | { + tag: "compactU16"; + value: undefined; + } | { + tag: "compactU32"; + value: undefined; + } | { + tag: "compactU64"; + value: undefined; + } | { + tag: "compactU128"; + value: undefined; + } | { + tag: "compactU256"; + value: undefined; + } | { + tag: "void"; + value: undefined; + } | { + tag: "perId"; + value: number; + }>] & { + enc: _pezkuwi_bizinikiwi_bindings.Encoder<{ + tag: "bool"; + value: undefined; + } | { + tag: "char"; + value: undefined; + } | { + tag: "str"; + value: undefined; + } | { + tag: "u8"; + value: undefined; + } | { + tag: "u16"; + value: undefined; + } | { + tag: "u32"; + value: undefined; + } | { + tag: "u64"; + value: undefined; + } | { + tag: "u128"; + value: undefined; + } | { + tag: "u256"; + value: undefined; + } | { + tag: "i8"; + value: undefined; + } | { + tag: "i16"; + value: undefined; + } | { + tag: "i32"; + value: undefined; + } | { + tag: "i64"; + value: undefined; + } | { + tag: "i128"; + value: undefined; + } | { + tag: "i256"; + value: undefined; + } | { + tag: "compactU8"; + value: undefined; + } | { + tag: "compactU16"; + value: undefined; + } | { + tag: "compactU32"; + value: undefined; + } | { + tag: "compactU64"; + value: undefined; + } | { + tag: "compactU128"; + value: undefined; + } | { + tag: "compactU256"; + value: undefined; + } | { + tag: "void"; + value: undefined; + } | { + tag: "perId"; + value: number; + }>; + dec: _pezkuwi_bizinikiwi_bindings.Decoder<{ + tag: "bool"; + value: undefined; + } | { + tag: "char"; + value: undefined; + } | { + tag: "str"; + value: undefined; + } | { + tag: "u8"; + value: undefined; + } | { + tag: "u16"; + value: undefined; + } | { + tag: "u32"; + value: undefined; + } | { + tag: "u64"; + value: undefined; + } | { + tag: "u128"; + value: undefined; + } | { + tag: "u256"; + value: undefined; + } | { + tag: "i8"; + value: undefined; + } | { + tag: "i16"; + value: undefined; + } | { + tag: "i32"; + value: undefined; + } | { + tag: "i64"; + value: undefined; + } | { + tag: "i128"; + value: undefined; + } | { + tag: "i256"; + value: undefined; + } | { + tag: "compactU8"; + value: undefined; + } | { + tag: "compactU16"; + value: undefined; + } | { + tag: "compactU32"; + value: undefined; + } | { + tag: "compactU64"; + value: undefined; + } | { + tag: "compactU128"; + value: undefined; + } | { + tag: "compactU256"; + value: undefined; + } | { + tag: "void"; + value: undefined; + } | { + tag: "perId"; + value: number; + }>; + } & { + inner: { + bool: Codec; + char: Codec; + str: Codec; + u8: Codec; + u16: Codec; + u32: Codec; + u64: Codec; + u128: Codec; + u256: Codec; + i8: Codec; + i16: Codec; + i32: Codec; + i64: Codec; + i128: Codec; + i256: Codec; + compactU8: Codec; + compactU16: Codec; + compactU32: Codec; + compactU64: Codec; + compactU128: Codec; + compactU256: Codec; + void: Codec; + perId: Codec; + }; + }; + signatureTy: [_pezkuwi_bizinikiwi_bindings.Encoder<{ + tag: "bool"; + value: undefined; + } | { + tag: "char"; + value: undefined; + } | { + tag: "str"; + value: undefined; + } | { + tag: "u8"; + value: undefined; + } | { + tag: "u16"; + value: undefined; + } | { + tag: "u32"; + value: undefined; + } | { + tag: "u64"; + value: undefined; + } | { + tag: "u128"; + value: undefined; + } | { + tag: "u256"; + value: undefined; + } | { + tag: "i8"; + value: undefined; + } | { + tag: "i16"; + value: undefined; + } | { + tag: "i32"; + value: undefined; + } | { + tag: "i64"; + value: undefined; + } | { + tag: "i128"; + value: undefined; + } | { + tag: "i256"; + value: undefined; + } | { + tag: "compactU8"; + value: undefined; + } | { + tag: "compactU16"; + value: undefined; + } | { + tag: "compactU32"; + value: undefined; + } | { + tag: "compactU64"; + value: undefined; + } | { + tag: "compactU128"; + value: undefined; + } | { + tag: "compactU256"; + value: undefined; + } | { + tag: "void"; + value: undefined; + } | { + tag: "perId"; + value: number; + }>, _pezkuwi_bizinikiwi_bindings.Decoder<{ + tag: "bool"; + value: undefined; + } | { + tag: "char"; + value: undefined; + } | { + tag: "str"; + value: undefined; + } | { + tag: "u8"; + value: undefined; + } | { + tag: "u16"; + value: undefined; + } | { + tag: "u32"; + value: undefined; + } | { + tag: "u64"; + value: undefined; + } | { + tag: "u128"; + value: undefined; + } | { + tag: "u256"; + value: undefined; + } | { + tag: "i8"; + value: undefined; + } | { + tag: "i16"; + value: undefined; + } | { + tag: "i32"; + value: undefined; + } | { + tag: "i64"; + value: undefined; + } | { + tag: "i128"; + value: undefined; + } | { + tag: "i256"; + value: undefined; + } | { + tag: "compactU8"; + value: undefined; + } | { + tag: "compactU16"; + value: undefined; + } | { + tag: "compactU32"; + value: undefined; + } | { + tag: "compactU64"; + value: undefined; + } | { + tag: "compactU128"; + value: undefined; + } | { + tag: "compactU256"; + value: undefined; + } | { + tag: "void"; + value: undefined; + } | { + tag: "perId"; + value: number; + }>] & { + enc: _pezkuwi_bizinikiwi_bindings.Encoder<{ + tag: "bool"; + value: undefined; + } | { + tag: "char"; + value: undefined; + } | { + tag: "str"; + value: undefined; + } | { + tag: "u8"; + value: undefined; + } | { + tag: "u16"; + value: undefined; + } | { + tag: "u32"; + value: undefined; + } | { + tag: "u64"; + value: undefined; + } | { + tag: "u128"; + value: undefined; + } | { + tag: "u256"; + value: undefined; + } | { + tag: "i8"; + value: undefined; + } | { + tag: "i16"; + value: undefined; + } | { + tag: "i32"; + value: undefined; + } | { + tag: "i64"; + value: undefined; + } | { + tag: "i128"; + value: undefined; + } | { + tag: "i256"; + value: undefined; + } | { + tag: "compactU8"; + value: undefined; + } | { + tag: "compactU16"; + value: undefined; + } | { + tag: "compactU32"; + value: undefined; + } | { + tag: "compactU64"; + value: undefined; + } | { + tag: "compactU128"; + value: undefined; + } | { + tag: "compactU256"; + value: undefined; + } | { + tag: "void"; + value: undefined; + } | { + tag: "perId"; + value: number; + }>; + dec: _pezkuwi_bizinikiwi_bindings.Decoder<{ + tag: "bool"; + value: undefined; + } | { + tag: "char"; + value: undefined; + } | { + tag: "str"; + value: undefined; + } | { + tag: "u8"; + value: undefined; + } | { + tag: "u16"; + value: undefined; + } | { + tag: "u32"; + value: undefined; + } | { + tag: "u64"; + value: undefined; + } | { + tag: "u128"; + value: undefined; + } | { + tag: "u256"; + value: undefined; + } | { + tag: "i8"; + value: undefined; + } | { + tag: "i16"; + value: undefined; + } | { + tag: "i32"; + value: undefined; + } | { + tag: "i64"; + value: undefined; + } | { + tag: "i128"; + value: undefined; + } | { + tag: "i256"; + value: undefined; + } | { + tag: "compactU8"; + value: undefined; + } | { + tag: "compactU16"; + value: undefined; + } | { + tag: "compactU32"; + value: undefined; + } | { + tag: "compactU64"; + value: undefined; + } | { + tag: "compactU128"; + value: undefined; + } | { + tag: "compactU256"; + value: undefined; + } | { + tag: "void"; + value: undefined; + } | { + tag: "perId"; + value: number; + }>; + } & { + inner: { + bool: Codec; + char: Codec; + str: Codec; + u8: Codec; + u16: Codec; + u32: Codec; + u64: Codec; + u128: Codec; + u256: Codec; + i8: Codec; + i16: Codec; + i32: Codec; + i64: Codec; + i128: Codec; + i256: Codec; + compactU8: Codec; + compactU16: Codec; + compactU32: Codec; + compactU64: Codec; + compactU128: Codec; + compactU256: Codec; + void: Codec; + perId: Codec; + }; + }; + signedExtensions: [_pezkuwi_bizinikiwi_bindings.Encoder<{ + identifier: string; + includedInExtrinsic: { + tag: "bool"; + value: undefined; + } | { + tag: "char"; + value: undefined; + } | { + tag: "str"; + value: undefined; + } | { + tag: "u8"; + value: undefined; + } | { + tag: "u16"; + value: undefined; + } | { + tag: "u32"; + value: undefined; + } | { + tag: "u64"; + value: undefined; + } | { + tag: "u128"; + value: undefined; + } | { + tag: "u256"; + value: undefined; + } | { + tag: "i8"; + value: undefined; + } | { + tag: "i16"; + value: undefined; + } | { + tag: "i32"; + value: undefined; + } | { + tag: "i64"; + value: undefined; + } | { + tag: "i128"; + value: undefined; + } | { + tag: "i256"; + value: undefined; + } | { + tag: "compactU8"; + value: undefined; + } | { + tag: "compactU16"; + value: undefined; + } | { + tag: "compactU32"; + value: undefined; + } | { + tag: "compactU64"; + value: undefined; + } | { + tag: "compactU128"; + value: undefined; + } | { + tag: "compactU256"; + value: undefined; + } | { + tag: "void"; + value: undefined; + } | { + tag: "perId"; + value: number; + }; + includedInSignedData: { + tag: "bool"; + value: undefined; + } | { + tag: "char"; + value: undefined; + } | { + tag: "str"; + value: undefined; + } | { + tag: "u8"; + value: undefined; + } | { + tag: "u16"; + value: undefined; + } | { + tag: "u32"; + value: undefined; + } | { + tag: "u64"; + value: undefined; + } | { + tag: "u128"; + value: undefined; + } | { + tag: "u256"; + value: undefined; + } | { + tag: "i8"; + value: undefined; + } | { + tag: "i16"; + value: undefined; + } | { + tag: "i32"; + value: undefined; + } | { + tag: "i64"; + value: undefined; + } | { + tag: "i128"; + value: undefined; + } | { + tag: "i256"; + value: undefined; + } | { + tag: "compactU8"; + value: undefined; + } | { + tag: "compactU16"; + value: undefined; + } | { + tag: "compactU32"; + value: undefined; + } | { + tag: "compactU64"; + value: undefined; + } | { + tag: "compactU128"; + value: undefined; + } | { + tag: "compactU256"; + value: undefined; + } | { + tag: "void"; + value: undefined; + } | { + tag: "perId"; + value: number; + }; + }[]>, _pezkuwi_bizinikiwi_bindings.Decoder<{ + identifier: string; + includedInExtrinsic: { + tag: "bool"; + value: undefined; + } | { + tag: "char"; + value: undefined; + } | { + tag: "str"; + value: undefined; + } | { + tag: "u8"; + value: undefined; + } | { + tag: "u16"; + value: undefined; + } | { + tag: "u32"; + value: undefined; + } | { + tag: "u64"; + value: undefined; + } | { + tag: "u128"; + value: undefined; + } | { + tag: "u256"; + value: undefined; + } | { + tag: "i8"; + value: undefined; + } | { + tag: "i16"; + value: undefined; + } | { + tag: "i32"; + value: undefined; + } | { + tag: "i64"; + value: undefined; + } | { + tag: "i128"; + value: undefined; + } | { + tag: "i256"; + value: undefined; + } | { + tag: "compactU8"; + value: undefined; + } | { + tag: "compactU16"; + value: undefined; + } | { + tag: "compactU32"; + value: undefined; + } | { + tag: "compactU64"; + value: undefined; + } | { + tag: "compactU128"; + value: undefined; + } | { + tag: "compactU256"; + value: undefined; + } | { + tag: "void"; + value: undefined; + } | { + tag: "perId"; + value: number; + }; + includedInSignedData: { + tag: "bool"; + value: undefined; + } | { + tag: "char"; + value: undefined; + } | { + tag: "str"; + value: undefined; + } | { + tag: "u8"; + value: undefined; + } | { + tag: "u16"; + value: undefined; + } | { + tag: "u32"; + value: undefined; + } | { + tag: "u64"; + value: undefined; + } | { + tag: "u128"; + value: undefined; + } | { + tag: "u256"; + value: undefined; + } | { + tag: "i8"; + value: undefined; + } | { + tag: "i16"; + value: undefined; + } | { + tag: "i32"; + value: undefined; + } | { + tag: "i64"; + value: undefined; + } | { + tag: "i128"; + value: undefined; + } | { + tag: "i256"; + value: undefined; + } | { + tag: "compactU8"; + value: undefined; + } | { + tag: "compactU16"; + value: undefined; + } | { + tag: "compactU32"; + value: undefined; + } | { + tag: "compactU64"; + value: undefined; + } | { + tag: "compactU128"; + value: undefined; + } | { + tag: "compactU256"; + value: undefined; + } | { + tag: "void"; + value: undefined; + } | { + tag: "perId"; + value: number; + }; + }[]>] & { + enc: _pezkuwi_bizinikiwi_bindings.Encoder<{ + identifier: string; + includedInExtrinsic: { + tag: "bool"; + value: undefined; + } | { + tag: "char"; + value: undefined; + } | { + tag: "str"; + value: undefined; + } | { + tag: "u8"; + value: undefined; + } | { + tag: "u16"; + value: undefined; + } | { + tag: "u32"; + value: undefined; + } | { + tag: "u64"; + value: undefined; + } | { + tag: "u128"; + value: undefined; + } | { + tag: "u256"; + value: undefined; + } | { + tag: "i8"; + value: undefined; + } | { + tag: "i16"; + value: undefined; + } | { + tag: "i32"; + value: undefined; + } | { + tag: "i64"; + value: undefined; + } | { + tag: "i128"; + value: undefined; + } | { + tag: "i256"; + value: undefined; + } | { + tag: "compactU8"; + value: undefined; + } | { + tag: "compactU16"; + value: undefined; + } | { + tag: "compactU32"; + value: undefined; + } | { + tag: "compactU64"; + value: undefined; + } | { + tag: "compactU128"; + value: undefined; + } | { + tag: "compactU256"; + value: undefined; + } | { + tag: "void"; + value: undefined; + } | { + tag: "perId"; + value: number; + }; + includedInSignedData: { + tag: "bool"; + value: undefined; + } | { + tag: "char"; + value: undefined; + } | { + tag: "str"; + value: undefined; + } | { + tag: "u8"; + value: undefined; + } | { + tag: "u16"; + value: undefined; + } | { + tag: "u32"; + value: undefined; + } | { + tag: "u64"; + value: undefined; + } | { + tag: "u128"; + value: undefined; + } | { + tag: "u256"; + value: undefined; + } | { + tag: "i8"; + value: undefined; + } | { + tag: "i16"; + value: undefined; + } | { + tag: "i32"; + value: undefined; + } | { + tag: "i64"; + value: undefined; + } | { + tag: "i128"; + value: undefined; + } | { + tag: "i256"; + value: undefined; + } | { + tag: "compactU8"; + value: undefined; + } | { + tag: "compactU16"; + value: undefined; + } | { + tag: "compactU32"; + value: undefined; + } | { + tag: "compactU64"; + value: undefined; + } | { + tag: "compactU128"; + value: undefined; + } | { + tag: "compactU256"; + value: undefined; + } | { + tag: "void"; + value: undefined; + } | { + tag: "perId"; + value: number; + }; + }[]>; + dec: _pezkuwi_bizinikiwi_bindings.Decoder<{ + identifier: string; + includedInExtrinsic: { + tag: "bool"; + value: undefined; + } | { + tag: "char"; + value: undefined; + } | { + tag: "str"; + value: undefined; + } | { + tag: "u8"; + value: undefined; + } | { + tag: "u16"; + value: undefined; + } | { + tag: "u32"; + value: undefined; + } | { + tag: "u64"; + value: undefined; + } | { + tag: "u128"; + value: undefined; + } | { + tag: "u256"; + value: undefined; + } | { + tag: "i8"; + value: undefined; + } | { + tag: "i16"; + value: undefined; + } | { + tag: "i32"; + value: undefined; + } | { + tag: "i64"; + value: undefined; + } | { + tag: "i128"; + value: undefined; + } | { + tag: "i256"; + value: undefined; + } | { + tag: "compactU8"; + value: undefined; + } | { + tag: "compactU16"; + value: undefined; + } | { + tag: "compactU32"; + value: undefined; + } | { + tag: "compactU64"; + value: undefined; + } | { + tag: "compactU128"; + value: undefined; + } | { + tag: "compactU256"; + value: undefined; + } | { + tag: "void"; + value: undefined; + } | { + tag: "perId"; + value: number; + }; + includedInSignedData: { + tag: "bool"; + value: undefined; + } | { + tag: "char"; + value: undefined; + } | { + tag: "str"; + value: undefined; + } | { + tag: "u8"; + value: undefined; + } | { + tag: "u16"; + value: undefined; + } | { + tag: "u32"; + value: undefined; + } | { + tag: "u64"; + value: undefined; + } | { + tag: "u128"; + value: undefined; + } | { + tag: "u256"; + value: undefined; + } | { + tag: "i8"; + value: undefined; + } | { + tag: "i16"; + value: undefined; + } | { + tag: "i32"; + value: undefined; + } | { + tag: "i64"; + value: undefined; + } | { + tag: "i128"; + value: undefined; + } | { + tag: "i256"; + value: undefined; + } | { + tag: "compactU8"; + value: undefined; + } | { + tag: "compactU16"; + value: undefined; + } | { + tag: "compactU32"; + value: undefined; + } | { + tag: "compactU64"; + value: undefined; + } | { + tag: "compactU128"; + value: undefined; + } | { + tag: "compactU256"; + value: undefined; + } | { + tag: "void"; + value: undefined; + } | { + tag: "perId"; + value: number; + }; + }[]>; + } & { + inner: Codec<{ + identifier: string; + includedInExtrinsic: { + tag: "bool"; + value: undefined; + } | { + tag: "char"; + value: undefined; + } | { + tag: "str"; + value: undefined; + } | { + tag: "u8"; + value: undefined; + } | { + tag: "u16"; + value: undefined; + } | { + tag: "u32"; + value: undefined; + } | { + tag: "u64"; + value: undefined; + } | { + tag: "u128"; + value: undefined; + } | { + tag: "u256"; + value: undefined; + } | { + tag: "i8"; + value: undefined; + } | { + tag: "i16"; + value: undefined; + } | { + tag: "i32"; + value: undefined; + } | { + tag: "i64"; + value: undefined; + } | { + tag: "i128"; + value: undefined; + } | { + tag: "i256"; + value: undefined; + } | { + tag: "compactU8"; + value: undefined; + } | { + tag: "compactU16"; + value: undefined; + } | { + tag: "compactU32"; + value: undefined; + } | { + tag: "compactU64"; + value: undefined; + } | { + tag: "compactU128"; + value: undefined; + } | { + tag: "compactU256"; + value: undefined; + } | { + tag: "void"; + value: undefined; + } | { + tag: "perId"; + value: number; + }; + includedInSignedData: { + tag: "bool"; + value: undefined; + } | { + tag: "char"; + value: undefined; + } | { + tag: "str"; + value: undefined; + } | { + tag: "u8"; + value: undefined; + } | { + tag: "u16"; + value: undefined; + } | { + tag: "u32"; + value: undefined; + } | { + tag: "u64"; + value: undefined; + } | { + tag: "u128"; + value: undefined; + } | { + tag: "u256"; + value: undefined; + } | { + tag: "i8"; + value: undefined; + } | { + tag: "i16"; + value: undefined; + } | { + tag: "i32"; + value: undefined; + } | { + tag: "i64"; + value: undefined; + } | { + tag: "i128"; + value: undefined; + } | { + tag: "i256"; + value: undefined; + } | { + tag: "compactU8"; + value: undefined; + } | { + tag: "compactU16"; + value: undefined; + } | { + tag: "compactU32"; + value: undefined; + } | { + tag: "compactU64"; + value: undefined; + } | { + tag: "compactU128"; + value: undefined; + } | { + tag: "compactU256"; + value: undefined; + } | { + tag: "void"; + value: undefined; + } | { + tag: "perId"; + value: number; + }; + }>; + }; + }; + }; + info: [_pezkuwi_bizinikiwi_bindings.Encoder<{ + specVersion: number; + specName: string; + base58Prefix: number; + decimals: number; + tokenSymbol: string; + }>, _pezkuwi_bizinikiwi_bindings.Decoder<{ + specVersion: number; + specName: string; + base58Prefix: number; + decimals: number; + tokenSymbol: string; + }>] & { + enc: _pezkuwi_bizinikiwi_bindings.Encoder<{ + specVersion: number; + specName: string; + base58Prefix: number; + decimals: number; + tokenSymbol: string; + }>; + dec: _pezkuwi_bizinikiwi_bindings.Decoder<{ + specVersion: number; + specName: string; + base58Prefix: number; + decimals: number; + tokenSymbol: string; + }>; + } & { + inner: { + specVersion: Codec; + specName: Codec; + base58Prefix: Codec; + decimals: Codec; + tokenSymbol: Codec; + }; + }; + }; +}; +type Proof = CodecType; + +interface MetadataMerkleizer { + /** + * @returns Digest value of the metadata (aka its merkleized root-hash) + */ + digest: () => Uint8Array; + /** + * Get proof for an `Extrinsic`. + * + * @param transaction Encoded `Extrinsic`, both signed or unsigned. + * @param txAdditionalSigned Optionally collect types for given + * `additionalSigned` part of signedExtensions. + * @returns Encoded `Proof` + */ + getProofForExtrinsic: (transaction: Uint8Array | HexString, txAdditionalSigned?: Uint8Array | HexString) => Uint8Array; + /** + * Get proof for `ExtrinsicPayload` parts. + * + * @param callData Call data of the transaction. It has to be + * bare; i.e. + * without prepended compact length. + * @param includedInExtrinsic Extra part of the signed extensions, all of + * them concatenated. + * @param includedInSignedData Additional signed part of the signed + * extensions, all of them concatenated. + * @returns Encoded `Proof` + */ + getProofForExtrinsicParts: (callData: Uint8Array | HexString, includedInExtrinsic: Uint8Array | HexString, includedInSignedData: Uint8Array | HexString) => Uint8Array; + /** + * Get proof for `ExtrinsicPayload`. + * + * @param extrinsicPayload Call data, extra part of signedExtensions and + * additional signed part of signedExtensions + * concatenated. It has to be bare; i.e. without + * prepended compact length. + * @returns Encoded `Proof` + */ + getProofForExtrinsicPayload: (extrinsicPayload: Uint8Array | HexString) => Uint8Array; +} +declare const merkleizeMetadata: (metadataBytes: Uint8Array | HexString, { decimals, tokenSymbol, ...hinted }: { + decimals: number; + tokenSymbol: string; +} & Partial) => MetadataMerkleizer; + +export { extraInfo, extrinsicMetadata, hash, lookup, lookupType, merkleizeMetadata, proof }; +export type { ExtraInfo, ExtrinsicMetadata, Lookup, LookupEntry, MetadataMerkleizer, Proof, TypeRef }; diff --git a/packages/merkleize-metadata/dist/index.js b/packages/merkleize-metadata/dist/index.js new file mode 100644 index 0000000..22a2b26 --- /dev/null +++ b/packages/merkleize-metadata/dist/index.js @@ -0,0 +1,597 @@ +'use strict'; + +var substrateBindings = require('@pezkuwi/bizinikiwi-bindings'); +var utils = require('@pezkuwi/papi-utils'); +var metadataBuilders = require('@pezkuwi/metadata-builders'); + +const extraInfoInner = { + specVersion: substrateBindings.u32, + specName: substrateBindings.str, + base58Prefix: substrateBindings.u16, + decimals: substrateBindings.u8, + tokenSymbol: substrateBindings.str +}; +const extraInfo = substrateBindings.Struct(extraInfoInner); +const hash = substrateBindings.Bytes(32); +const metadataDigest = substrateBindings.ScaleEnum({ + V0: substrateBindings._void, + V1: substrateBindings.Struct({ + typeInformationTreeRoot: hash, + extrinsicMetadataHash: hash, + ...extraInfoInner + }) +}); +substrateBindings.ScaleEnum({ + bool: substrateBindings._void, + char: substrateBindings._void, + str: substrateBindings._void, + u8: substrateBindings._void, + u16: substrateBindings._void, + u32: substrateBindings._void, + u64: substrateBindings._void, + u128: substrateBindings._void, + u256: substrateBindings._void, + i8: substrateBindings._void, + i16: substrateBindings._void, + i32: substrateBindings._void, + i64: substrateBindings._void, + i128: substrateBindings._void, + i256: substrateBindings._void +}); +const typeRef = substrateBindings.ScaleEnum({ + bool: substrateBindings._void, + char: substrateBindings._void, + str: substrateBindings._void, + u8: substrateBindings._void, + u16: substrateBindings._void, + u32: substrateBindings._void, + u64: substrateBindings._void, + u128: substrateBindings._void, + u256: substrateBindings._void, + i8: substrateBindings._void, + i16: substrateBindings._void, + i32: substrateBindings._void, + i64: substrateBindings._void, + i128: substrateBindings._void, + i256: substrateBindings._void, + compactU8: substrateBindings._void, + compactU16: substrateBindings._void, + compactU32: substrateBindings._void, + compactU64: substrateBindings._void, + compactU128: substrateBindings._void, + compactU256: substrateBindings._void, + void: substrateBindings._void, + perId: substrateBindings.compactNumber +}); +const field = substrateBindings.Struct({ + name: substrateBindings.Option(substrateBindings.str), + ty: typeRef, + typeName: substrateBindings.Option(substrateBindings.str) +}); +const typeDef = substrateBindings.ScaleEnum({ + composite: substrateBindings.Vector(field), + enumeration: substrateBindings.Struct({ + name: substrateBindings.str, + fields: substrateBindings.Vector(field), + index: substrateBindings.compactNumber + }), + sequence: typeRef, + array: substrateBindings.Struct({ + len: substrateBindings.u32, + typeParam: typeRef + }), + tuple: substrateBindings.Vector(typeRef), + bitSequence: substrateBindings.Struct({ + numBytes: substrateBindings.u8, + leastSignificantBitFirst: substrateBindings.bool + }) +}); +const lookupType = substrateBindings.Struct({ + path: substrateBindings.Vector(substrateBindings.str), + typeDef, + typeId: substrateBindings.compactNumber +}); +const lookup = substrateBindings.Vector(lookupType); +const extrinsicMetadata = substrateBindings.Struct({ + version: substrateBindings.u8, + addressTy: typeRef, + callTy: typeRef, + signatureTy: typeRef, + signedExtensions: substrateBindings.Vector( + substrateBindings.Struct({ + identifier: substrateBindings.str, + includedInExtrinsic: typeRef, + includedInSignedData: typeRef + }) + ) +}); +const extrinsicDec = substrateBindings.Tuple.dec( + substrateBindings.compact[1], + substrateBindings.extrinsicFormat[1], + substrateBindings.Bytes(Infinity)[1] +); +const proof = substrateBindings.Struct({ + leaves: lookup, + leafIdxs: substrateBindings.Vector(substrateBindings.u32), + proofs: substrateBindings.Vector(hash), + extrinsic: extrinsicMetadata, + info: extraInfo +}); + +const getAccessibleTypes = (metadata, definitions) => { + const types = /* @__PURE__ */ new Set(); + const collectTypesFromId = (id) => { + if (types.has(id)) return; + const { tag, value } = definitions.get(id).def; + switch (tag) { + case "composite": + if (!value.length) break; + types.add(id); + value.forEach(({ type }) => { + collectTypesFromId(type); + }); + break; + case "variant": + if (!value.length) break; + types.add(id); + value.forEach(({ fields }) => { + fields.forEach(({ type }) => { + collectTypesFromId(type); + }); + }); + break; + case "tuple": + if (!value.length) break; + types.add(id); + value.forEach(collectTypesFromId); + break; + case "sequence": + types.add(id); + collectTypesFromId(value); + break; + case "array": + types.add(id); + collectTypesFromId(value.type); + break; + case "bitSequence": + types.add(id); + } + }; + collectTypesFromId(metadata.extrinsic.call); + collectTypesFromId(metadata.extrinsic.address); + collectTypesFromId(metadata.extrinsic.signature); + metadata.extrinsic.signedExtensions.forEach(({ type, additionalSigned }) => { + collectTypesFromId(type); + collectTypesFromId(additionalSigned); + }); + const sortedTypes = [...types].sort((a, b) => a - b); + return new Map(sortedTypes.map((value, idx) => [value, idx])); +}; + +const bitSequenceBytes = { + u8: 1, + u16: 2, + u32: 4, + u64: 8 +}; +const constructTypeDef = (definitions, getTypeRef, getPrimitive, frameId) => { + const { + def: { tag, value } + } = definitions.get(frameId); + switch (tag) { + case "composite": + return [ + { + tag, + value: value.map((f) => ({ + name: f.name, + typeName: f.typeName, + ty: getTypeRef(f.type) + })) + } + ]; + case "variant": { + return value.map((v) => ({ + tag: "enumeration", + value: { + name: v.name, + index: v.index, + fields: v.fields.map((f) => ({ + name: f.name, + typeName: f.typeName, + ty: getTypeRef(f.type) + })) + } + })); + } + case "sequence": + return [ + { + tag, + value: getTypeRef(value) + } + ]; + case "array": + return [ + { + tag, + value: { + len: value.len, + typeParam: getTypeRef(value.type) + } + } + ]; + case "tuple": + return [ + { + tag, + value: value.map(getTypeRef) + } + ]; + case "bitSequence": { + const primitive = getPrimitive(value.bitStoreType); + const numBytes = bitSequenceBytes[primitive]; + if (!numBytes) throw new Error("Invalid primitive for BitSequence"); + const storeOrderPath = definitions.get(value.bitOrderType).path; + const leastSignificantBitFirst = storeOrderPath.includes("Lsb0"); + if (!leastSignificantBitFirst && !storeOrderPath.includes("Msb0")) + throw new Error("BitOrderType not recognized"); + return [ + { + tag: "bitSequence", + value: { numBytes, leastSignificantBitFirst } + } + ]; + } + } + throw new Error(`FrameId(${frameId}) should have been filtered out`); +}; +const getLookup = (definitions, accessibleTypes, getTypeRef, getPrimitive) => { + const typeTree = []; + [...accessibleTypes.entries()].forEach(([frameId, typeId]) => { + const { path } = definitions.get(frameId); + constructTypeDef(definitions, getTypeRef, getPrimitive, frameId).forEach( + (typeDef) => { + typeTree.push({ + path, + typeId, + typeDef + }); + } + ); + }); + typeTree.sort((a, b) => { + if (a.typeId !== b.typeId) return a.typeId - b.typeId; + if (a.typeDef.tag !== "enumeration" || b.typeDef.tag !== "enumeration") + throw new Error("Found two types with same id"); + return a.typeDef.value.index - b.typeDef.value.index; + }); + return typeTree; +}; + +const getMetadata = (input) => { + try { + const metadata = substrateBindings.unifyMetadata(substrateBindings.decAnyMetadata(input)); + if (metadata.version <= 14) throw new Error("Wrong metadata version"); + return metadata; + } catch (e) { + throw e || new Error("Unable to decode metadata"); + } +}; + +const toBytes = (input) => typeof input === "string" ? utils.fromHex(input) : input; +const compactTypeRefs = { + null: "void", + u8: "compactU8", + u16: "compactU16", + u32: "compactU32", + u64: "compactU64", + u128: "compactU128", + u256: "compactU256" +}; + +const typeRefDecoders = { + bool: substrateBindings.u8, + char: substrateBindings.u8, + str: substrateBindings.str, + u8: substrateBindings.u8, + u16: substrateBindings.u16, + u32: substrateBindings.u32, + u64: substrateBindings.u64, + u128: substrateBindings.u128, + u256: substrateBindings.u256, + i8: substrateBindings.i8, + i16: substrateBindings.i16, + i32: substrateBindings.i32, + i64: substrateBindings.i64, + i128: substrateBindings.i128, + i256: substrateBindings.i256, + void: substrateBindings._void, + compactU8: substrateBindings.compact, + compactU16: substrateBindings.compact, + compactU32: substrateBindings.compact, + compactU64: substrateBindings.compact, + compactU128: substrateBindings.compact, + compactU256: substrateBindings.compact +}; +const innerDecodeAndCollect = (input, typeRef, idToLookups, lookup, collected) => { + if (typeRef.tag !== "perId") { + typeRefDecoders[typeRef.tag][1](input); + return; + } + const handleTypeRef = (typeRef2) => { + innerDecodeAndCollect(input, typeRef2, idToLookups, lookup, collected); + }; + const lookupIdxs = idToLookups.get(typeRef.value); + const [currentIdx] = lookupIdxs; + const current = lookup[currentIdx]; + if (lookupIdxs.length === 1) collected.add(currentIdx); + switch (current.typeDef.tag) { + case "enumeration": { + const selectedIdx = substrateBindings.u8.dec(input); + const [selected, collectedIdx] = lookupIdxs.map( + (lookupIdx) => [lookup[lookupIdx].typeDef, lookupIdx] + ).find(([x]) => x.value.index === selectedIdx); + collected.add(collectedIdx); + selected.value.fields.forEach(({ ty }) => { + handleTypeRef(ty); + }); + break; + } + case "sequence": { + const len = substrateBindings.compact.dec(input); + for (let i = 0; i < len; i++) handleTypeRef(current.typeDef.value); + break; + } + case "array": { + for (let i = 0; i < current.typeDef.value.len; i++) + handleTypeRef(current.typeDef.value.typeParam); + break; + } + case "composite": { + current.typeDef.value.forEach((x) => { + handleTypeRef(x.ty); + }); + break; + } + case "tuple": { + current.typeDef.value.forEach(handleTypeRef); + break; + } + case "bitSequence": + throw new Error("bitSequence is not supported"); + } +}; +const decodeAndCollectKnownLeafs = (data, typeRefs, lookup) => { + let input = new Uint8Array(); + substrateBindings.createDecoder((_input) => { + input = _input; + })(data); + const idToLookups = /* @__PURE__ */ new Map(); + lookup.forEach((lookup2, idx) => { + const arr = idToLookups.get(lookup2.typeId); + if (arr) arr.push(idx); + else idToLookups.set(lookup2.typeId, [idx]); + }); + const result = /* @__PURE__ */ new Set(); + typeRefs.forEach((typeRef) => { + innerDecodeAndCollect(input, typeRef, idToLookups, lookup, result); + }); + return [...result].sort((a, b) => a - b); +}; + +const getLevelFromIdx = (idx) => Math.log2(idx + 1) | 0; +const getAncestorIdx = (from, nLevels) => (from + 1 >> nLevels) - 1; +function getProofData(leaves, knownLeavesIdxs) { + const knownLeaves = knownLeavesIdxs.map((idx) => leaves[idx]); + const startingIdx = leaves.length - 1; + const leafIdxs = knownLeavesIdxs.map((idx) => startingIdx + idx); + const proofIdxs = []; + if (leafIdxs.length) { + const nLevels = getLevelFromIdx(leafIdxs.at(-1)); + const splitPosition = Math.pow(2, nLevels) - 1; + const splitIdx = leafIdxs.findIndex((x) => x >= splitPosition); + if (splitIdx > 0) { + leafIdxs.unshift(...leafIdxs.splice(splitIdx)); + knownLeaves.unshift(...knownLeaves.splice(splitIdx)); + } + } + let targetIdx = 0; + const traverse = (nodeIdx) => { + if (targetIdx === leafIdxs.length) { + proofIdxs.push(nodeIdx); + return; + } + const target = leafIdxs[targetIdx]; + if (target === nodeIdx) { + ++targetIdx; + return; + } + const currentLevel = getLevelFromIdx(nodeIdx); + const targetLevel = getLevelFromIdx(target); + if (nodeIdx !== getAncestorIdx(target, targetLevel - currentLevel)) { + proofIdxs.push(nodeIdx); + return; + } + const leftSon = 2 * nodeIdx + 1; + traverse(leftSon); + traverse(leftSon + 1); + }; + traverse(0); + return { + leaves: knownLeaves, + leafIdxs, + proofIdxs + }; +} + +const assertExpected = (name, expected, received) => { + if (received != null && received !== expected) + throw new Error( + `${name} not expected. Received ${received} expected ${expected}` + ); +}; +const merkleizeMetadata = (metadataBytes, { + decimals, + tokenSymbol, + ...hinted +}) => { + const metadata = getMetadata(metadataBytes); + const checkedVersion = metadata.extrinsic.version.includes(4) ? 4 : null; + if (checkedVersion == null) throw new Error("Only extrinsic v4 is supported"); + const { ss58Prefix, buildDefinition } = metadataBuilders.getDynamicBuilder( + metadataBuilders.getLookupFn(metadata) + ); + if (ss58Prefix == null) throw new Error("SS58 prefix not found in metadata"); + assertExpected("SS58 prefix", ss58Prefix, hinted.base58Prefix); + const version = metadata.pallets.find((x) => x.name === "System")?.constants.find((x) => x.name === "Version"); + if (version == null) throw new Error("System.Version constant not found"); + const { spec_name: specName, spec_version: specVersion } = buildDefinition( + version.type + ).dec(version.value); + if (typeof specName !== "string" || typeof specVersion !== "number") + throw new Error("Spec name or spec version not found"); + assertExpected("Spec name", specName, hinted.specName); + assertExpected("Spec version", specVersion, hinted.specVersion); + const info = { + decimals, + tokenSymbol, + specVersion, + specName, + base58Prefix: ss58Prefix + }; + const definitions = new Map( + metadata.lookup.map((value) => [value.id, value]) + ); + const accessibleTypes = getAccessibleTypes(metadata, definitions); + const getPrimitive = (frameId) => { + const { + def: { tag, value } + } = definitions.get(frameId); + if (tag === "primitive") return value.tag; + if (tag !== "composite" && tag !== "tuple" || value.length > 1) + throw new Error("The provided definition doesn't map to a primitive"); + return value.length === 0 ? null : getPrimitive(tag === "tuple" ? value[0] : value[0].type); + }; + const getTypeRef = (frameId) => { + const { def } = definitions.get(frameId); + if (def.tag === "primitive") return { tag: def.value.tag, value: void 0 }; + if (def.tag === "compact") { + const primitive = getPrimitive(def.value); + const tag = compactTypeRefs[primitive]; + if (!tag) throw new Error("Invalid primitive for Compact"); + return { tag, value: void 0 }; + } + return accessibleTypes.has(frameId) ? { tag: "perId", value: accessibleTypes.get(frameId) } : { tag: "void", value: void 0 }; + }; + const extrinsic = { + version: checkedVersion, + addressTy: getTypeRef(metadata.extrinsic.address), + callTy: getTypeRef(metadata.extrinsic.call), + signatureTy: getTypeRef(metadata.extrinsic.signature), + signedExtensions: metadata.extrinsic.signedExtensions.map((se) => ({ + identifier: se.identifier, + includedInExtrinsic: getTypeRef(se.type), + includedInSignedData: getTypeRef(se.additionalSigned) + })) + }; + const lookup = getLookup( + definitions, + accessibleTypes, + getTypeRef, + getPrimitive + ); + const lookupEncoded = lookup.map(lookupType.enc); + let hashTree; + const getHashTree = () => { + if (hashTree) return hashTree; + if (!lookupEncoded.length) return hashTree = [new Uint8Array(32).fill(0)]; + hashTree = new Array(lookupEncoded.length * 2 - 1); + let leavesStartIdx = lookupEncoded.length - 1; + for (let i = 0; i < lookupEncoded.length; i++) + hashTree[leavesStartIdx + i] = substrateBindings.Blake3256(lookupEncoded[i]); + for (let i = hashTree.length - 2; i > 0; i -= 2) + hashTree[(i - 1) / 2] = substrateBindings.Blake3256( + utils.mergeUint8([hashTree[i], hashTree[i + 1]]) + ); + return hashTree; + }; + let digested; + const digest = () => { + if (digested) return digested; + const rootLookupHash = getHashTree()[0]; + const digest2 = { + tag: "V1", + value: { + typeInformationTreeRoot: rootLookupHash, + extrinsicMetadataHash: substrateBindings.Blake3256(extrinsicMetadata.enc(extrinsic)), + ...info + } + }; + return digested = substrateBindings.Blake3256(metadataDigest.enc(digest2)); + }; + const generateProof = (knownIndexes) => { + const proofData = getProofData(lookupEncoded, knownIndexes); + const hashTree2 = getHashTree(); + const proofs = proofData.proofIdxs.map((idx) => hashTree2[idx]); + return utils.mergeUint8([ + substrateBindings.compact.enc(proofData.leaves.length), + ...proofData.leaves, + substrateBindings.compact.enc(proofData.leafIdxs.length), + ...proofData.leafIdxs.map((x) => substrateBindings.u32.enc(x)), + substrateBindings.compact.enc(proofs.length), + ...proofs, + extrinsicMetadata.enc(extrinsic), + extraInfo.enc(info) + ]); + }; + const getProofForExtrinsicPayload = (extrinsicPayload) => { + const typeRefs = [ + extrinsic.callTy, + ...extrinsic.signedExtensions.map((x) => x.includedInExtrinsic), + ...extrinsic.signedExtensions.map((x) => x.includedInSignedData) + ]; + return generateProof( + decodeAndCollectKnownLeafs(extrinsicPayload, typeRefs, lookup) + ); + }; + const getProofForExtrinsicParts = (callData, includedInExtrinsic, includedInSignedData) => { + const bytes = utils.mergeUint8( + [callData, includedInExtrinsic, includedInSignedData].map(toBytes) + ); + return getProofForExtrinsicPayload(bytes); + }; + const getProofForExtrinsic = (transaction, txAdditionalSigned) => { + let [, { version: version2, type }, bytes] = extrinsicDec(transaction); + if (version2 !== extrinsic.version) + throw new Error("Incorrect extrinsic version"); + const typeRefs = type === "signed" ? [ + extrinsic.addressTy, + extrinsic.signatureTy, + ...extrinsic.signedExtensions.map((x) => x.includedInExtrinsic), + extrinsic.callTy + ] : [extrinsic.callTy]; + if (txAdditionalSigned) { + bytes = utils.mergeUint8([bytes, toBytes(txAdditionalSigned)]); + typeRefs.push( + ...extrinsic.signedExtensions.map((x) => x.includedInSignedData) + ); + } + return generateProof(decodeAndCollectKnownLeafs(bytes, typeRefs, lookup)); + }; + return { + digest, + getProofForExtrinsic, + getProofForExtrinsicParts, + getProofForExtrinsicPayload + }; +}; + +exports.extraInfo = extraInfo; +exports.extrinsicMetadata = extrinsicMetadata; +exports.hash = hash; +exports.lookup = lookup; +exports.lookupType = lookupType; +exports.merkleizeMetadata = merkleizeMetadata; +exports.proof = proof; +//# sourceMappingURL=index.js.map diff --git a/packages/merkleize-metadata/dist/index.js.map b/packages/merkleize-metadata/dist/index.js.map new file mode 100644 index 0000000..e91ec14 --- /dev/null +++ b/packages/merkleize-metadata/dist/index.js.map @@ -0,0 +1 @@ +{"version":3,"file":"index.js","sources":["../src/codecs.ts","../src/get-accessible-types.ts","../src/get-lookup.ts","../src/get-metadata.ts","../src/utils.ts","../src/decode-and-collect.ts","../src/proof.ts","../src/main.ts"],"sourcesContent":["import {\n Bytes,\n Codec,\n CodecType,\n Option,\n ScaleEnum,\n Struct,\n Tuple,\n V14Lookup,\n Vector,\n _void,\n bool,\n compact,\n compactNumber,\n extrinsicFormat,\n str,\n u16,\n u32,\n u8,\n} from \"@pezkuwi/bizinikiwi-bindings\"\n\nconst extraInfoInner = {\n specVersion: u32,\n specName: str,\n base58Prefix: u16,\n decimals: u8,\n tokenSymbol: str,\n}\nexport const extraInfo = Struct(extraInfoInner)\nexport type ExtraInfo = CodecType\n\nexport const hash = Bytes(32)\nexport const metadataDigest = ScaleEnum({\n V0: _void,\n V1: Struct({\n typeInformationTreeRoot: hash,\n extrinsicMetadataHash: hash,\n ...extraInfoInner,\n }),\n})\nexport type MetadataDigest = CodecType\n\nexport const scalePrimitive = ScaleEnum({\n bool: _void,\n char: _void,\n str: _void,\n u8: _void,\n u16: _void,\n u32: _void,\n u64: _void,\n u128: _void,\n u256: _void,\n i8: _void,\n i16: _void,\n i32: _void,\n i64: _void,\n i128: _void,\n i256: _void,\n})\nexport type ScalePrimitive = CodecType\n\nexport const typeRef = ScaleEnum({\n bool: _void,\n char: _void,\n str: _void,\n u8: _void,\n u16: _void,\n u32: _void,\n u64: _void,\n u128: _void,\n u256: _void,\n i8: _void,\n i16: _void,\n i32: _void,\n i64: _void,\n i128: _void,\n i256: _void,\n compactU8: _void,\n compactU16: _void,\n compactU32: _void,\n compactU64: _void,\n compactU128: _void,\n compactU256: _void,\n void: _void,\n perId: compactNumber,\n})\nexport type TypeRef = CodecType\n\nconst field = Struct({\n name: Option(str),\n ty: typeRef,\n typeName: Option(str),\n})\nexport const typeDef = ScaleEnum({\n composite: Vector(field),\n enumeration: Struct({\n name: str,\n fields: Vector(field),\n index: compactNumber,\n }),\n sequence: typeRef,\n array: Struct({\n len: u32,\n typeParam: typeRef,\n }),\n tuple: Vector(typeRef),\n bitSequence: Struct({\n numBytes: u8,\n leastSignificantBitFirst: bool,\n }),\n})\nexport type TypeDef = CodecType\n\nexport const lookupType = Struct({\n path: Vector(str),\n typeDef: typeDef,\n typeId: compactNumber,\n})\nexport type LookupEntry = CodecType\nexport type Lookup = Array\nexport const lookup: Codec = Vector(lookupType)\n\nexport const extrinsicMetadata = Struct({\n version: u8,\n addressTy: typeRef,\n callTy: typeRef,\n signatureTy: typeRef,\n signedExtensions: Vector(\n Struct({\n identifier: str,\n includedInExtrinsic: typeRef,\n includedInSignedData: typeRef,\n }),\n ),\n})\nexport type ExtrinsicMetadata = CodecType\nexport type LookupValue = V14Lookup[number]\n\nexport const extrinsicDec = Tuple.dec(\n compact[1],\n extrinsicFormat[1],\n Bytes(Infinity)[1],\n)\n\nexport const proof = Struct({\n leaves: lookup,\n leafIdxs: Vector(u32),\n proofs: Vector(hash),\n extrinsic: extrinsicMetadata,\n info: extraInfo,\n})\nexport type Proof = CodecType\n","import { UnifiedMetadata } from \"@pezkuwi/bizinikiwi-bindings\"\nimport { LookupValue } from \"./codecs\"\n\nexport const getAccessibleTypes = (\n metadata: UnifiedMetadata<15 | 16>,\n definitions: Map,\n): Map => {\n const types = new Set()\n\n const collectTypesFromId = (id: number) => {\n if (types.has(id)) return\n\n const { tag, value } = definitions.get(id)!.def\n switch (tag) {\n case \"composite\":\n if (!value.length) break\n types.add(id)\n value.forEach(({ type }) => {\n collectTypesFromId(type)\n })\n break\n case \"variant\":\n if (!value.length) break\n types.add(id)\n value.forEach(({ fields }) => {\n fields.forEach(({ type }) => {\n collectTypesFromId(type)\n })\n })\n break\n case \"tuple\":\n if (!value.length) break\n types.add(id)\n value.forEach(collectTypesFromId)\n break\n case \"sequence\":\n types.add(id)\n collectTypesFromId(value)\n break\n case \"array\":\n types.add(id)\n collectTypesFromId(value.type)\n break\n case \"bitSequence\": // bitSequence inner types are not stored\n types.add(id)\n // primitive and compact are not stored\n }\n }\n\n collectTypesFromId(metadata.extrinsic.call)\n collectTypesFromId(metadata.extrinsic.address)\n collectTypesFromId(metadata.extrinsic.signature)\n metadata.extrinsic.signedExtensions.forEach(({ type, additionalSigned }) => {\n collectTypesFromId(type)\n collectTypesFromId(additionalSigned)\n })\n\n const sortedTypes = [...types].sort((a, b) => a - b)\n return new Map(sortedTypes.map((value, idx) => [value, idx]))\n}\n","import { Lookup, LookupValue, ScalePrimitive, TypeDef, TypeRef } from \"./codecs\"\n\nconst bitSequenceBytes = {\n u8: 1,\n u16: 2,\n u32: 4,\n u64: 8,\n}\n\nconst constructTypeDef = (\n definitions: Map,\n getTypeRef: (frameId: number) => TypeRef,\n getPrimitive: (frameId: number) => ScalePrimitive[\"tag\"] | null,\n frameId: number,\n): TypeDef[] => {\n const {\n def: { tag, value },\n } = definitions.get(frameId)!\n switch (tag) {\n case \"composite\":\n return [\n {\n tag,\n value: value.map((f) => ({\n name: f.name,\n typeName: f.typeName,\n ty: getTypeRef(f.type),\n })),\n },\n ]\n case \"variant\": {\n return value.map((v) => ({\n tag: \"enumeration\",\n value: {\n name: v.name,\n index: v.index,\n fields: v.fields.map((f) => ({\n name: f.name,\n typeName: f.typeName,\n ty: getTypeRef(f.type),\n })),\n },\n }))\n }\n case \"sequence\":\n return [\n {\n tag,\n value: getTypeRef(value),\n },\n ]\n case \"array\":\n return [\n {\n tag,\n value: {\n len: value.len,\n typeParam: getTypeRef(value.type),\n },\n },\n ]\n case \"tuple\":\n return [\n {\n tag,\n value: value.map(getTypeRef),\n },\n ]\n case \"bitSequence\": {\n const primitive = getPrimitive(value.bitStoreType)\n const numBytes = bitSequenceBytes[primitive as \"u8\"]\n if (!numBytes) throw new Error(\"Invalid primitive for BitSequence\")\n\n const storeOrderPath = definitions.get(value.bitOrderType)!.path\n const leastSignificantBitFirst = storeOrderPath.includes(\"Lsb0\")\n if (!leastSignificantBitFirst && !storeOrderPath.includes(\"Msb0\"))\n throw new Error(\"BitOrderType not recognized\")\n\n return [\n {\n tag: \"bitSequence\",\n value: { numBytes, leastSignificantBitFirst },\n },\n ]\n }\n }\n\n throw new Error(`FrameId(${frameId}) should have been filtered out`)\n}\n\nexport const getLookup = (\n definitions: Map,\n accessibleTypes: Map,\n getTypeRef: (frameId: number) => TypeRef,\n getPrimitive: (frameId: number) => ScalePrimitive[\"tag\"] | null,\n) => {\n const typeTree: Lookup = []\n ;[...accessibleTypes.entries()].forEach(([frameId, typeId]) => {\n const { path } = definitions.get(frameId)!\n constructTypeDef(definitions, getTypeRef, getPrimitive, frameId).forEach(\n (typeDef) => {\n typeTree.push({\n path,\n typeId,\n typeDef,\n })\n },\n )\n })\n\n typeTree.sort((a, b) => {\n if (a.typeId !== b.typeId) return a.typeId - b.typeId // in general\n // should only happen for variants\n if (a.typeDef.tag !== \"enumeration\" || b.typeDef.tag !== \"enumeration\")\n throw new Error(\"Found two types with same id\")\n return a.typeDef.value.index - b.typeDef.value.index\n })\n return typeTree\n}\n","import {\n decAnyMetadata,\n UnifiedMetadata,\n type HexString,\n unifyMetadata,\n} from \"@pezkuwi/bizinikiwi-bindings\"\n\nexport const getMetadata = (\n input: Uint8Array | HexString,\n): UnifiedMetadata<15 | 16> => {\n try {\n const metadata = unifyMetadata(decAnyMetadata(input))\n if (metadata.version <= 14) throw new Error(\"Wrong metadata version\")\n return metadata as UnifiedMetadata<15 | 16>\n } catch (e) {\n throw e || new Error(\"Unable to decode metadata\")\n }\n}\n","import { type HexString } from \"@pezkuwi/bizinikiwi-bindings\"\nimport { fromHex } from \"@pezkuwi/papi-utils\"\n\nexport const toBytes = (input: Uint8Array | HexString) =>\n typeof input === \"string\" ? fromHex(input) : input\n\nexport const compactTypeRefs = {\n null: \"void\" as const,\n u8: \"compactU8\" as const,\n u16: \"compactU16\" as const,\n u32: \"compactU32\" as const,\n u64: \"compactU64\" as const,\n u128: \"compactU128\" as const,\n u256: \"compactU256\" as const,\n}\n","import {\n HexString,\n _void,\n compact,\n createDecoder,\n i128,\n i16,\n i256,\n i32,\n i64,\n i8,\n str,\n u128,\n u16,\n u256,\n u32,\n u64,\n u8,\n} from \"@pezkuwi/bizinikiwi-bindings\"\nimport { Lookup, TypeDef, TypeRef } from \"./codecs\"\n\nconst typeRefDecoders = {\n bool: u8,\n char: u8,\n str,\n u8,\n u16,\n u32,\n u64,\n u128,\n u256,\n i8,\n i16,\n i32,\n i64,\n i128,\n i256,\n void: _void,\n compactU8: compact,\n compactU16: compact,\n compactU32: compact,\n compactU64: compact,\n compactU128: compact,\n compactU256: compact,\n}\n\nconst innerDecodeAndCollect = (\n input: Uint8Array,\n typeRef: TypeRef,\n idToLookups: Map>,\n lookup: Lookup,\n collected: Set,\n) => {\n if (typeRef.tag !== \"perId\") {\n typeRefDecoders[typeRef.tag][1](input)\n return\n }\n\n const handleTypeRef = (typeRef: TypeRef) => {\n innerDecodeAndCollect(input, typeRef, idToLookups, lookup, collected)\n }\n\n const lookupIdxs = idToLookups.get(typeRef.value)!\n const [currentIdx] = lookupIdxs\n const current = lookup[currentIdx]\n\n if (lookupIdxs.length === 1) collected.add(currentIdx)\n\n switch (current.typeDef.tag) {\n case \"enumeration\": {\n const selectedIdx = u8.dec(input)\n const [selected, collectedIdx] = lookupIdxs\n .map(\n (lookupIdx) =>\n [lookup[lookupIdx].typeDef, lookupIdx] as [\n TypeDef & { tag: \"enumeration\" },\n number,\n ],\n )\n .find(([x]) => x.value.index === selectedIdx)!\n collected.add(collectedIdx)\n selected.value.fields.forEach(({ ty }) => {\n handleTypeRef(ty)\n })\n break\n }\n case \"sequence\": {\n const len = compact.dec(input)\n for (let i = 0; i < len; i++) handleTypeRef(current.typeDef.value)\n break\n }\n case \"array\": {\n for (let i = 0; i < current.typeDef.value.len; i++)\n handleTypeRef(current.typeDef.value.typeParam)\n break\n }\n case \"composite\": {\n current.typeDef.value.forEach((x) => {\n handleTypeRef(x.ty)\n })\n break\n }\n case \"tuple\": {\n current.typeDef.value.forEach(handleTypeRef)\n break\n }\n case \"bitSequence\":\n throw new Error(\"bitSequence is not supported\")\n }\n}\n\nexport const decodeAndCollectKnownLeafs = (\n data: Uint8Array | HexString,\n typeRefs: Array,\n lookup: Lookup,\n): Array => {\n let input: Uint8Array = new Uint8Array()\n createDecoder((_input) => {\n input = _input\n })(data)\n\n const idToLookups = new Map()\n lookup.forEach((lookup, idx) => {\n const arr = idToLookups.get(lookup.typeId)\n if (arr) arr.push(idx)\n else idToLookups.set(lookup.typeId, [idx])\n })\n\n const result = new Set()\n typeRefs.forEach((typeRef) => {\n innerDecodeAndCollect(input, typeRef, idToLookups, lookup, result)\n })\n\n return [...result].sort((a, b) => a - b)\n}\n","const getLevelFromIdx = (idx: number) => Math.log2(idx + 1) | 0\nconst getAncestorIdx = (from: number, nLevels: number) =>\n ((from + 1) >> nLevels) - 1\n\nexport function getProofData(\n leaves: Array,\n knownLeavesIdxs: Array,\n) {\n const knownLeaves = knownLeavesIdxs.map((idx) => leaves[idx])\n\n const startingIdx = leaves.length - 1\n const leafIdxs = knownLeavesIdxs.map((idx) => startingIdx + idx)\n\n const proofIdxs: Array = []\n if (leafIdxs.length) {\n const nLevels = getLevelFromIdx(leafIdxs.at(-1)!)\n const splitPosition = Math.pow(2, nLevels) - 1\n const splitIdx = leafIdxs.findIndex((x) => x >= splitPosition)\n if (splitIdx > 0) {\n leafIdxs.unshift(...leafIdxs.splice(splitIdx))\n knownLeaves.unshift(...knownLeaves.splice(splitIdx))\n }\n }\n\n let targetIdx = 0\n const traverse = (nodeIdx: number): void => {\n if (targetIdx === leafIdxs.length) {\n proofIdxs.push(nodeIdx)\n return\n }\n\n const target = leafIdxs[targetIdx]\n if (target === nodeIdx) {\n ++targetIdx\n return\n }\n\n const currentLevel = getLevelFromIdx(nodeIdx)\n const targetLevel = getLevelFromIdx(target)\n\n if (nodeIdx !== getAncestorIdx(target, targetLevel - currentLevel)) {\n proofIdxs.push(nodeIdx)\n return\n }\n\n const leftSon = 2 * nodeIdx + 1\n traverse(leftSon)\n traverse(leftSon + 1)\n }\n traverse(0)\n\n return {\n leaves: knownLeaves,\n leafIdxs,\n proofIdxs,\n }\n}\n","import {\n Blake3256,\n HexString,\n compact,\n u32,\n} from \"@pezkuwi/bizinikiwi-bindings\"\nimport {\n ExtraInfo,\n ExtrinsicMetadata,\n LookupValue,\n MetadataDigest,\n ScalePrimitive,\n TypeRef,\n extraInfo,\n extrinsicMetadata,\n lookupType,\n metadataDigest,\n extrinsicDec,\n} from \"./codecs\"\nimport { getAccessibleTypes } from \"./get-accessible-types\"\nimport { getLookup } from \"./get-lookup\"\nimport { getMetadata } from \"./get-metadata\"\nimport { compactTypeRefs, toBytes } from \"./utils\"\nimport { decodeAndCollectKnownLeafs } from \"./decode-and-collect\"\nimport { getProofData } from \"./proof\"\nimport { getDynamicBuilder, getLookupFn } from \"@pezkuwi/metadata-builders\"\nimport { mergeUint8 } from \"@pezkuwi/papi-utils\"\n\nexport interface MetadataMerkleizer {\n /**\n * @returns Digest value of the metadata (aka its merkleized root-hash)\n */\n digest: () => Uint8Array\n\n /**\n * Get proof for an `Extrinsic`.\n *\n * @param transaction Encoded `Extrinsic`, both signed or unsigned.\n * @param txAdditionalSigned Optionally collect types for given\n * `additionalSigned` part of signedExtensions.\n * @returns Encoded `Proof`\n */\n getProofForExtrinsic: (\n transaction: Uint8Array | HexString,\n txAdditionalSigned?: Uint8Array | HexString,\n ) => Uint8Array\n\n /**\n * Get proof for `ExtrinsicPayload` parts.\n *\n * @param callData Call data of the transaction. It has to be\n * bare; i.e.\n * without prepended compact length.\n * @param includedInExtrinsic Extra part of the signed extensions, all of\n * them concatenated.\n * @param includedInSignedData Additional signed part of the signed\n * extensions, all of them concatenated.\n * @returns Encoded `Proof`\n */\n getProofForExtrinsicParts: (\n callData: Uint8Array | HexString,\n includedInExtrinsic: Uint8Array | HexString,\n includedInSignedData: Uint8Array | HexString,\n ) => Uint8Array\n\n /**\n * Get proof for `ExtrinsicPayload`.\n *\n * @param extrinsicPayload Call data, extra part of signedExtensions and\n * additional signed part of signedExtensions\n * concatenated. It has to be bare; i.e. without\n * prepended compact length.\n * @returns Encoded `Proof`\n */\n getProofForExtrinsicPayload: (\n extrinsicPayload: Uint8Array | HexString,\n ) => Uint8Array\n}\n\nconst assertExpected = (name: string, expected: T, received?: T): void => {\n if (received != null && received !== expected)\n throw new Error(\n `${name} not expected. Received ${received} expected ${expected}`,\n )\n}\n\nexport const merkleizeMetadata = (\n metadataBytes: Uint8Array | HexString,\n {\n decimals,\n tokenSymbol,\n ...hinted\n }: { decimals: number; tokenSymbol: string } & Partial,\n): MetadataMerkleizer => {\n const metadata = getMetadata(metadataBytes)\n\n const checkedVersion = metadata.extrinsic.version.includes(4) ? 4 : null\n if (checkedVersion == null) throw new Error(\"Only extrinsic v4 is supported\")\n\n const { ss58Prefix, buildDefinition } = getDynamicBuilder(\n getLookupFn(metadata),\n )\n if (ss58Prefix == null) throw new Error(\"SS58 prefix not found in metadata\")\n assertExpected(\"SS58 prefix\", ss58Prefix, hinted.base58Prefix)\n const version = metadata.pallets\n .find((x) => x.name === \"System\")\n ?.constants.find((x) => x.name === \"Version\")\n if (version == null) throw new Error(\"System.Version constant not found\")\n const { spec_name: specName, spec_version: specVersion } = buildDefinition(\n version.type,\n ).dec(version.value)\n if (typeof specName !== \"string\" || typeof specVersion !== \"number\")\n throw new Error(\"Spec name or spec version not found\")\n assertExpected(\"Spec name\", specName, hinted.specName)\n assertExpected(\"Spec version\", specVersion, hinted.specVersion)\n\n const info: ExtraInfo = {\n decimals,\n tokenSymbol,\n specVersion,\n specName,\n base58Prefix: ss58Prefix,\n }\n const definitions = new Map(\n metadata.lookup.map((value) => [value.id, value]),\n )\n const accessibleTypes = getAccessibleTypes(metadata, definitions)\n const getPrimitive = (frameId: number): ScalePrimitive[\"tag\"] | null => {\n const {\n def: { tag, value },\n } = definitions.get(frameId)!\n\n if (tag === \"primitive\") return value.tag\n\n if ((tag !== \"composite\" && tag !== \"tuple\") || value.length > 1)\n throw new Error(\"The provided definition doesn't map to a primitive\")\n\n return value.length === 0\n ? null // signals `void`\n : getPrimitive(tag === \"tuple\" ? value[0] : value[0].type)\n }\n\n const getTypeRef = (frameId: number): TypeRef => {\n const { def } = definitions.get(frameId)!\n\n if (def.tag === \"primitive\") return { tag: def.value.tag, value: undefined }\n\n if (def.tag === \"compact\") {\n const primitive = getPrimitive(def.value)\n const tag = compactTypeRefs[primitive as \"u8\"]\n if (!tag) throw new Error(\"Invalid primitive for Compact\")\n return { tag, value: undefined }\n }\n\n return accessibleTypes.has(frameId)\n ? { tag: \"perId\", value: accessibleTypes.get(frameId)! }\n : { tag: \"void\", value: undefined }\n }\n\n const extrinsic: ExtrinsicMetadata = {\n version: checkedVersion,\n addressTy: getTypeRef(metadata.extrinsic.address),\n callTy: getTypeRef(metadata.extrinsic.call),\n signatureTy: getTypeRef(metadata.extrinsic.signature),\n signedExtensions: metadata.extrinsic.signedExtensions.map((se) => ({\n identifier: se.identifier,\n includedInExtrinsic: getTypeRef(se.type),\n includedInSignedData: getTypeRef(se.additionalSigned),\n })),\n }\n\n const lookup = getLookup(\n definitions,\n accessibleTypes,\n getTypeRef,\n getPrimitive,\n )\n const lookupEncoded = lookup.map(lookupType.enc)\n\n let hashTree: Array | undefined\n const getHashTree = (): Array => {\n if (hashTree) return hashTree\n\n if (!lookupEncoded.length) return (hashTree = [new Uint8Array(32).fill(0)])\n\n hashTree = new Array(lookupEncoded.length * 2 - 1)\n\n let leavesStartIdx = lookupEncoded.length - 1\n for (let i = 0; i < lookupEncoded.length; i++)\n hashTree[leavesStartIdx + i] = Blake3256(lookupEncoded[i])\n\n for (let i = hashTree.length - 2; i > 0; i -= 2)\n hashTree[(i - 1) / 2] = Blake3256(\n mergeUint8([hashTree[i], hashTree[i + 1]]),\n )\n\n return hashTree\n }\n\n let digested: undefined | Uint8Array\n const digest = () => {\n if (digested) return digested\n const rootLookupHash = getHashTree()[0]\n\n const digest: MetadataDigest = {\n tag: \"V1\",\n value: {\n typeInformationTreeRoot: rootLookupHash,\n extrinsicMetadataHash: Blake3256(extrinsicMetadata.enc(extrinsic)),\n ...info,\n },\n }\n\n return (digested = Blake3256(metadataDigest.enc(digest)))\n }\n\n const generateProof = (knownIndexes: number[]) => {\n const proofData = getProofData(lookupEncoded, knownIndexes)\n\n const hashTree = getHashTree()\n const proofs = proofData.proofIdxs.map((idx) => hashTree[idx])\n\n return mergeUint8([\n compact.enc(proofData.leaves.length),\n ...proofData.leaves,\n compact.enc(proofData.leafIdxs.length),\n ...proofData.leafIdxs.map((x) => u32.enc(x)),\n compact.enc(proofs.length),\n ...proofs,\n extrinsicMetadata.enc(extrinsic),\n extraInfo.enc(info),\n ])\n }\n\n const getProofForExtrinsicPayload = (\n extrinsicPayload: Uint8Array | HexString,\n ) => {\n const typeRefs: Array = [\n extrinsic.callTy,\n ...extrinsic.signedExtensions.map((x) => x.includedInExtrinsic),\n ...extrinsic.signedExtensions.map((x) => x.includedInSignedData),\n ]\n return generateProof(\n decodeAndCollectKnownLeafs(extrinsicPayload, typeRefs, lookup),\n )\n }\n\n const getProofForExtrinsicParts = (\n callData: Uint8Array | HexString,\n includedInExtrinsic: Uint8Array | HexString,\n includedInSignedData: Uint8Array | HexString,\n ) => {\n const bytes = mergeUint8(\n [callData, includedInExtrinsic, includedInSignedData].map(toBytes),\n )\n return getProofForExtrinsicPayload(bytes)\n }\n\n const getProofForExtrinsic = (\n transaction: Uint8Array | HexString,\n txAdditionalSigned?: Uint8Array | HexString,\n ) => {\n let [, { version, type }, bytes] = extrinsicDec(transaction)\n\n if (version !== extrinsic.version)\n throw new Error(\"Incorrect extrinsic version\")\n\n const typeRefs: TypeRef[] =\n type === \"signed\"\n ? [\n extrinsic.addressTy,\n extrinsic.signatureTy,\n ...extrinsic.signedExtensions.map((x) => x.includedInExtrinsic),\n extrinsic.callTy,\n ]\n : [extrinsic.callTy]\n\n if (txAdditionalSigned) {\n bytes = mergeUint8([bytes, toBytes(txAdditionalSigned)])\n typeRefs.push(\n ...extrinsic.signedExtensions.map((x) => x.includedInSignedData),\n )\n }\n\n return generateProof(decodeAndCollectKnownLeafs(bytes, typeRefs, lookup))\n }\n\n return {\n digest,\n getProofForExtrinsic,\n getProofForExtrinsicParts,\n getProofForExtrinsicPayload,\n }\n}\n"],"names":["u32","str","u16","u8","Struct","Bytes","ScaleEnum","_void","compactNumber","Option","Vector","bool","Tuple","compact","extrinsicFormat","unifyMetadata","decAnyMetadata","fromHex","u64","u128","u256","i8","i16","i32","i64","i128","i256","typeRef","createDecoder","lookup","getDynamicBuilder","getLookupFn","Blake3256","mergeUint8","digest","hashTree","version"],"mappings":"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"} \ No newline at end of file diff --git a/packages/merkleize-metadata/package.json b/packages/merkleize-metadata/package.json new file mode 100644 index 0000000..eae134b --- /dev/null +++ b/packages/merkleize-metadata/package.json @@ -0,0 +1,46 @@ +{ + "name": "@pezkuwi/merkleize-metadata", + "version": "1.0.0", + "author": "Dijital Kurdistan Tech Institute ", + "bugs": "https://github.com/pezkuwichain/pezkuwi-api/issues", + "homepage": "https://github.com/pezkuwichain/pezkuwi-api/tree/master/packages/merkleize-metadata#readme", + "repository": { + "directory": "packages/merkleize-metadata", + "type": "git", + "url": "https://github.com/pezkuwichain/pezkuwi-api.git" + }, + "license": "MIT", + "sideEffects": false, + "type": "module", + "exports": { + ".": { + "node": { + "production": { + "import": "./dist/esm/index.mjs", + "require": "./dist/index.js", + "default": "./dist/index.js" + }, + "import": "./dist/esm/index.mjs", + "require": "./dist/index.js", + "default": "./dist/index.js" + }, + "module": "./dist/esm/index.mjs", + "import": "./dist/esm/index.mjs", + "require": "./dist/index.js", + "default": "./dist/index.js" + }, + "./package.json": "./package.json" + }, + "main": "./dist/index.js", + "module": "./dist/esm/index.mjs", + "browser": "./dist/esm/index.mjs", + "types": "./dist/index.d.ts", + "files": [ + "dist" + ], + "dependencies": { + "@pezkuwi/metadata-builders": "1.0.0", + "@pezkuwi/bizinikiwi-bindings": "1.0.0", + "@pezkuwi/papi-utils": "1.0.0" + } +} diff --git a/packages/metadata-builders/LICENSE b/packages/metadata-builders/LICENSE new file mode 100644 index 0000000..e7c9b1a --- /dev/null +++ b/packages/metadata-builders/LICENSE @@ -0,0 +1,21 @@ +MIT License + +Copyright (c) 2023 Josep M Sobrepere + +Permission is hereby granted, free of charge, to any person obtaining a copy +of this software and associated documentation files (the "Software"), to deal +in the Software without restriction, including without limitation the rights +to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +copies of the Software, and to permit persons to whom the Software is +furnished to do so, subject to the following conditions: + +The above copyright notice and this permission notice shall be included in all +copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +SOFTWARE. diff --git a/packages/metadata-builders/README.md b/packages/metadata-builders/README.md new file mode 100644 index 0000000..ca84905 --- /dev/null +++ b/packages/metadata-builders/README.md @@ -0,0 +1,121 @@ +# @polkadot-api/metadata-builders + +This package has multiple functions that read a metadata object, denormalizes it, and builds other structures needed for different processes + +## getLookupFn + +```ts +interface MetadataLookup { + (id: number): LookupEntry + metadata: V14 | V15 +} + +function getLookupFn(metadata: Metadata): MetadataLookup +``` + +Given the a metadata, returns a function that will give the `LookupEntry` for an id along. The function also has access to the original metadata, as it's usually needed to work with the actual lookup. + +The `LookupEntry` is a denormalized data structure for one entry in the metadata. It also "shortcuts" type references when those are pointers (composites or tuples of length 1). Essentially, it's a union of each of the different types that can be found in the lookup, mostly equivalent to something like: + +```ts +type TerminalVar = + | PrimitiveVar // u8, str, char, i128, etc. + | CompactVar + | BitSequenceVar + | AccountId32 + +type ComposedVar = + | TupleVar + | StructVar + | SequenceVar + | ArrayVar + | OptionVar + | ResultVar + | EnumVar + +type LookupEntry = TerminalVar | ComposedVar +``` + +Where, for instance, a StructVar is of the shape + +```ts +type StructVar = { + type: "struct" + value: Record +} +``` + +It's useful to get types referenced by storage calls, etc. + +## getDynamicBuilder + +```ts +function getDynamicBuilder(metadataLookup: MetadataLookup): { + buildDefinition: (id: number) => Codec + buildConstant: (pallet: string, name: string) => Codec + buildEvent: (pallet: string, name: string) => VariantEntry + buildError: (pallet: string, name: string) => VariantEntry + buildCall: (pallet: string, name: string) => VariantEntry + buildStorage: (pallet: string, entry: string) => StorageEntry + buildRuntimeCall: (api: string, method: string) => RuntimeEntry +} +``` + +Generates all the codecs needed to SCALE encode or decode the data for any interaction with the chain. + +`buildDefinition` returns the codec for the type identified by the parameter `id` + +`buildConstant` returns the codec for the requested constant (equivalent as calling `buildDefinition` with the type id of that constant) + +`buildEvent`, `buildError` and `buildCall` return an object with the codec, and the indices of the pallet and entry within the metadata: + +```ts +interface VariantEntry { + location: [number, number] // [palletIdx, entryIdx], + codec: Codec +} +``` + +`buildStorage` creates all the encoders/decoders needed to encode a storage call and decode its result: + +```ts +interface StorageEntry { + // Encodes the arguments of the storage call. + enc: (...args: any[]) => string + // Decodes the result from the storage call. + dec: (value: string) => any + // Decodes the arguments of the storage call + keyDecoder: (value: string) => any[] + // Expected number of arguments + len: number + // Decoded fallback value as defined in the metadata entry + fallback: unknown +} +``` + +Similarly, `buildRuntimeCall` returns the codecs for both encoding the arguments of the runtime call, and the codec for decoding the result + +```ts +interface RuntimeEntry { + args: Codec + value: Codec +} +``` + +## getChecksumBuilder + +```ts +function getChecksumBuilder(metadataLookup: MetadataLookup): { + buildDefinition: (id: number) => string | null + buildRuntimeCall: (api: string, method: string) => string | null + buildStorage: (pallet: string, entry: string) => string | null + buildCall: (pallet: string, name: string) => string | null + buildEvent: (pallet: string, name: string) => string | null + buildError: (pallet: string, name: string) => string | null + buildConstant: (pallet: string, constantName: string) => string | null +} +``` + +Generates the checksums for the different components defined in the metadata. + +`buildDefinition` builds the checksum of one of the types in the lookup. The rest of the methods build the checksum for each of the interfaces of the chain. diff --git a/packages/metadata-builders/dist/esm/checksum-builder.mjs b/packages/metadata-builders/dist/esm/checksum-builder.mjs new file mode 100644 index 0000000..e661fb9 --- /dev/null +++ b/packages/metadata-builders/dist/esm/checksum-builder.mjs @@ -0,0 +1,370 @@ +import { h64 } from '@pezkuwi/bizinikiwi-bindings'; +import { buildLookupGraph, getSubgraph, getStronglyConnectedComponents, mergeSCCsWithCommonNodes } from './lookup-graph.mjs'; + +const textEncoder = new TextEncoder(); +const encodeText = textEncoder.encode.bind(textEncoder); +const getChecksum = (values) => { + const res = new Uint8Array(values.length * 8); + const dv = new DataView(res.buffer); + for (let i = 0; i < values.length; i++) dv.setBigUint64(i * 8, values[i]); + return h64(res); +}; +const getStringChecksum = (values) => getChecksum(values.map((v) => h64(encodeText(v)))); +const shapeIds = { + primitive: 0n, + vector: 1n, + tuple: 2n, + struct: 3n, + option: 4n, + result: 5n, + enum: 6n, + void: 7n +}; +const runtimePrimitiveIds = { + undefined: 0n, + number: 1n, + string: 2n, + bigint: 3n, + boolean: 4n, + bitSequence: 5n, + // {bitsLen: number, bytes: Uint8Array} + byteSequence: 6n, + // Binary + accountId32: 7n, + // SS58String + accountId20: 8n + // EthAccount +}; +const metadataPrimitiveIds = { + bool: runtimePrimitiveIds.boolean, + char: runtimePrimitiveIds.string, + str: runtimePrimitiveIds.string, + u8: runtimePrimitiveIds.number, + u16: runtimePrimitiveIds.number, + u32: runtimePrimitiveIds.number, + u64: runtimePrimitiveIds.bigint, + u128: runtimePrimitiveIds.bigint, + u256: runtimePrimitiveIds.bigint, + i8: runtimePrimitiveIds.number, + i16: runtimePrimitiveIds.number, + i32: runtimePrimitiveIds.number, + i64: runtimePrimitiveIds.bigint, + i128: runtimePrimitiveIds.bigint, + i256: runtimePrimitiveIds.bigint +}; +const structLikeBuilder = (shapeId, input, innerChecksum) => { + const sortedEntries = Object.entries(input).sort( + ([a], [b]) => a.localeCompare(b) + ); + const keysChecksum = getStringChecksum(sortedEntries.map(([key]) => key)); + const valuesChecksum = getChecksum( + sortedEntries.map(([, entry]) => innerChecksum(entry)) + ); + return getChecksum([shapeId, keysChecksum, valuesChecksum]); +}; +const _buildChecksum = (input, buildNextChecksum) => { + if (input.type === "primitive") + return getChecksum([shapeIds.primitive, metadataPrimitiveIds[input.value]]); + if (input.type === "void") return getChecksum([shapeIds.void]); + if (input.type === "compact") + return getChecksum([ + shapeIds.primitive, + runtimePrimitiveIds[input.isBig ? "bigint" : "number"] + ]); + if (input.type === "bitSequence") + return getChecksum([shapeIds.primitive, runtimePrimitiveIds.bitSequence]); + if (input.type === "AccountId32") { + return getChecksum([shapeIds.primitive, runtimePrimitiveIds.accountId32]); + } + if (input.type === "AccountId20") { + return getChecksum([shapeIds.primitive, runtimePrimitiveIds.accountId20]); + } + const buildVector = (entry, length) => { + const innerChecksum = buildNextChecksum(entry); + return getChecksum( + length !== void 0 ? [shapeIds.vector, innerChecksum, BigInt(length)] : [shapeIds.vector, innerChecksum] + ); + }; + if (input.type === "array") { + const innerValue = input.value; + if (innerValue.type === "primitive" && innerValue.value === "u8") { + return getChecksum([ + shapeIds.primitive, + runtimePrimitiveIds.byteSequence, + BigInt(input.len) + ]); + } + return buildVector(innerValue, input.len); + } + if (input.type === "sequence") { + const innerValue = input.value; + if (innerValue.type === "primitive" && innerValue.value === "u8") { + return getChecksum([shapeIds.primitive, runtimePrimitiveIds.byteSequence]); + } + return buildVector(innerValue); + } + const buildTuple = (entries) => getChecksum([shapeIds.tuple, ...entries.map(buildNextChecksum)]); + const buildStruct = (entries) => structLikeBuilder(shapeIds.struct, entries, buildNextChecksum); + if (input.type === "tuple") return buildTuple(input.value); + if (input.type === "struct") return buildStruct(input.value); + if (input.type === "option") + return getChecksum([shapeIds.option, buildNextChecksum(input.value)]); + if (input.type === "result") + return getChecksum([ + shapeIds.result, + buildNextChecksum(input.value.ok), + buildNextChecksum(input.value.ko) + ]); + return structLikeBuilder(shapeIds.enum, input.value, (entry) => { + if (entry.type === "lookupEntry") return buildNextChecksum(entry.value); + switch (entry.type) { + case "void": + return getChecksum([shapeIds.void]); + case "tuple": + return buildTuple(entry.value); + case "struct": + return buildStruct(entry.value); + case "array": + return buildVector(entry.value, entry.len); + } + }); +}; +const sortCyclicGroups = (groups, graph) => { + const getReachableNodes = (group) => { + const result2 = /* @__PURE__ */ new Set(); + const toVisit = Array.from(group); + while (toVisit.length) { + const id = toVisit.pop(); + if (result2.has(id)) continue; + result2.add(id); + graph.get(id)?.refs.forEach((id2) => toVisit.push(id2)); + } + return Array.from(result2); + }; + const result = new Array(); + function dependentsFirst(group) { + if (result.includes(group)) return; + const dependents = groups.filter( + (candidate) => candidate !== group && getReachableNodes(group).some((node) => candidate.has(node)) + ); + dependents.forEach((group2) => dependentsFirst(group2)); + if (result.includes(group)) return; + result.push(group); + } + groups.forEach((group) => dependentsFirst(group)); + return result; +}; +function iterateChecksums(group, iterations, cache, graph) { + const groupReadCache = new Map([...group].map((id) => [id, 0n])); + const groupWriteCache = /* @__PURE__ */ new Map(); + const recursiveBuildChecksum = (entry, skipCache = true) => { + if (!skipCache && (groupReadCache.has(entry.id) || cache.has(entry.id))) { + return groupReadCache.get(entry.id) ?? cache.get(entry.id); + } + const result = _buildChecksum( + entry, + (nextEntry) => recursiveBuildChecksum(nextEntry, false) + ); + if (group.has(entry.id)) { + groupWriteCache.set(entry.id, result); + } else { + cache.set(entry.id, result); + } + return result; + }; + for (let i = 0; i < iterations; i++) { + group.forEach((id) => recursiveBuildChecksum(graph.get(id).entry)); + group.forEach((id) => groupReadCache.set(id, groupWriteCache.get(id))); + } + return groupReadCache; +} +function getMirroredNodes(cyclicGroups, graph) { + const maxSize = cyclicGroups.reduce( + (acc, group) => Math.max(acc, group.size), + 0 + ); + const allEntries = new Set([...graph.values()].map((v) => v.entry.id)); + const resultingChecksums = iterateChecksums( + allEntries, + maxSize, + // Cache won't be used, since it's using the internal one for every node. + /* @__PURE__ */ new Map(), + graph + ); + const checksumToNodes = /* @__PURE__ */ new Map(); + for (const id of allEntries) { + const checksum = resultingChecksums.get(id); + if (checksum == void 0) throw new Error("Unreachable"); + if (!checksumToNodes.has(checksum)) { + checksumToNodes.set(checksum, []); + } + checksumToNodes.get(checksum).push(id); + } + const checksumsWithDuplicates = [...checksumToNodes.entries()].filter( + ([, nodes]) => nodes.length > 1 + ); + const duplicatesMap = {}; + checksumsWithDuplicates.forEach(([, nodes]) => { + nodes.forEach((n) => duplicatesMap[n] = nodes); + }); + return duplicatesMap; +} +const buildChecksum = (entry, cache, graph) => { + if (cache.has(entry.id)) return cache.get(entry.id); + const subGraph = getSubgraph(entry.id, graph); + const cycles = getStronglyConnectedComponents(subGraph).filter( + // SCCs can be of length=1, but for those we're only interested with those that are circular with themselves + (group) => group.size > 1 || isSelfCircular(group, subGraph) + ); + const cyclicGroups = mergeSCCsWithCommonNodes(cycles).filter((group) => { + return !cache.has(group.values().next().value); + }); + const mirrored = getMirroredNodes(cyclicGroups, subGraph); + const sortedCyclicGroups = sortCyclicGroups(cyclicGroups, subGraph); + sortedCyclicGroups.forEach((group) => { + if (cache.has(group.values().next().value)) { + return; + } + const result = iterateChecksums(group, group.size, cache, graph); + group.forEach((id) => { + const checksum = result.get(id); + if (id in mirrored) { + mirrored[id].forEach((id2) => cache.set(id2, checksum)); + } else { + cache.set(id, checksum); + } + }); + }); + const getChecksum2 = (entry2) => { + if (cache.has(entry2.id)) return cache.get(entry2.id); + return _buildChecksum(entry2, getChecksum2); + }; + return getChecksum2(entry); +}; +const isSelfCircular = (group, graph) => { + if (group.size !== 1) return false; + const [id] = group; + return graph.get(id).refs.has(id); +}; +const getChecksumBuilder = (getLookupEntryDef) => { + const { metadata } = getLookupEntryDef; + const graph = buildLookupGraph(getLookupEntryDef, metadata.lookup.length); + const cache = /* @__PURE__ */ new Map(); + const buildDefinition = (id) => buildChecksum(getLookupEntryDef(id), cache, graph); + const buildStorage = (pallet, entry) => { + try { + const storageEntry = metadata.pallets.find((x) => x.name === pallet).storage.items.find((s) => s.name === entry); + if (storageEntry.type.tag === "plain") + return buildDefinition(storageEntry.type.value); + const { key, value } = storageEntry.type.value; + const val = buildDefinition(value); + const returnKey = buildDefinition(key); + return getChecksum([val, returnKey]); + } catch (_) { + return null; + } + }; + const buildViewFns = (pallet, entry) => { + try { + const viewFn = metadata.pallets.find((x) => x.name === pallet)?.viewFns.find((x) => x.name === entry); + if (!viewFn) throw null; + const argNamesChecksum = getStringChecksum( + viewFn.inputs.map((x) => x.name) + ); + const argValuesChecksum = getChecksum( + viewFn.inputs.map((x) => buildDefinition(x.type)) + ); + const outputChecksum = buildDefinition(viewFn.output); + return getChecksum([argNamesChecksum, argValuesChecksum, outputChecksum]); + } catch (_) { + return null; + } + }; + const buildRuntimeCall = (api, method) => { + try { + const entry = metadata.apis.find((x) => x.name === api)?.methods.find((x) => x.name === method); + if (!entry) throw null; + const argNamesChecksum = getStringChecksum( + entry.inputs.map((x) => x.name) + ); + const argValuesChecksum = getChecksum( + entry.inputs.map((x) => buildDefinition(x.type)) + ); + const outputChecksum = buildDefinition(entry.output); + return getChecksum([argNamesChecksum, argValuesChecksum, outputChecksum]); + } catch (_) { + return null; + } + }; + const buildComposite = (input) => { + if (input.type === "void") return getChecksum([0n]); + if (input.type === "tuple") { + const values = Object.values(input.value).map( + (entry) => buildDefinition(entry.id) + ); + return getChecksum([shapeIds.tuple, ...values]); + } + if (input.type === "array") { + return getChecksum([ + shapeIds.vector, + buildDefinition(input.value.id), + BigInt(input.len) + ]); + } + return structLikeBuilder( + shapeIds.struct, + input.value, + (entry) => buildDefinition(entry.id) + ); + }; + const buildNamedTuple = (input) => { + return structLikeBuilder( + shapeIds.tuple, + input.value, + (entry) => buildDefinition(entry.id) + ); + }; + const variantShapeId = { + errors: 1n, + events: 2n, + calls: 3n + }; + const buildVariant = (variantType) => (pallet, name) => { + try { + const palletEntry = metadata.pallets.find((x) => x.name === pallet); + const enumLookup = getLookupEntryDef(palletEntry[variantType].type); + buildDefinition(enumLookup.id); + if (enumLookup.type !== "enum") throw null; + const entry = enumLookup.value[name]; + const valueChecksum = entry.type === "lookupEntry" ? buildDefinition(entry.value.id) : buildComposite(entry); + return getChecksum([variantShapeId[variantType], valueChecksum]); + } catch (_) { + return null; + } + }; + const buildConstant = (pallet, constantName) => { + try { + const storageEntry = metadata.pallets.find((x) => x.name === pallet).constants.find((s) => s.name === constantName); + return buildDefinition(storageEntry.type); + } catch (_) { + return null; + } + }; + const toStringEnhancer = (fn) => (...args) => fn(...args)?.toString(32) ?? null; + return { + buildDefinition: toStringEnhancer(buildDefinition), + buildRuntimeCall: toStringEnhancer(buildRuntimeCall), + buildStorage: toStringEnhancer(buildStorage), + buildViewFns: toStringEnhancer(buildViewFns), + buildCall: toStringEnhancer(buildVariant("calls")), + buildEvent: toStringEnhancer(buildVariant("events")), + buildError: toStringEnhancer(buildVariant("errors")), + buildConstant: toStringEnhancer(buildConstant), + buildComposite: toStringEnhancer(buildComposite), + buildNamedTuple: toStringEnhancer(buildNamedTuple), + getAllGeneratedChecksums: () => Array.from(cache.values()).map((v) => v.toString(32)) + }; +}; + +export { getChecksumBuilder }; +//# sourceMappingURL=checksum-builder.mjs.map diff --git a/packages/metadata-builders/dist/esm/checksum-builder.mjs.map b/packages/metadata-builders/dist/esm/checksum-builder.mjs.map new file mode 100644 index 0000000..d00b504 --- /dev/null +++ b/packages/metadata-builders/dist/esm/checksum-builder.mjs.map @@ -0,0 +1 @@ +{"version":3,"file":"checksum-builder.mjs","sources":["../../src/checksum-builder.ts"],"sourcesContent":["import type { StringRecord } from \"@pezkuwi/bizinikiwi-bindings\"\nimport { h64 } from \"@pezkuwi/bizinikiwi-bindings\"\nimport {\n LookupGraph,\n buildLookupGraph,\n getStronglyConnectedComponents,\n getSubgraph,\n mergeSCCsWithCommonNodes,\n} from \"./lookup-graph\"\nimport {\n ArrayVar,\n LookupEntry,\n MetadataLookup,\n MetadataPrimitives,\n StructVar,\n TupleVar,\n VoidVar,\n} from \"./lookups\"\n\nconst textEncoder = new TextEncoder()\nconst encodeText = textEncoder.encode.bind(textEncoder)\n\nconst getChecksum = (values: Array) => {\n const res = new Uint8Array(values.length * 8)\n const dv = new DataView(res.buffer)\n\n for (let i = 0; i < values.length; i++) dv.setBigUint64(i * 8, values[i])\n\n return h64(res)\n}\nconst getStringChecksum = (values: Array) =>\n getChecksum(values.map((v) => h64(encodeText(v))))\n\ntype Shape =\n | \"primitive\"\n | \"void\"\n | \"vector\"\n | \"tuple\"\n | \"struct\"\n | \"option\"\n | \"result\"\n | \"enum\"\nconst shapeIds: Record = {\n primitive: 0n,\n vector: 1n,\n tuple: 2n,\n struct: 3n,\n option: 4n,\n result: 5n,\n enum: 6n,\n void: 7n,\n}\n\ntype RuntimePrimitives =\n | \"undefined\"\n | \"number\"\n | \"string\"\n | \"bigint\"\n | \"boolean\"\n | \"bitSequence\"\n | \"byteSequence\"\n | \"accountId32\"\n | \"accountId20\"\n\nconst runtimePrimitiveIds: Record = {\n undefined: 0n,\n number: 1n,\n string: 2n,\n bigint: 3n,\n boolean: 4n,\n bitSequence: 5n, // {bitsLen: number, bytes: Uint8Array}\n byteSequence: 6n, // Binary\n accountId32: 7n, // SS58String\n accountId20: 8n, // EthAccount\n}\n\nconst metadataPrimitiveIds: Record = {\n bool: runtimePrimitiveIds.boolean,\n char: runtimePrimitiveIds.string,\n str: runtimePrimitiveIds.string,\n u8: runtimePrimitiveIds.number,\n u16: runtimePrimitiveIds.number,\n u32: runtimePrimitiveIds.number,\n u64: runtimePrimitiveIds.bigint,\n u128: runtimePrimitiveIds.bigint,\n u256: runtimePrimitiveIds.bigint,\n i8: runtimePrimitiveIds.number,\n i16: runtimePrimitiveIds.number,\n i32: runtimePrimitiveIds.number,\n i64: runtimePrimitiveIds.bigint,\n i128: runtimePrimitiveIds.bigint,\n i256: runtimePrimitiveIds.bigint,\n}\n\nconst structLikeBuilder = (\n shapeId: bigint,\n input: StringRecord,\n innerChecksum: (value: T) => bigint,\n) => {\n const sortedEntries = Object.entries(input).sort(([a], [b]) =>\n a.localeCompare(b),\n )\n const keysChecksum = getStringChecksum(sortedEntries.map(([key]) => key))\n const valuesChecksum = getChecksum(\n sortedEntries.map(([, entry]) => innerChecksum(entry)),\n )\n\n return getChecksum([shapeId, keysChecksum, valuesChecksum])\n}\n\nconst _buildChecksum = (\n input: LookupEntry,\n buildNextChecksum: (entry: LookupEntry) => bigint,\n): bigint => {\n if (input.type === \"primitive\")\n return getChecksum([shapeIds.primitive, metadataPrimitiveIds[input.value]])\n\n if (input.type === \"void\") return getChecksum([shapeIds.void])\n\n if (input.type === \"compact\")\n return getChecksum([\n shapeIds.primitive,\n runtimePrimitiveIds[input.isBig ? \"bigint\" : \"number\"],\n ])\n\n if (input.type === \"bitSequence\")\n return getChecksum([shapeIds.primitive, runtimePrimitiveIds.bitSequence])\n\n if (input.type === \"AccountId32\") {\n return getChecksum([shapeIds.primitive, runtimePrimitiveIds.accountId32])\n }\n\n if (input.type === \"AccountId20\") {\n return getChecksum([shapeIds.primitive, runtimePrimitiveIds.accountId20])\n }\n\n const buildVector = (entry: LookupEntry, length?: number) => {\n const innerChecksum = buildNextChecksum(entry)\n return getChecksum(\n length !== undefined\n ? [shapeIds.vector, innerChecksum, BigInt(length)]\n : [shapeIds.vector, innerChecksum],\n )\n }\n\n if (input.type === \"array\") {\n const innerValue = input.value\n if (innerValue.type === \"primitive\" && innerValue.value === \"u8\") {\n return getChecksum([\n shapeIds.primitive,\n runtimePrimitiveIds.byteSequence,\n BigInt(input.len),\n ])\n }\n return buildVector(innerValue, input.len)\n }\n\n if (input.type === \"sequence\") {\n const innerValue = input.value\n if (innerValue.type === \"primitive\" && innerValue.value === \"u8\") {\n return getChecksum([shapeIds.primitive, runtimePrimitiveIds.byteSequence])\n }\n return buildVector(innerValue)\n }\n\n const buildTuple = (entries: LookupEntry[]) =>\n getChecksum([shapeIds.tuple, ...entries.map(buildNextChecksum)])\n\n const buildStruct = (entries: StringRecord) =>\n structLikeBuilder(shapeIds.struct, entries, buildNextChecksum)\n\n if (input.type === \"tuple\") return buildTuple(input.value)\n\n if (input.type === \"struct\") return buildStruct(input.value)\n\n if (input.type === \"option\")\n return getChecksum([shapeIds.option, buildNextChecksum(input.value)])\n\n if (input.type === \"result\")\n return getChecksum([\n shapeIds.result,\n buildNextChecksum(input.value.ok),\n buildNextChecksum(input.value.ko),\n ])\n\n return structLikeBuilder(shapeIds.enum, input.value, (entry) => {\n if (entry.type === \"lookupEntry\") return buildNextChecksum(entry.value)\n switch (entry.type) {\n case \"void\":\n return getChecksum([shapeIds.void])\n case \"tuple\":\n return buildTuple(entry.value)\n case \"struct\":\n return buildStruct(entry.value)\n case \"array\":\n return buildVector(entry.value, entry.len)\n }\n })\n}\n\nconst sortCyclicGroups = (groups: Array>, graph: LookupGraph) => {\n const getReachableNodes = (group: Set) => {\n const result = new Set()\n const toVisit = Array.from(group)\n while (toVisit.length) {\n const id = toVisit.pop()!\n if (result.has(id)) continue\n result.add(id)\n\n graph.get(id)?.refs.forEach((id) => toVisit.push(id))\n }\n\n return Array.from(result)\n }\n\n const result: Array> = new Array()\n\n function dependentsFirst(group: Set) {\n if (result.includes(group)) return\n const dependents = groups.filter(\n (candidate) =>\n candidate !== group &&\n getReachableNodes(group).some((node) => candidate.has(node)),\n )\n dependents.forEach((group) => dependentsFirst(group))\n if (result.includes(group)) return\n result.push(group)\n }\n\n groups.forEach((group) => dependentsFirst(group))\n return result\n}\n\nfunction iterateChecksums(\n group: Set,\n iterations: number,\n cache: Map,\n graph: LookupGraph,\n) {\n // Keep the values that are getting changed on each iteration in a separate\n // cache, because two nodes referencing the same one should read the same\n // previous iteration checksum for that node.\n const groupReadCache = new Map([...group].map((id) => [id, 0n]))\n const groupWriteCache = new Map()\n\n const recursiveBuildChecksum = (\n entry: LookupEntry,\n // The first call has to skip the cache, otherwise it would return the\n // previous iteration result.\n skipCache = true,\n ): bigint => {\n if (!skipCache && (groupReadCache.has(entry.id) || cache.has(entry.id))) {\n return groupReadCache.get(entry.id) ?? cache.get(entry.id)!\n }\n const result = _buildChecksum(entry, (nextEntry) =>\n recursiveBuildChecksum(nextEntry, false),\n )\n if (group.has(entry.id)) {\n groupWriteCache.set(entry.id, result)\n } else {\n cache.set(entry.id, result)\n }\n return result\n }\n\n for (let i = 0; i < iterations; i++) {\n group.forEach((id) => recursiveBuildChecksum(graph.get(id)!.entry))\n\n group.forEach((id) => groupReadCache.set(id, groupWriteCache.get(id)!))\n }\n\n return groupReadCache\n}\n\nfunction getMirroredNodes(\n cyclicGroups: Array>,\n graph: LookupGraph,\n) {\n const maxSize = cyclicGroups.reduce(\n (acc, group) => Math.max(acc, group.size),\n 0,\n )\n const allEntries = new Set([...graph.values()].map((v) => v.entry.id))\n\n const resultingChecksums = iterateChecksums(\n allEntries,\n maxSize,\n // Cache won't be used, since it's using the internal one for every node.\n new Map(),\n graph,\n )\n\n const checksumToNodes = new Map()\n for (const id of allEntries) {\n const checksum = resultingChecksums.get(id)\n if (checksum == undefined) throw new Error(\"Unreachable\")\n if (!checksumToNodes.has(checksum)) {\n checksumToNodes.set(checksum, [])\n }\n checksumToNodes.get(checksum)!.push(id)\n }\n\n const checksumsWithDuplicates = [...checksumToNodes.entries()].filter(\n ([, nodes]) => nodes.length > 1,\n )\n\n const duplicatesMap: Record = {}\n checksumsWithDuplicates.forEach(([, nodes]) => {\n nodes.forEach((n) => (duplicatesMap[n] = nodes))\n })\n\n return duplicatesMap\n}\n\nconst buildChecksum = (\n entry: LookupEntry,\n cache: Map,\n graph: LookupGraph,\n) => {\n if (cache.has(entry.id)) return cache.get(entry.id)!\n\n const subGraph = getSubgraph(entry.id, graph)\n\n const cycles = getStronglyConnectedComponents(subGraph).filter(\n // SCCs can be of length=1, but for those we're only interested with those that are circular with themselves\n (group) => group.size > 1 || isSelfCircular(group, subGraph),\n )\n const cyclicGroups = mergeSCCsWithCommonNodes(cycles).filter((group) => {\n // Exclude groups that were previously calculated\n return !cache.has(group.values().next().value!)\n })\n const mirrored = getMirroredNodes(cyclicGroups, subGraph)\n const sortedCyclicGroups = sortCyclicGroups(cyclicGroups, subGraph)\n\n sortedCyclicGroups.forEach((group) => {\n if (cache.has(group.values().next().value!)) {\n // exclude mirrored groups\n return\n }\n\n const result = iterateChecksums(group, group.size, cache, graph)\n group.forEach((id) => {\n const checksum = result.get(id)!\n if (id in mirrored) {\n mirrored[id].forEach((id) => cache.set(id, checksum))\n } else {\n cache.set(id, checksum)\n }\n })\n })\n\n const getChecksum = (entry: LookupEntry) => {\n if (cache.has(entry.id)) return cache.get(entry.id)!\n return _buildChecksum(entry, getChecksum)\n }\n\n return getChecksum(entry)\n}\n\nconst isSelfCircular = (group: Set, graph: LookupGraph) => {\n if (group.size !== 1) return false\n const [id] = group\n\n return graph.get(id)!.refs.has(id)\n}\n\nexport const getChecksumBuilder = (getLookupEntryDef: MetadataLookup) => {\n const { metadata } = getLookupEntryDef\n const graph = buildLookupGraph(getLookupEntryDef, metadata.lookup.length)\n\n const cache = new Map()\n\n const buildDefinition = (id: number): bigint =>\n buildChecksum(getLookupEntryDef(id), cache, graph)\n\n const buildStorage = (pallet: string, entry: string): bigint | null => {\n try {\n const storageEntry = metadata.pallets\n .find((x) => x.name === pallet)!\n .storage!.items.find((s) => s.name === entry)!\n\n if (storageEntry.type.tag === \"plain\")\n return buildDefinition(storageEntry.type.value)\n\n const { key, value } = storageEntry.type.value\n const val = buildDefinition(value)\n const returnKey = buildDefinition(key)\n return getChecksum([val, returnKey])\n } catch (_) {\n return null\n }\n }\n\n const buildViewFns = (pallet: string, entry: string): bigint | null => {\n try {\n const viewFn = metadata.pallets\n .find((x) => x.name === pallet)\n ?.viewFns.find((x) => x.name === entry)\n if (!viewFn) throw null\n\n const argNamesChecksum = getStringChecksum(\n viewFn.inputs.map((x) => x.name),\n )\n const argValuesChecksum = getChecksum(\n viewFn.inputs.map((x) => buildDefinition(x.type)),\n )\n const outputChecksum = buildDefinition(viewFn.output)\n\n return getChecksum([argNamesChecksum, argValuesChecksum, outputChecksum])\n } catch (_) {\n return null\n }\n }\n\n const buildRuntimeCall = (api: string, method: string): bigint | null => {\n try {\n const entry = metadata.apis\n .find((x) => x.name === api)\n ?.methods.find((x) => x.name === method)\n if (!entry) throw null\n\n const argNamesChecksum = getStringChecksum(\n entry.inputs.map((x) => x.name),\n )\n const argValuesChecksum = getChecksum(\n entry.inputs.map((x) => buildDefinition(x.type)),\n )\n const outputChecksum = buildDefinition(entry.output)\n\n return getChecksum([argNamesChecksum, argValuesChecksum, outputChecksum])\n } catch (_) {\n return null\n }\n }\n\n const buildComposite = (\n input: TupleVar | StructVar | VoidVar | ArrayVar,\n ): bigint => {\n if (input.type === \"void\") return getChecksum([0n])\n\n if (input.type === \"tuple\") {\n const values = Object.values(input.value).map((entry) =>\n buildDefinition(entry.id),\n )\n\n return getChecksum([shapeIds.tuple, ...values])\n }\n\n if (input.type === \"array\") {\n return getChecksum([\n shapeIds.vector,\n buildDefinition(input.value.id),\n BigInt(input.len),\n ])\n }\n\n // Otherwise struct\n return structLikeBuilder(shapeIds.struct, input.value, (entry) =>\n buildDefinition(entry.id),\n )\n }\n\n const buildNamedTuple = (input: StructVar): bigint => {\n return structLikeBuilder(shapeIds.tuple, input.value, (entry) =>\n buildDefinition(entry.id),\n )\n }\n\n const variantShapeId = {\n errors: 1n,\n events: 2n,\n calls: 3n,\n }\n const buildVariant =\n (variantType: \"errors\" | \"events\" | \"calls\") =>\n (pallet: string, name: string): bigint | null => {\n try {\n const palletEntry = metadata.pallets.find((x) => x.name === pallet)!\n const enumLookup = getLookupEntryDef(palletEntry[variantType]!.type)\n buildDefinition(enumLookup.id)\n\n if (enumLookup.type !== \"enum\") throw null\n const entry = enumLookup.value[name]\n const valueChecksum =\n entry.type === \"lookupEntry\"\n ? buildDefinition(entry.value.id)\n : buildComposite(entry)\n return getChecksum([variantShapeId[variantType], valueChecksum])\n } catch (_) {\n return null\n }\n }\n\n const buildConstant = (\n pallet: string,\n constantName: string,\n ): bigint | null => {\n try {\n const storageEntry = metadata.pallets\n .find((x) => x.name === pallet)!\n .constants!.find((s) => s.name === constantName)!\n\n return buildDefinition(storageEntry.type)\n } catch (_) {\n return null\n }\n }\n\n const toStringEnhancer =\n >(\n fn: (...args: Args) => bigint | null,\n ): ((...args: Args) => string | null) =>\n (...args) =>\n fn(...args)?.toString(32) ?? null\n\n return {\n buildDefinition: toStringEnhancer(buildDefinition),\n buildRuntimeCall: toStringEnhancer(buildRuntimeCall),\n buildStorage: toStringEnhancer(buildStorage),\n buildViewFns: toStringEnhancer(buildViewFns),\n buildCall: toStringEnhancer(buildVariant(\"calls\")),\n buildEvent: toStringEnhancer(buildVariant(\"events\")),\n buildError: toStringEnhancer(buildVariant(\"errors\")),\n buildConstant: toStringEnhancer(buildConstant),\n buildComposite: toStringEnhancer(buildComposite),\n buildNamedTuple: toStringEnhancer(buildNamedTuple),\n getAllGeneratedChecksums: () =>\n Array.from(cache.values()).map((v) => v.toString(32)),\n }\n}\n"],"names":["result","id","group","getChecksum","entry"],"mappings":"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"} \ No newline at end of file diff --git a/packages/metadata-builders/dist/esm/dynamic-builder.mjs b/packages/metadata-builders/dist/esm/dynamic-builder.mjs new file mode 100644 index 0000000..5546ae5 --- /dev/null +++ b/packages/metadata-builders/dist/esm/dynamic-builder.mjs @@ -0,0 +1,136 @@ +import * as scale from '@pezkuwi/bizinikiwi-bindings'; +import { mapObject } from '@pezkuwi/papi-utils'; +import { getLookupCodecBuilder } from './lookup-codec-builder.mjs'; + +const nullCodec = scale.enhanceCodec( + scale._void, + () => void 0, + () => null +); +const getDynamicBuilder = (getLookupEntryDef) => { + const { metadata } = getLookupEntryDef; + let buildDefinition = getLookupCodecBuilder(getLookupEntryDef); + const prefix = metadata.pallets.find((x) => x.name === "System")?.constants.find((x) => x.name === "SS58Prefix"); + let ss58Prefix; + if (prefix) { + try { + const prefixVal = buildDefinition(prefix.type).dec(prefix.value); + if (typeof prefixVal === "number") { + ss58Prefix = prefixVal; + buildDefinition = getLookupCodecBuilder( + getLookupEntryDef, + scale.AccountId(prefixVal) + ); + } + } catch (_) { + } + } + const storagePallets = /* @__PURE__ */ new Map(); + const buildStorage = (pallet, entry) => { + let storagePallet = storagePallets.get(pallet); + if (!storagePallet) + storagePallets.set(pallet, storagePallet = scale.Storage(pallet)); + const storageEntry = metadata.pallets.find((x) => x.name === pallet).storage.items.find((s) => s.name === entry); + const withNullVoid = (codec) => codec === scale._void ? nullCodec : codec; + const storageWithFallback = (len, value2, ...args) => { + const keys = storagePallet(...args); + const [, ...encodersWithHash] = args; + return { + args: scale.Tuple(...encodersWithHash.map(([codec]) => codec)), + keys, + value: value2, + len, + fallback: storageEntry.modifier === 1 ? value2.dec(storageEntry.fallback) : void 0 + }; + }; + if (storageEntry.type.tag === "plain") + return storageWithFallback( + 0, + withNullVoid(buildDefinition(storageEntry.type.value)), + entry + ); + const { key, value, hashers } = storageEntry.type.value; + const val = withNullVoid(buildDefinition(value)); + const hashes = hashers.map((x) => scale[x.tag]); + const hashArgs = (() => { + if (hashes.length === 1) { + return [[buildDefinition(key), hashes[0]]]; + } + const keyDef = getLookupEntryDef(key); + switch (keyDef.type) { + case "array": + return hashes.map((hash) => [buildDefinition(keyDef.value.id), hash]); + case "tuple": + return keyDef.value.map((x, idx) => [ + buildDefinition(x.id), + hashes[idx] + ]); + default: + throw new Error("Invalid key type"); + } + })(); + return storageWithFallback(hashes.length, val, entry, ...hashArgs); + }; + const buildEnumEntry = (entry) => { + switch (entry.type) { + case "void": + return scale._void; + case "lookupEntry": + return buildDefinition(entry.value.id); + case "tuple": + return scale.Tuple( + ...Object.values(entry.value).map((l) => buildDefinition(l.id)) + ); + case "struct": + return scale.Struct( + mapObject(entry.value, (x) => buildDefinition(x.id)) + ); + case "array": + return scale.Vector(buildDefinition(entry.value.id), entry.len); + } + }; + const buildConstant = (pallet, constantName) => { + const storageEntry = metadata.pallets.find((x) => x.name === pallet).constants.find((s) => s.name === constantName); + return buildDefinition(storageEntry.type); + }; + const buildVariant = (type) => (pallet, name) => { + const palletEntry = metadata.pallets.find((x) => x.name === pallet); + const lookup = getLookupEntryDef(palletEntry[type].type); + if (lookup.type !== "enum") throw null; + const entry = lookup.value[name]; + return { + location: [palletEntry.index, entry.idx], + codec: buildEnumEntry(lookup.value[name]) + }; + }; + const buildViewFn = (pallet, entry) => { + const fn = metadata.pallets.find((x) => x.name === pallet)?.viewFns.find((x) => x.name === entry); + if (!fn) throw null; + return { + args: scale.Tuple(...fn.inputs.map((x) => buildDefinition(x.type))), + value: buildDefinition(fn.output) + }; + }; + const buildRuntimeCall = (api, method) => { + const entry = metadata.apis.find((x) => x.name === api)?.methods.find((x) => x.name === method); + if (!entry) throw null; + return { + args: scale.Tuple(...entry.inputs.map((x) => buildDefinition(x.type))), + value: buildDefinition(entry.output) + }; + }; + return { + buildDefinition, + buildStorage, + buildEvent: buildVariant("events"), + buildError: buildVariant("errors"), + buildViewFn, + buildRuntimeCall, + buildCall: buildVariant("calls"), + buildConstant, + ss58Prefix + }; +}; + +export { getDynamicBuilder }; +//# sourceMappingURL=dynamic-builder.mjs.map diff --git a/packages/metadata-builders/dist/esm/dynamic-builder.mjs.map b/packages/metadata-builders/dist/esm/dynamic-builder.mjs.map new file mode 100644 index 0000000..719049a --- /dev/null +++ b/packages/metadata-builders/dist/esm/dynamic-builder.mjs.map @@ -0,0 +1 @@ +{"version":3,"file":"dynamic-builder.mjs","sources":["../../src/dynamic-builder.ts"],"sourcesContent":["import type { Codec, StringRecord } from \"@pezkuwi/bizinikiwi-bindings\"\nimport * as scale from \"@pezkuwi/bizinikiwi-bindings\"\nimport { mapObject } from \"@pezkuwi/papi-utils\"\nimport type { EnumVar, MetadataLookup } from \"./lookups\"\nimport { getLookupCodecBuilder } from \"./lookup-codec-builder\"\n\nconst nullCodec = scale.enhanceCodec(\n scale._void,\n () => undefined,\n () => null,\n)\n\nexport const getDynamicBuilder = (getLookupEntryDef: MetadataLookup) => {\n const { metadata } = getLookupEntryDef\n let buildDefinition = getLookupCodecBuilder(getLookupEntryDef)\n\n const prefix = metadata.pallets\n .find((x) => x.name === \"System\")\n ?.constants.find((x) => x.name === \"SS58Prefix\")\n\n let ss58Prefix: number | undefined\n if (prefix) {\n try {\n const prefixVal = buildDefinition(prefix.type).dec(prefix.value)\n if (typeof prefixVal === \"number\") {\n ss58Prefix = prefixVal\n buildDefinition = getLookupCodecBuilder(\n getLookupEntryDef,\n scale.AccountId(prefixVal),\n )\n }\n } catch (_) {}\n }\n\n const storagePallets = new Map>()\n\n const buildStorage = (pallet: string, entry: string) => {\n let storagePallet = storagePallets.get(pallet)\n if (!storagePallet)\n storagePallets.set(pallet, (storagePallet = scale.Storage(pallet)))\n\n const storageEntry = metadata.pallets\n .find((x) => x.name === pallet)!\n .storage!.items.find((s) => s.name === entry)!\n\n // if val is `void` it decodes to `undefined`, making it impossible\n // to differentiate from a non-existant key\n // therefore, if the key exists => null, if it doesn't => undefined\n const withNullVoid = (codec: Codec) =>\n codec === scale._void ? nullCodec : codec\n\n const storageWithFallback = (\n len: number,\n value: Codec,\n ...args: Parameters>\n ) => {\n const keys = storagePallet!(...args)\n const [, ...encodersWithHash] = args\n return {\n args: scale.Tuple(...encodersWithHash.map(([codec]) => codec)),\n keys,\n value,\n len,\n fallback:\n storageEntry.modifier === 1\n ? value.dec(storageEntry.fallback)\n : undefined,\n }\n }\n\n if (storageEntry.type.tag === \"plain\")\n return storageWithFallback(\n 0,\n withNullVoid(buildDefinition(storageEntry.type.value)),\n entry,\n )\n\n const { key, value, hashers } = storageEntry.type.value\n const val = withNullVoid(buildDefinition(value))\n const hashes = hashers.map((x) => scale[x.tag])\n\n const hashArgs: scale.EncoderWithHash[] = (() => {\n if (hashes.length === 1) {\n return [[buildDefinition(key), hashes[0]]]\n }\n\n const keyDef = getLookupEntryDef(key)\n\n switch (keyDef.type) {\n case \"array\":\n return hashes.map((hash) => [buildDefinition(keyDef.value.id), hash])\n case \"tuple\":\n return keyDef.value.map((x, idx) => [\n buildDefinition(x.id),\n hashes[idx],\n ])\n default:\n throw new Error(\"Invalid key type\")\n }\n })()\n\n return storageWithFallback(hashes.length, val, entry, ...hashArgs)\n }\n\n const buildEnumEntry = (\n entry: EnumVar[\"value\"][keyof EnumVar[\"value\"]],\n ): Codec => {\n switch (entry.type) {\n case \"void\":\n return scale._void\n case \"lookupEntry\":\n return buildDefinition(entry.value.id)\n case \"tuple\":\n return scale.Tuple(\n ...Object.values(entry.value).map((l) => buildDefinition(l.id)),\n )\n case \"struct\":\n return scale.Struct(\n mapObject(entry.value, (x) => buildDefinition(x.id)) as StringRecord<\n Codec\n >,\n )\n case \"array\":\n return scale.Vector(buildDefinition(entry.value.id), entry.len)\n }\n }\n\n const buildConstant = (pallet: string, constantName: string) => {\n const storageEntry = metadata.pallets\n .find((x) => x.name === pallet)!\n .constants!.find((s) => s.name === constantName)!\n\n return buildDefinition(storageEntry.type as number)\n }\n\n const buildVariant =\n (type: \"errors\" | \"events\" | \"calls\") =>\n (\n pallet: string,\n name: string,\n ): {\n codec: Codec\n location: [number, number]\n } => {\n const palletEntry = metadata.pallets.find((x) => x.name === pallet)!\n const lookup = getLookupEntryDef(palletEntry[type]!.type)\n if (lookup.type !== \"enum\") throw null\n const entry = lookup.value[name]\n\n return {\n location: [palletEntry.index, entry.idx],\n codec: buildEnumEntry(lookup.value[name]),\n }\n }\n\n const buildViewFn = (pallet: string, entry: string) => {\n const fn = metadata.pallets\n .find((x) => x.name === pallet)\n ?.viewFns.find((x) => x.name === entry)\n if (!fn) throw null\n\n return {\n args: scale.Tuple(...fn.inputs.map((x) => buildDefinition(x.type))),\n value: buildDefinition(fn.output),\n }\n }\n\n const buildRuntimeCall = (api: string, method: string) => {\n const entry = metadata.apis\n .find((x) => x.name === api)\n ?.methods.find((x) => x.name === method)\n if (!entry) throw null\n\n return {\n args: scale.Tuple(...entry.inputs.map((x) => buildDefinition(x.type))),\n value: buildDefinition(entry.output),\n }\n }\n\n return {\n buildDefinition,\n buildStorage,\n buildEvent: buildVariant(\"events\"),\n buildError: buildVariant(\"errors\"),\n buildViewFn,\n buildRuntimeCall,\n buildCall: buildVariant(\"calls\"),\n buildConstant,\n ss58Prefix,\n }\n}\n"],"names":["value"],"mappings":";;;;AAMA,MAAM,YAAY,KAAA,CAAM,YAAA;AAAA,EACtB,KAAA,CAAM,KAAA;AAAA,EACN,MAAM,MAAA;AAAA,EACN,MAAM;AACR,CAAA;AAEO,MAAM,iBAAA,GAAoB,CAAC,iBAAA,KAAsC;AACtE,EAAA,MAAM,EAAE,UAAS,GAAI,iBAAA;AACrB,EAAA,IAAI,eAAA,GAAkB,sBAAsB,iBAAiB,CAAA;AAE7D,EAAA,MAAM,SAAS,QAAA,CAAS,OAAA,CACrB,IAAA,CAAK,CAAC,MAAM,CAAA,CAAE,IAAA,KAAS,QAAQ,CAAA,EAC9B,UAAU,IAAA,CAAK,CAAC,CAAA,KAAM,CAAA,CAAE,SAAS,YAAY,CAAA;AAEjD,EAAA,IAAI,UAAA;AACJ,EAAA,IAAI,MAAA,EAAQ;AACV,IAAA,IAAI;AACF,MAAA,MAAM,YAAY,eAAA,CAAgB,MAAA,CAAO,IAAI,CAAA,CAAE,GAAA,CAAI,OAAO,KAAK,CAAA;AAC/D,MAAA,IAAI,OAAO,cAAc,QAAA,EAAU;AACjC,QAAA,UAAA,GAAa,SAAA;AACb,QAAA,eAAA,GAAkB,qBAAA;AAAA,UAChB,iBAAA;AAAA,UACA,KAAA,CAAM,UAAU,SAAS;AAAA,SAC3B;AAAA,MACF;AAAA,IACF,SAAS,CAAA,EAAG;AAAA,IAAC;AAAA,EACf;AAEA,EAAA,MAAM,cAAA,uBAAqB,GAAA,EAA8C;AAEzE,EAAA,MAAM,YAAA,GAAe,CAAC,MAAA,EAAgB,KAAA,KAAkB;AACtD,IAAA,IAAI,aAAA,GAAgB,cAAA,CAAe,GAAA,CAAI,MAAM,CAAA;AAC7C,IAAA,IAAI,CAAC,aAAA;AACH,MAAA,cAAA,CAAe,IAAI,MAAA,EAAS,aAAA,GAAgB,KAAA,CAAM,OAAA,CAAQ,MAAM,CAAE,CAAA;AAEpE,IAAA,MAAM,eAAe,QAAA,CAAS,OAAA,CAC3B,IAAA,CAAK,CAAC,MAAM,CAAA,CAAE,IAAA,KAAS,MAAM,CAAA,CAC7B,QAAS,KAAA,CAAM,IAAA,CAAK,CAAC,CAAA,KAAM,CAAA,CAAE,SAAS,KAAK,CAAA;AAK9C,IAAA,MAAM,eAAe,CAAC,KAAA,KACpB,KAAA,KAAU,KAAA,CAAM,QAAQ,SAAA,GAAY,KAAA;AAEtC,IAAA,MAAM,mBAAA,GAAsB,CAC1B,GAAA,EACAA,MAAAA,EAAAA,GACG,IAAA,KACA;AACH,MAAA,MAAM,IAAA,GAAO,aAAA,CAAe,GAAG,IAAI,CAAA;AACnC,MAAA,MAAM,GAAG,GAAG,gBAAgB,CAAA,GAAI,IAAA;AAChC,MAAA,OAAO;AAAA,QACL,IAAA,EAAM,KAAA,CAAM,KAAA,CAAM,GAAG,gBAAA,CAAiB,GAAA,CAAI,CAAC,CAAC,KAAK,CAAA,KAAM,KAAK,CAAC,CAAA;AAAA,QAC7D,IAAA;AAAA,QACA,KAAA,EAAAA,MAAAA;AAAA,QACA,GAAA;AAAA,QACA,QAAA,EACE,aAAa,QAAA,KAAa,CAAA,GACtBA,OAAM,GAAA,CAAI,YAAA,CAAa,QAAQ,CAAA,GAC/B;AAAA,OACR;AAAA,IACF,CAAA;AAEA,IAAA,IAAI,YAAA,CAAa,KAAK,GAAA,KAAQ,OAAA;AAC5B,MAAA,OAAO,mBAAA;AAAA,QACL,CAAA;AAAA,QACA,YAAA,CAAa,eAAA,CAAgB,YAAA,CAAa,IAAA,CAAK,KAAK,CAAC,CAAA;AAAA,QACrD;AAAA,OACF;AAEF,IAAA,MAAM,EAAE,GAAA,EAAK,KAAA,EAAO,OAAA,EAAQ,GAAI,aAAa,IAAA,CAAK,KAAA;AAClD,IAAA,MAAM,GAAA,GAAM,YAAA,CAAa,eAAA,CAAgB,KAAK,CAAC,CAAA;AAC/C,IAAA,MAAM,MAAA,GAAS,QAAQ,GAAA,CAAI,CAAC,MAAM,KAAA,CAAM,CAAA,CAAE,GAAG,CAAC,CAAA;AAE9C,IAAA,MAAM,YAA8C,MAAM;AACxD,MAAA,IAAI,MAAA,CAAO,WAAW,CAAA,EAAG;AACvB,QAAA,OAAO,CAAC,CAAC,eAAA,CAAgB,GAAG,GAAG,MAAA,CAAO,CAAC,CAAC,CAAC,CAAA;AAAA,MAC3C;AAEA,MAAA,MAAM,MAAA,GAAS,kBAAkB,GAAG,CAAA;AAEpC,MAAA,QAAQ,OAAO,IAAA;AAAM,QACnB,KAAK,OAAA;AACH,UAAA,OAAO,MAAA,CAAO,GAAA,CAAI,CAAC,IAAA,KAAS,CAAC,eAAA,CAAgB,MAAA,CAAO,KAAA,CAAM,EAAE,CAAA,EAAG,IAAI,CAAC,CAAA;AAAA,QACtE,KAAK,OAAA;AACH,UAAA,OAAO,MAAA,CAAO,KAAA,CAAM,GAAA,CAAI,CAAC,GAAG,GAAA,KAAQ;AAAA,YAClC,eAAA,CAAgB,EAAE,EAAE,CAAA;AAAA,YACpB,OAAO,GAAG;AAAA,WACX,CAAA;AAAA,QACH;AACE,UAAA,MAAM,IAAI,MAAM,kBAAkB,CAAA;AAAA;AACtC,IACF,CAAA,GAAG;AAEH,IAAA,OAAO,oBAAoB,MAAA,CAAO,MAAA,EAAQ,GAAA,EAAK,KAAA,EAAO,GAAG,QAAQ,CAAA;AAAA,EACnE,CAAA;AAEA,EAAA,MAAM,cAAA,GAAiB,CACrB,KAAA,KACe;AACf,IAAA,QAAQ,MAAM,IAAA;AAAM,MAClB,KAAK,MAAA;AACH,QAAA,OAAO,KAAA,CAAM,KAAA;AAAA,MACf,KAAK,aAAA;AACH,QAAA,OAAO,eAAA,CAAgB,KAAA,CAAM,KAAA,CAAM,EAAE,CAAA;AAAA,MACvC,KAAK,OAAA;AACH,QAAA,OAAO,KAAA,CAAM,KAAA;AAAA,UACX,GAAG,MAAA,CAAO,MAAA,CAAO,KAAA,CAAM,KAAK,CAAA,CAAE,GAAA,CAAI,CAAC,CAAA,KAAM,eAAA,CAAgB,CAAA,CAAE,EAAE,CAAC;AAAA,SAChE;AAAA,MACF,KAAK,QAAA;AACH,QAAA,OAAO,KAAA,CAAM,MAAA;AAAA,UACX,SAAA,CAAU,MAAM,KAAA,EAAO,CAAC,MAAM,eAAA,CAAgB,CAAA,CAAE,EAAE,CAAC;AAAA,SAGrD;AAAA,MACF,KAAK,OAAA;AACH,QAAA,OAAO,KAAA,CAAM,OAAO,eAAA,CAAgB,KAAA,CAAM,MAAM,EAAE,CAAA,EAAG,MAAM,GAAG,CAAA;AAAA;AAClE,EACF,CAAA;AAEA,EAAA,MAAM,aAAA,GAAgB,CAAC,MAAA,EAAgB,YAAA,KAAyB;AAC9D,IAAA,MAAM,eAAe,QAAA,CAAS,OAAA,CAC3B,IAAA,CAAK,CAAC,MAAM,CAAA,CAAE,IAAA,KAAS,MAAM,CAAA,CAC7B,UAAW,IAAA,CAAK,CAAC,CAAA,KAAM,CAAA,CAAE,SAAS,YAAY,CAAA;AAEjD,IAAA,OAAO,eAAA,CAAgB,aAAa,IAAc,CAAA;AAAA,EACpD,CAAA;AAEA,EAAA,MAAM,YAAA,GACJ,CAAC,IAAA,KACD,CACE,QACA,IAAA,KAIG;AACH,IAAA,MAAM,WAAA,GAAc,SAAS,OAAA,CAAQ,IAAA,CAAK,CAAC,CAAA,KAAM,CAAA,CAAE,SAAS,MAAM,CAAA;AAClE,IAAA,MAAM,MAAA,GAAS,iBAAA,CAAkB,WAAA,CAAY,IAAI,EAAG,IAAI,CAAA;AACxD,IAAA,IAAI,MAAA,CAAO,IAAA,KAAS,MAAA,EAAQ,MAAM,IAAA;AAClC,IAAA,MAAM,KAAA,GAAQ,MAAA,CAAO,KAAA,CAAM,IAAI,CAAA;AAE/B,IAAA,OAAO;AAAA,MACL,QAAA,EAAU,CAAC,WAAA,CAAY,KAAA,EAAO,MAAM,GAAG,CAAA;AAAA,MACvC,KAAA,EAAO,cAAA,CAAe,MAAA,CAAO,KAAA,CAAM,IAAI,CAAC;AAAA,KAC1C;AAAA,EACF,CAAA;AAEF,EAAA,MAAM,WAAA,GAAc,CAAC,MAAA,EAAgB,KAAA,KAAkB;AACrD,IAAA,MAAM,KAAK,QAAA,CAAS,OAAA,CACjB,IAAA,CAAK,CAAC,MAAM,CAAA,CAAE,IAAA,KAAS,MAAM,CAAA,EAC5B,QAAQ,IAAA,CAAK,CAAC,CAAA,KAAM,CAAA,CAAE,SAAS,KAAK,CAAA;AACxC,IAAA,IAAI,CAAC,IAAI,MAAM,IAAA;AAEf,IAAA,OAAO;AAAA,MACL,IAAA,EAAM,KAAA,CAAM,KAAA,CAAM,GAAG,EAAA,CAAG,MAAA,CAAO,GAAA,CAAI,CAAC,CAAA,KAAM,eAAA,CAAgB,CAAA,CAAE,IAAI,CAAC,CAAC,CAAA;AAAA,MAClE,KAAA,EAAO,eAAA,CAAgB,EAAA,CAAG,MAAM;AAAA,KAClC;AAAA,EACF,CAAA;AAEA,EAAA,MAAM,gBAAA,GAAmB,CAAC,GAAA,EAAa,MAAA,KAAmB;AACxD,IAAA,MAAM,QAAQ,QAAA,CAAS,IAAA,CACpB,IAAA,CAAK,CAAC,MAAM,CAAA,CAAE,IAAA,KAAS,GAAG,CAAA,EACzB,QAAQ,IAAA,CAAK,CAAC,CAAA,KAAM,CAAA,CAAE,SAAS,MAAM,CAAA;AACzC,IAAA,IAAI,CAAC,OAAO,MAAM,IAAA;AAElB,IAAA,OAAO;AAAA,MACL,IAAA,EAAM,KAAA,CAAM,KAAA,CAAM,GAAG,KAAA,CAAM,MAAA,CAAO,GAAA,CAAI,CAAC,CAAA,KAAM,eAAA,CAAgB,CAAA,CAAE,IAAI,CAAC,CAAC,CAAA;AAAA,MACrE,KAAA,EAAO,eAAA,CAAgB,KAAA,CAAM,MAAM;AAAA,KACrC;AAAA,EACF,CAAA;AAEA,EAAA,OAAO;AAAA,IACL,eAAA;AAAA,IACA,YAAA;AAAA,IACA,UAAA,EAAY,aAAa,QAAQ,CAAA;AAAA,IACjC,UAAA,EAAY,aAAa,QAAQ,CAAA;AAAA,IACjC,WAAA;AAAA,IACA,gBAAA;AAAA,IACA,SAAA,EAAW,aAAa,OAAO,CAAA;AAAA,IAC/B,aAAA;AAAA,IACA;AAAA,GACF;AACF;;;;"} \ No newline at end of file diff --git a/packages/metadata-builders/dist/esm/index.mjs b/packages/metadata-builders/dist/esm/index.mjs new file mode 100644 index 0000000..bbf5a62 --- /dev/null +++ b/packages/metadata-builders/dist/esm/index.mjs @@ -0,0 +1,5 @@ +export { denormalizeLookup, getLookupFn } from './lookups.mjs'; +export { getDynamicBuilder } from './dynamic-builder.mjs'; +export { getChecksumBuilder } from './checksum-builder.mjs'; +export { getLookupCodecBuilder } from './lookup-codec-builder.mjs'; +//# sourceMappingURL=index.mjs.map diff --git a/packages/metadata-builders/dist/esm/index.mjs.map b/packages/metadata-builders/dist/esm/index.mjs.map new file mode 100644 index 0000000..0ece4af --- /dev/null +++ b/packages/metadata-builders/dist/esm/index.mjs.map @@ -0,0 +1 @@ +{"version":3,"file":"index.mjs","sources":[],"sourcesContent":[],"names":[],"mappings":";;;"} \ No newline at end of file diff --git a/packages/metadata-builders/dist/esm/lookup-codec-builder.mjs b/packages/metadata-builders/dist/esm/lookup-codec-builder.mjs new file mode 100644 index 0000000..cdeab10 --- /dev/null +++ b/packages/metadata-builders/dist/esm/lookup-codec-builder.mjs @@ -0,0 +1,81 @@ +import * as scale from '@pezkuwi/bizinikiwi-bindings'; +import { withCache } from './with-cache.mjs'; + +const _bytes = scale.Bin(); +const _buildCodec = (input, cache, stack, _accountId) => { + if (input.type === "primitive") return scale[input.value]; + if (input.type === "void") return scale._void; + if (input.type === "AccountId32") return _accountId; + if (input.type === "AccountId20") return scale.ethAccount; + if (input.type === "compact") + return input.isBig ? scale.compactBn : scale.compactNumber; + if (input.type === "bitSequence") return scale.BitSeq(input.isLSB); + const buildNextCodec = (nextInput) => buildCodec(nextInput, cache, stack, _accountId); + const buildVector = (inner2, len) => { + const innerCodec = buildNextCodec(inner2); + return len ? scale.Vector(innerCodec, len) : scale.Vector(innerCodec); + }; + const buildTuple = (value) => scale.Tuple(...value.map(buildNextCodec)); + const buildStruct = (value) => { + const inner2 = Object.fromEntries( + Object.entries(value).map(([key, value2]) => [key, buildNextCodec(value2)]) + ); + return scale.Struct(inner2); + }; + if (input.type === "sequence" && input.value.type === "primitive" && input.value.value === "u8") { + return _bytes; + } + if (input.type === "array") { + if (input.value.type === "primitive" && input.value.value === "u8") + return scale.Bin(input.len); + return buildVector(input.value, input.len); + } + if (input.type === "sequence") return buildVector(input.value); + if (input.type === "tuple") return buildTuple(input.value); + if (input.type === "struct") return buildStruct(input.value); + if (input.type === "option") return scale.Option(buildNextCodec(input.value)); + if (input.type === "result") + return scale.Result( + buildNextCodec(input.value.ok), + buildNextCodec(input.value.ko) + ); + const dependencies = Object.values(input.value).map((v) => { + switch (v.type) { + case "void": + return scale._void; + case "lookupEntry": + return buildNextCodec(v.value); + case "tuple": + return buildTuple(v.value); + case "struct": + return buildStruct(v.value); + case "array": + return buildVector(v.value, v.len); + } + }); + const inner = Object.fromEntries( + Object.keys(input.value).map((key, idx) => { + return [key, dependencies[idx]]; + }) + ); + const indexes = Object.values(input.value).map((x) => x.idx); + const areIndexesSorted = indexes.every((idx, i) => idx === i); + const variantCodec = areIndexesSorted ? scale.Variant(inner) : scale.Variant(inner, indexes); + return input.byteLength ? fixedSizeCodec(variantCodec, input.byteLength) : variantCodec; +}; +const buildCodec = withCache(_buildCodec, scale.Self, (res) => res); +const getLookupCodecBuilder = (lookup, accountId = scale.AccountId()) => { + const cache = /* @__PURE__ */ new Map(); + const buildDefinition = (id) => buildCodec(lookup(id), cache, /* @__PURE__ */ new Set(), accountId); + return (id) => buildDefinition(id); +}; +const fixedSizeCodec = (codec, size) => { + const allBytes = scale.Bytes(size); + return scale.createCodec( + (value) => allBytes.enc(codec.enc(value)), + (data) => codec.dec(allBytes.dec(data)) + ); +}; + +export { getLookupCodecBuilder }; +//# sourceMappingURL=lookup-codec-builder.mjs.map diff --git a/packages/metadata-builders/dist/esm/lookup-codec-builder.mjs.map b/packages/metadata-builders/dist/esm/lookup-codec-builder.mjs.map new file mode 100644 index 0000000..6d64c5b --- /dev/null +++ b/packages/metadata-builders/dist/esm/lookup-codec-builder.mjs.map @@ -0,0 +1 @@ +{"version":3,"file":"lookup-codec-builder.mjs","sources":["../../src/lookup-codec-builder.ts"],"sourcesContent":["import type { Codec, StringRecord } from \"@pezkuwi/bizinikiwi-bindings\"\nimport * as scale from \"@pezkuwi/bizinikiwi-bindings\"\nimport type { LookupEntry } from \"./lookups\"\nimport { withCache } from \"./with-cache\"\n\nconst _bytes = scale.Bin()\n\nconst _buildCodec = (\n input: LookupEntry,\n cache: Map>,\n stack: Set,\n _accountId: Codec,\n): Codec => {\n if (input.type === \"primitive\") return scale[input.value]\n if (input.type === \"void\") return scale._void\n if (input.type === \"AccountId32\") return _accountId\n if (input.type === \"AccountId20\") return scale.ethAccount\n if (input.type === \"compact\")\n return input.isBig ? scale.compactBn : scale.compactNumber\n if (input.type === \"bitSequence\") return scale.BitSeq(input.isLSB)\n\n const buildNextCodec = (nextInput: LookupEntry): Codec =>\n buildCodec(nextInput, cache, stack, _accountId)\n\n const buildVector = (inner: LookupEntry, len?: number) => {\n const innerCodec = buildNextCodec(inner)\n return len ? scale.Vector(innerCodec, len) : scale.Vector(innerCodec)\n }\n\n const buildTuple = (value: LookupEntry[]) =>\n scale.Tuple(...value.map(buildNextCodec))\n\n const buildStruct = (value: StringRecord) => {\n const inner = Object.fromEntries(\n Object.entries(value).map(([key, value]) => [key, buildNextCodec(value)]),\n ) as StringRecord>\n return scale.Struct(inner)\n }\n\n if (\n input.type === \"sequence\" &&\n input.value.type === \"primitive\" &&\n input.value.value === \"u8\"\n ) {\n return _bytes\n }\n\n if (input.type === \"array\") {\n // Bytes case\n if (input.value.type === \"primitive\" && input.value.value === \"u8\")\n return scale.Bin(input.len)\n\n return buildVector(input.value, input.len)\n }\n\n if (input.type === \"sequence\") return buildVector(input.value)\n if (input.type === \"tuple\") return buildTuple(input.value)\n if (input.type === \"struct\") return buildStruct(input.value)\n\n if (input.type === \"option\") return scale.Option(buildNextCodec(input.value))\n\n if (input.type === \"result\")\n return scale.Result(\n buildNextCodec(input.value.ok),\n buildNextCodec(input.value.ko),\n )\n\n // it has to be an enum by now\n const dependencies = Object.values(input.value).map((v) => {\n switch (v.type) {\n case \"void\":\n return scale._void\n case \"lookupEntry\":\n return buildNextCodec(v.value)\n case \"tuple\":\n return buildTuple(v.value)\n case \"struct\":\n return buildStruct(v.value)\n case \"array\":\n return buildVector(v.value, v.len)\n }\n })\n\n const inner = Object.fromEntries(\n Object.keys(input.value).map((key, idx) => {\n return [key, dependencies[idx]]\n }),\n ) as StringRecord>\n\n const indexes = Object.values(input.value).map((x) => x.idx)\n const areIndexesSorted = indexes.every((idx, i) => idx === i)\n\n const variantCodec = areIndexesSorted\n ? scale.Variant(inner)\n : scale.Variant(inner, indexes as any)\n return input.byteLength\n ? fixedSizeCodec(variantCodec, input.byteLength)\n : variantCodec\n}\nconst buildCodec = withCache(_buildCodec, scale.Self, (res) => res)\n\nexport const getLookupCodecBuilder = (\n lookup: (id: number) => LookupEntry,\n accountId = scale.AccountId(),\n) => {\n const cache = new Map()\n const buildDefinition = (id: number) =>\n buildCodec(lookup(id), cache, new Set(), accountId)\n\n return (id: number) => buildDefinition(id)\n}\n\nconst fixedSizeCodec = (codec: Codec, size: number): Codec => {\n const allBytes = scale.Bytes(size)\n return scale.createCodec(\n (value: T) => allBytes.enc(codec.enc(value)),\n (data) => codec.dec(allBytes.dec(data)),\n )\n}\n"],"names":["inner","value"],"mappings":"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"} \ No newline at end of file diff --git a/packages/metadata-builders/dist/esm/lookup-graph.mjs b/packages/metadata-builders/dist/esm/lookup-graph.mjs new file mode 100644 index 0000000..dce2e26 --- /dev/null +++ b/packages/metadata-builders/dist/esm/lookup-graph.mjs @@ -0,0 +1,161 @@ +function buildLookupGraph(lookupFn, lookupLength) { + const result = /* @__PURE__ */ new Map(); + const visited = /* @__PURE__ */ new Set(); + const addEdge = (from, to) => { + if (!result.has(from)) + result.set(from, { + entry: lookupFn(from), + backRefs: /* @__PURE__ */ new Set(), + refs: /* @__PURE__ */ new Set() + }); + if (!result.has(to)) + result.set(to, { + entry: lookupFn(to), + backRefs: /* @__PURE__ */ new Set(), + refs: /* @__PURE__ */ new Set() + }); + result.get(from).refs.add(to); + result.get(to).backRefs.add(from); + }; + for (let i = 0; i < lookupLength; i++) { + const entry = lookupFn(i); + if (i !== entry.id) { + addEdge(i, entry.id); + } + if (visited.has(entry.id)) continue; + visited.add(entry.id); + switch (entry.type) { + case "array": + case "option": + case "sequence": + addEdge(entry.id, entry.value.id); + break; + case "enum": + Object.values(entry.value).forEach((enumEntry) => { + switch (enumEntry.type) { + case "array": + case "lookupEntry": + addEdge(entry.id, enumEntry.value.id); + break; + case "struct": + case "tuple": + Object.values(enumEntry.value).forEach( + (v) => addEdge(entry.id, v.id) + ); + break; + } + }); + break; + case "result": + addEdge(entry.id, entry.value.ok.id); + addEdge(entry.id, entry.value.ko.id); + break; + case "struct": + case "tuple": + Object.values(entry.value).forEach((v) => addEdge(entry.id, v.id)); + break; + } + if (!result.has(entry.id)) { + result.set(entry.id, { + backRefs: /* @__PURE__ */ new Set(), + refs: /* @__PURE__ */ new Set(), + entry + }); + } + } + return result; +} +const subgraphCache = /* @__PURE__ */ new WeakMap(); +function _getSubgraph(id, graph, result, cache) { + if (result.has(id)) return; + const node = graph.get(id); + result.set(id, node); + cache.set(id, result); + node.refs.forEach((ref) => _getSubgraph(ref, graph, result, cache)); + node.backRefs.forEach((ref) => _getSubgraph(ref, graph, result, cache)); +} +function getSubgraph(id, graph) { + if (!subgraphCache.has(graph)) { + subgraphCache.set(graph, /* @__PURE__ */ new Map()); + } + const cache = subgraphCache.get(graph); + if (cache.has(id)) return cache.get(id); + const result = /* @__PURE__ */ new Map(); + _getSubgraph(id, graph, result, cache); + return result; +} +function getStronglyConnectedComponents(graph) { + const tarjanState = /* @__PURE__ */ new Map(); + let index = 0; + const stack = []; + const result = []; + function strongConnect(v) { + const state = { + index, + lowLink: index, + onStack: true + }; + tarjanState.set(v, state); + index++; + stack.push(v); + const edges = graph.get(v).refs; + for (let w of edges) { + const edgeState = tarjanState.get(w); + if (!edgeState) { + strongConnect(w); + state.lowLink = Math.min(state.lowLink, tarjanState.get(w).lowLink); + } else if (edgeState.onStack) { + state.lowLink = Math.min(state.lowLink, edgeState.index); + } + } + if (state.lowLink === state.index) { + const component = /* @__PURE__ */ new Set(); + let poppedNode = -1; + do { + poppedNode = stack.pop(); + tarjanState.get(poppedNode).onStack = false; + component.add(poppedNode); + } while (poppedNode !== v); + result.push(component); + } + } + for (const node of graph.keys()) { + if (!tarjanState.has(node)) { + strongConnect(node); + } + } + return result; +} +function mergeSCCsWithCommonNodes(stronglyConnectedComponents) { + const scc = stronglyConnectedComponents; + const ungroupedCycles = new Set(scc.map((_, i) => i)); + const edges = new Map(scc.map((_, i) => [i, /* @__PURE__ */ new Set()])); + scc.forEach((cycle, i) => { + scc.slice(i + 1).forEach((otherCycle, _j) => { + const j = _j + i + 1; + const combined = /* @__PURE__ */ new Set([...cycle, ...otherCycle]); + if (combined.size !== cycle.size + otherCycle.size) { + edges.get(i).add(j); + edges.get(j).add(i); + } + }); + }); + const groups = []; + while (ungroupedCycles.size) { + const group = /* @__PURE__ */ new Set(); + const toVisit = [ungroupedCycles.values().next().value]; + while (toVisit.length) { + const idx = toVisit.pop(); + if (!ungroupedCycles.has(idx)) continue; + ungroupedCycles.delete(idx); + const cycle = scc[idx]; + cycle.forEach((v) => group.add(Number(v))); + edges.get(idx).forEach((n) => toVisit.push(n)); + } + groups.push(group); + } + return groups; +} + +export { buildLookupGraph, getStronglyConnectedComponents, getSubgraph, mergeSCCsWithCommonNodes }; +//# sourceMappingURL=lookup-graph.mjs.map diff --git a/packages/metadata-builders/dist/esm/lookup-graph.mjs.map b/packages/metadata-builders/dist/esm/lookup-graph.mjs.map new file mode 100644 index 0000000..30030d3 --- /dev/null +++ b/packages/metadata-builders/dist/esm/lookup-graph.mjs.map @@ -0,0 +1 @@ +{"version":3,"file":"lookup-graph.mjs","sources":["../../src/lookup-graph.ts"],"sourcesContent":["import { LookupEntry } from \"./lookups\"\n\nexport type LookupGraph = Map<\n number,\n { entry: LookupEntry; backRefs: Set; refs: Set }\n>\n\nexport function buildLookupGraph(\n lookupFn: (id: number) => LookupEntry,\n lookupLength: number,\n): LookupGraph {\n const result: LookupGraph = new Map()\n const visited = new Set()\n\n const addEdge = (from: number, to: number) => {\n if (!result.has(from))\n result.set(from, {\n entry: lookupFn(from),\n backRefs: new Set(),\n refs: new Set(),\n })\n if (!result.has(to))\n result.set(to, {\n entry: lookupFn(to),\n backRefs: new Set(),\n refs: new Set(),\n })\n result.get(from)!.refs.add(to)\n result.get(to)!.backRefs.add(from)\n }\n\n for (let i = 0; i < lookupLength; i++) {\n const entry = lookupFn(i)\n if (i !== entry.id) {\n // Lookup solved a pointer, but we still need to add that node into our\n // graph in case someone access it from there.\n addEdge(i, entry.id)\n }\n if (visited.has(entry.id)) continue\n visited.add(entry.id)\n\n switch (entry.type) {\n case \"array\":\n case \"option\":\n case \"sequence\":\n addEdge(entry.id, entry.value.id)\n break\n case \"enum\":\n Object.values(entry.value).forEach((enumEntry) => {\n switch (enumEntry.type) {\n case \"array\":\n case \"lookupEntry\":\n addEdge(entry.id, enumEntry.value.id)\n break\n case \"struct\":\n case \"tuple\":\n Object.values(enumEntry.value).forEach((v) =>\n addEdge(entry.id, v.id),\n )\n break\n }\n })\n break\n case \"result\":\n addEdge(entry.id, entry.value.ok.id)\n addEdge(entry.id, entry.value.ko.id)\n break\n case \"struct\":\n case \"tuple\":\n Object.values(entry.value).forEach((v) => addEdge(entry.id, v.id))\n break\n }\n\n // It could be that this node is not being referenced by any other type\n // nor it references anything. We still have to add it into the graph.\n if (!result.has(entry.id)) {\n result.set(entry.id, {\n backRefs: new Set(),\n refs: new Set(),\n entry,\n })\n }\n }\n\n return result\n}\n\nconst subgraphCache = new WeakMap>()\nfunction _getSubgraph(\n id: number,\n graph: LookupGraph,\n result: LookupGraph,\n cache: Map,\n) {\n if (result.has(id)) return\n const node = graph.get(id)!\n result.set(id, node)\n cache.set(id, result)\n\n node.refs.forEach((ref) => _getSubgraph(ref, graph, result, cache))\n node.backRefs.forEach((ref) => _getSubgraph(ref, graph, result, cache))\n}\n\nexport function getSubgraph(id: number, graph: LookupGraph) {\n if (!subgraphCache.has(graph)) {\n subgraphCache.set(graph, new Map())\n }\n const cache = subgraphCache.get(graph)!\n if (cache.has(id)) return cache.get(id)!\n\n const result: LookupGraph = new Map()\n _getSubgraph(id, graph, result, cache)\n return result\n}\n\nexport function getStronglyConnectedComponents(graph: LookupGraph) {\n // Tarjan's strongly connected components\n const tarjanState = new Map<\n number,\n {\n index: number\n lowLink: number\n onStack: boolean\n }\n >()\n let index = 0\n const stack: number[] = []\n const result: Array> = []\n\n function strongConnect(v: number): void {\n const state = {\n index: index,\n lowLink: index,\n onStack: true,\n }\n tarjanState.set(v, state)\n index++\n stack.push(v)\n\n const edges = graph.get(v)!.refs\n for (let w of edges) {\n const edgeState = tarjanState.get(w)\n if (!edgeState) {\n strongConnect(w)\n state.lowLink = Math.min(state.lowLink, tarjanState.get(w)!.lowLink)\n } else if (edgeState.onStack) {\n state.lowLink = Math.min(state.lowLink, edgeState.index)\n }\n }\n\n if (state.lowLink === state.index) {\n const component = new Set()\n\n let poppedNode = -1\n do {\n poppedNode = stack.pop()!\n tarjanState.get(poppedNode)!.onStack = false\n component.add(poppedNode)\n } while (poppedNode !== v)\n\n result.push(component)\n }\n }\n\n for (const node of graph.keys()) {\n if (!tarjanState.has(node)) {\n strongConnect(node)\n }\n }\n\n return result\n}\n\nexport function mergeSCCsWithCommonNodes(\n stronglyConnectedComponents: Array>,\n) {\n /**\n * For Nodes that are shared between two sets of SCCs, we need to calculate\n * the checksum for the both of them, which wouldn't work (it would give\n * different checksums).\n * So we merge the SCCs that are using shared nodes into one group.\n */\n const scc = stronglyConnectedComponents\n const ungroupedCycles = new Set(scc.map((_, i) => i))\n const edges = new Map(scc.map((_, i) => [i, new Set()]))\n scc.forEach((cycle, i) => {\n scc.slice(i + 1).forEach((otherCycle, _j) => {\n const j = _j + i + 1\n const combined = new Set([...cycle, ...otherCycle])\n if (combined.size !== cycle.size + otherCycle.size) {\n edges.get(i)!.add(j)\n edges.get(j)!.add(i)\n }\n })\n })\n const groups: Array> = []\n\n while (ungroupedCycles.size) {\n const group = new Set()\n const toVisit = [ungroupedCycles.values().next().value!]\n while (toVisit.length) {\n const idx = toVisit.pop()!\n if (!ungroupedCycles.has(idx)) continue\n ungroupedCycles.delete(idx)\n\n const cycle = scc[idx]\n cycle.forEach((v) => group.add(Number(v)))\n edges.get(idx)!.forEach((n) => toVisit.push(n))\n }\n groups.push(group)\n }\n\n return groups\n}\n"],"names":[],"mappings":"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"} \ No newline at end of file diff --git a/packages/metadata-builders/dist/esm/lookups.mjs b/packages/metadata-builders/dist/esm/lookups.mjs new file mode 100644 index 0000000..be8432c --- /dev/null +++ b/packages/metadata-builders/dist/esm/lookups.mjs @@ -0,0 +1,224 @@ +const isBytes = (value, nBytes) => value.type === "array" && value.len === nBytes && value.value.type === "primitive" && value.value.value === "u8"; +const _void = { type: "void" }; +const _denormalizeLookup = (lookupData, customMap = () => null) => { + const lookups = /* @__PURE__ */ new Map(); + const from = /* @__PURE__ */ new Set(); + const withCache = (fn) => { + return (id) => { + let entry = lookups.get(id); + if (entry) return entry; + if (from.has(id)) { + const entry2 = { + id + }; + lookups.set(id, entry2); + return entry2; + } + from.add(id); + const value = fn(id); + entry = lookups.get(id); + if (entry) { + Object.assign(entry, value); + } else { + entry = { + id, + ...value + }; + lookups.set(id, entry); + } + from.delete(id); + return entry; + }; + }; + let isAccountId32SearchOn = true; + let isAccountId20SearchOn = true; + const getLookupEntryDef = withCache((id) => { + const custom = customMap(lookupData[id]); + if (custom) return custom; + const { def, path, params } = lookupData[id]; + if (def.tag === "composite") { + if (def.value.length === 0) return _void; + if (def.value.length === 1) { + const inner = getLookupEntryDef(def.value[0].type); + if (isAccountId32SearchOn && path.at(-1) === "AccountId32" && isBytes(inner, 32)) { + isAccountId32SearchOn = false; + return { type: "AccountId32" }; + } + if (isAccountId20SearchOn && path.at(-1) === "AccountId20" && isBytes(inner, 20)) { + isAccountId20SearchOn = false; + return { type: "AccountId20" }; + } + return inner; + } + return getComplexVar(def.value); + } + if (def.tag === "variant") { + if (path.length === 1 && path[0] === "Option" && params.length === 1 && params[0].name === "T") { + const value = getLookupEntryDef(params[0].type); + return value.type === "void" ? ( + // Option would return a Codec which makes no sense + // Therefore, we better treat it as a bool + { type: "primitive", value: "bool" } + ) : { + type: "option", + value + }; + } + if (path.length === 1 && path[0] === "Result" && params.length === 2 && params[0].name === "T" && params[1].name === "E") { + return { + type: "result", + value: { + ok: getLookupEntryDef(params[0].type), + ko: getLookupEntryDef(params[1].type) + } + }; + } + if (def.value.length === 0) return _void; + const enumValue = {}; + const enumDocs = {}; + def.value.forEach((x) => { + const key = x.name; + enumDocs[key] = x.docs; + if (x.fields.length === 0) { + enumValue[key] = { ..._void, idx: x.index }; + return; + } + if (x.fields.length === 1 && !x.fields[0].name) { + enumValue[key] = { + type: "lookupEntry", + value: getLookupEntryDef(x.fields[0].type), + idx: x.index + }; + return; + } + enumValue[key] = { ...getComplexVar(x.fields), idx: x.index }; + }); + return { + type: "enum", + value: enumValue, + innerDocs: enumDocs + }; + } + if (def.tag === "sequence") + return { + type: "sequence", + value: getLookupEntryDef(def.value) + }; + if (def.tag === "array") { + const { len } = def.value; + const value = getLookupEntryDef(def.value.type); + return !len || value.type === "void" ? _void : len > 1 ? { + type: "array", + value, + len: def.value.len + } : value; + } + if (def.tag === "tuple") { + if (def.value.length === 0) return _void; + return def.value.length > 1 ? getArrayOrTuple( + def.value.map((x) => getLookupEntryDef(x)), + def.value.map((x) => lookupData[x].docs) + ) : getLookupEntryDef(def.value[0]); + } + if (def.tag === "primitive") { + return { + type: "primitive", + value: def.value.tag + }; + } + if (def.tag === "compact") { + const translated = getLookupEntryDef(def.value); + if (translated.type === "void") return _void; + const isBig = Number(translated.value.slice(1)) > 32; + return { + type: "compact", + isBig, + size: translated.value + }; + } + return { + type: def.tag, + isLSB: (lookupData[def.value.bitOrderType].path.at(-1) ?? "LSB").toUpperCase().startsWith("LSB") + }; + }); + const getComplexVar = (input) => { + let allKey = true; + const values = {}; + const innerDocs = {}; + input.forEach((x, idx) => { + allKey = allKey && !!x.name; + const key = x.name || idx; + const value = getLookupEntryDef(x.type); + if (value.type !== "void") { + values[key] = value; + innerDocs[key] = x.docs; + } + }); + return allKey ? { + type: "struct", + value: values, + innerDocs + } : getArrayOrTuple(Object.values(values), Object.values(innerDocs)); + }; + const getArrayOrTuple = (values, innerDocs) => { + if (values.every((v) => v.id === values[0].id) && innerDocs.every((doc) => !doc.length)) { + const [value] = values; + return value.type === "void" ? _void : { + type: "array", + value: values[0], + len: values.length + }; + } + return { + type: "tuple", + value: values, + innerDocs + }; + }; + return getLookupEntryDef; +}; +const denormalizeLookup = (lookupData) => _denormalizeLookup(lookupData); +const getLookupFn = (metadata) => { + const getLookupEntryDef = _denormalizeLookup(metadata.lookup, ({ def }) => { + if (def.tag === "composite") { + const moduleErrorLength = getModuleErrorLength(def); + if (moduleErrorLength) { + return { + type: "enum", + innerDocs: {}, + value: Object.fromEntries( + metadata.pallets.map((p) => [ + p.name, + p.errors == null ? { ..._void, idx: p.index } : { + type: "lookupEntry", + value: getLookupEntryDef(p.errors.type), + idx: p.index + } + ]) + ), + byteLength: moduleErrorLength + }; + } + } + return null; + }); + function getModuleErrorLength(def) { + const preChecks = def.value.length === 2 && def.value[0].name === "index" && def.value[1].name === "error"; + if (!preChecks) return null; + const index = getLookupEntryDef(def.value[0].type); + const error = getLookupEntryDef(def.value[1].type); + return index.type === "primitive" && index.value === "u8" && error.type === "array" && error.value.type === "primitive" && error.value.value === "u8" ? 1 + error.len : null; + } + const getCall = () => { + if ("call" in metadata.extrinsic) { + return metadata.extrinsic.call; + } + const extrinsic = metadata.lookup[metadata.extrinsic.type]; + const call = extrinsic?.params.find((p) => p.name === "Call"); + return call?.type ?? null; + }; + return Object.assign(getLookupEntryDef, { metadata, call: getCall() }); +}; + +export { denormalizeLookup, getLookupFn }; +//# sourceMappingURL=lookups.mjs.map diff --git a/packages/metadata-builders/dist/esm/lookups.mjs.map b/packages/metadata-builders/dist/esm/lookups.mjs.map new file mode 100644 index 0000000..ad6461e --- /dev/null +++ b/packages/metadata-builders/dist/esm/lookups.mjs.map @@ -0,0 +1 @@ +{"version":3,"file":"lookups.mjs","sources":["../../src/lookups.ts"],"sourcesContent":["import type {\n StringRecord,\n UnifiedMetadata,\n V14Lookup,\n} from \"@pezkuwi/bizinikiwi-bindings\"\n\nexport type SignedPrimitive = \"i8\" | \"i16\" | \"i32\" | \"i64\" | \"i128\" | \"i256\"\nexport type UnsignedPrimitive = \"u8\" | \"u16\" | \"u32\" | \"u64\" | \"u128\" | \"u256\"\nexport type MetadataPrimitives =\n | \"bool\"\n | \"char\"\n | \"str\"\n | SignedPrimitive\n | UnsignedPrimitive\n\nexport type PrimitiveVar = {\n type: \"primitive\"\n value: MetadataPrimitives\n}\n\nexport type VoidVar = { type: \"void\" }\nexport type CompactVar = {\n type: \"compact\"\n isBig: boolean\n size: UnsignedPrimitive\n}\nexport type BitSequenceVar = {\n type: \"bitSequence\"\n isLSB: boolean\n}\nexport type AccountId32 = { type: \"AccountId32\" }\nexport type AccountId20 = { type: \"AccountId20\" }\nexport type TerminalVar =\n | PrimitiveVar\n | VoidVar\n | CompactVar\n | BitSequenceVar\n | AccountId32\n | AccountId20\n\n/* Array-like vars:\n * - TupleVar: Mixed types, fixed length\n * - Sequence: One type, arbitrary length\n * - Array: One type, fixed length\n */\nexport type TupleVar = {\n type: \"tuple\"\n value: LookupEntry[]\n innerDocs: Array\n}\nexport type StructVar = {\n type: \"struct\"\n value: StringRecord\n innerDocs: StringRecord\n}\nexport type EnumVar = {\n type: \"enum\"\n value: StringRecord<\n (\n | { type: \"lookupEntry\"; value: LookupEntry }\n | VoidVar\n | TupleVar\n | StructVar\n | ArrayVar\n ) & { idx: number }\n >\n innerDocs: StringRecord\n byteLength?: number\n}\nexport type OptionVar = {\n type: \"option\"\n value: LookupEntry\n}\nexport type ResultVar = {\n type: \"result\"\n value: { ok: LookupEntry; ko: LookupEntry }\n}\nexport type SequenceVar = {\n type: \"sequence\"\n value: LookupEntry\n}\nexport type ArrayVar = {\n type: \"array\"\n value: LookupEntry\n len: number\n}\n\nexport type ComposedVar =\n | TupleVar\n | StructVar\n | SequenceVar\n | ArrayVar\n | OptionVar\n | ResultVar\n | EnumVar\n\nexport type Var = TerminalVar | ComposedVar\n\nexport type LookupEntry = {\n id: number\n} & Var\n\nconst isBytes = (value: LookupEntry, nBytes: number) =>\n value.type === \"array\" &&\n value.len === nBytes &&\n value.value.type === \"primitive\" &&\n value.value.value === \"u8\"\n\nconst _void: VoidVar = { type: \"void\" }\n\nexport interface MetadataLookup {\n (id: number): LookupEntry\n metadata: UnifiedMetadata\n call: number | null\n}\n\nconst _denormalizeLookup = (\n lookupData: V14Lookup,\n customMap: (value: V14Lookup[number]) => Var | null = () => null,\n): ((id: number) => LookupEntry) => {\n const lookups = new Map()\n const from = new Set()\n\n const withCache = (\n fn: (id: number) => Var,\n ): ((id: number) => LookupEntry) => {\n return (id) => {\n let entry = lookups.get(id)\n\n if (entry) return entry\n\n if (from.has(id)) {\n const entry = {\n id,\n } as LookupEntry\n\n lookups.set(id, entry)\n return entry\n }\n\n from.add(id)\n const value = fn(id)\n entry = lookups.get(id)\n\n if (entry) {\n Object.assign(entry, value)\n } else {\n entry = {\n id,\n ...value,\n }\n lookups.set(id, entry!)\n }\n from.delete(id)\n return entry\n }\n }\n\n let isAccountId32SearchOn = true\n let isAccountId20SearchOn = true\n const getLookupEntryDef = withCache((id): Var => {\n const custom = customMap(lookupData[id])\n if (custom) return custom\n\n const { def, path, params } = lookupData[id]\n\n if (def.tag === \"composite\") {\n if (def.value.length === 0) return _void\n\n // used to be a \"pointer\"\n if (def.value.length === 1) {\n const inner = getLookupEntryDef(def.value[0].type as number)\n\n if (\n isAccountId32SearchOn &&\n path.at(-1) === \"AccountId32\" &&\n isBytes(inner, 32)\n ) {\n isAccountId32SearchOn = false\n return { type: \"AccountId32\" }\n }\n\n if (\n isAccountId20SearchOn &&\n path.at(-1) === \"AccountId20\" &&\n isBytes(inner, 20)\n ) {\n isAccountId20SearchOn = false\n return { type: \"AccountId20\" }\n }\n\n return inner\n }\n\n return getComplexVar(def.value)\n }\n\n if (def.tag === \"variant\") {\n if (\n path.length === 1 &&\n path[0] === \"Option\" &&\n params.length === 1 &&\n params[0].name === \"T\"\n ) {\n const value = getLookupEntryDef(params[0].type!)\n return value.type === \"void\"\n ? // Option would return a Codec which makes no sense\n // Therefore, we better treat it as a bool\n { type: \"primitive\", value: \"bool\" }\n : {\n type: \"option\",\n value,\n }\n }\n\n if (\n path.length === 1 &&\n path[0] === \"Result\" &&\n params.length === 2 &&\n params[0].name === \"T\" &&\n params[1].name === \"E\"\n ) {\n return {\n type: \"result\",\n value: {\n ok: getLookupEntryDef(params[0].type as number),\n ko: getLookupEntryDef(params[1].type as number),\n },\n }\n }\n if (def.value.length === 0) return _void\n\n const enumValue: StringRecord =\n {}\n const enumDocs: StringRecord = {}\n\n def.value.forEach((x) => {\n const key = x.name\n enumDocs[key] = x.docs\n\n if (x.fields.length === 0) {\n enumValue[key] = { ..._void, idx: x.index }\n return\n }\n\n if (x.fields.length === 1 && !x.fields[0].name) {\n enumValue[key] = {\n type: \"lookupEntry\",\n value: getLookupEntryDef(x.fields[0].type),\n idx: x.index,\n }\n return\n }\n\n enumValue[key] = { ...getComplexVar(x.fields), idx: x.index }\n })\n\n return {\n type: \"enum\",\n value: enumValue,\n innerDocs: enumDocs,\n }\n }\n\n if (def.tag === \"sequence\")\n return {\n type: \"sequence\",\n value: getLookupEntryDef(def.value as number),\n }\n\n if (def.tag === \"array\") {\n const { len } = def.value\n const value = getLookupEntryDef(def.value.type)\n\n return !len || value.type === \"void\"\n ? _void\n : len > 1\n ? {\n type: \"array\",\n value,\n len: def.value.len,\n }\n : value\n }\n\n if (def.tag === \"tuple\") {\n if (def.value.length === 0) return _void\n\n return def.value.length > 1\n ? getArrayOrTuple(\n def.value.map((x) => getLookupEntryDef(x as number)),\n def.value.map((x) => lookupData[x].docs),\n )\n : getLookupEntryDef(def.value[0] as number) // use to be a \"pointer\"\n }\n\n if (def.tag === \"primitive\") {\n return {\n type: \"primitive\",\n value: def.value.tag,\n }\n }\n\n if (def.tag === \"compact\") {\n const translated = getLookupEntryDef(def.value) as PrimitiveVar | VoidVar\n if (translated.type === \"void\") return _void\n\n const isBig = Number(translated.value.slice(1)) > 32\n\n return {\n type: \"compact\",\n isBig,\n size: translated.value as UnsignedPrimitive,\n }\n }\n\n // bitSequence\n return {\n type: def.tag,\n isLSB: (lookupData[def.value.bitOrderType].path.at(-1) ?? \"LSB\")\n .toUpperCase()\n .startsWith(\"LSB\"),\n }\n })\n\n const getComplexVar = (\n input: Array<{ type: number; name?: string; docs: string[] }>,\n ): TupleVar | StructVar | ArrayVar | VoidVar => {\n let allKey = true\n\n const values: Record = {}\n const innerDocs: Record = {}\n\n input.forEach((x, idx) => {\n allKey = allKey && !!x.name\n const key = x.name || idx\n const value = getLookupEntryDef(x.type as number)\n if (value.type !== \"void\") {\n values[key] = value\n innerDocs[key] = x.docs\n }\n })\n return allKey\n ? {\n type: \"struct\",\n value: values as StringRecord,\n innerDocs: innerDocs as StringRecord,\n }\n : getArrayOrTuple(Object.values(values), Object.values(innerDocs))\n }\n\n const getArrayOrTuple = (\n values: Array,\n innerDocs: Array,\n ): TupleVar | ArrayVar | VoidVar => {\n if (\n values.every((v) => v.id === values[0].id) &&\n innerDocs.every((doc) => !doc.length)\n ) {\n const [value] = values\n return value.type === \"void\"\n ? _void\n : {\n type: \"array\",\n value: values[0],\n len: values.length,\n }\n }\n return {\n type: \"tuple\",\n value: values,\n innerDocs: innerDocs,\n }\n }\n\n return getLookupEntryDef\n}\n\nexport const denormalizeLookup = (lookupData: V14Lookup) =>\n _denormalizeLookup(lookupData)\n\nexport const getLookupFn = (metadata: UnifiedMetadata): MetadataLookup => {\n const getLookupEntryDef = _denormalizeLookup(metadata.lookup, ({ def }) => {\n if (def.tag === \"composite\") {\n const moduleErrorLength = getModuleErrorLength(def)\n if (moduleErrorLength) {\n return {\n type: \"enum\",\n innerDocs: {},\n value: Object.fromEntries(\n metadata.pallets.map((p) => [\n p.name,\n p.errors == null\n ? { ..._void, idx: p.index }\n : {\n type: \"lookupEntry\" as const,\n value: getLookupEntryDef(p.errors.type),\n idx: p.index,\n },\n ]),\n ) as StringRecord<\n (\n | VoidVar\n | {\n type: \"lookupEntry\"\n value: LookupEntry\n }\n ) & { idx: number }\n >,\n byteLength: moduleErrorLength,\n }\n }\n }\n return null\n })\n\n function getModuleErrorLength(def: {\n tag: \"composite\"\n value: {\n name: string | undefined\n type: number\n typeName: string | undefined\n docs: string[]\n }[]\n }) {\n const preChecks =\n def.value.length === 2 &&\n def.value[0].name === \"index\" &&\n def.value[1].name === \"error\"\n if (!preChecks) return null\n\n const index = getLookupEntryDef(def.value[0].type)\n const error = getLookupEntryDef(def.value[1].type)\n\n return index.type === \"primitive\" &&\n index.value === \"u8\" &&\n error.type === \"array\" &&\n error.value.type === \"primitive\" &&\n error.value.value === \"u8\"\n ? 1 + error.len\n : null\n }\n\n const getCall = () => {\n if (\"call\" in metadata.extrinsic) {\n return metadata.extrinsic.call\n }\n\n const extrinsic = metadata.lookup[metadata.extrinsic.type]\n const call = extrinsic?.params.find((p) => p.name === \"Call\")\n\n return call?.type ?? null\n }\n\n return Object.assign(getLookupEntryDef, { metadata, call: getCall() })\n}\n"],"names":["entry"],"mappings":"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"} \ No newline at end of file diff --git a/packages/metadata-builders/dist/esm/with-cache.mjs b/packages/metadata-builders/dist/esm/with-cache.mjs new file mode 100644 index 0000000..91497bc --- /dev/null +++ b/packages/metadata-builders/dist/esm/with-cache.mjs @@ -0,0 +1,19 @@ +const withCache = (fn, onEnterCircular, onExitCircular) => (input, cache, stack, ...rest) => { + const { id } = input; + if (cache.has(id)) return cache.get(id); + if (stack.has(id)) { + const res = onEnterCircular(() => cache.get(id), input, ...rest); + cache.set(id, res); + return res; + } + stack.add(id); + let result = fn(input, cache, stack, ...rest); + stack.delete(id); + if (cache.has(id)) + result = onExitCircular(result, cache.get(id), input, ...rest); + cache.set(id, result); + return result; +}; + +export { withCache }; +//# sourceMappingURL=with-cache.mjs.map diff --git a/packages/metadata-builders/dist/esm/with-cache.mjs.map b/packages/metadata-builders/dist/esm/with-cache.mjs.map new file mode 100644 index 0000000..ebd7d98 --- /dev/null +++ b/packages/metadata-builders/dist/esm/with-cache.mjs.map @@ -0,0 +1 @@ +{"version":3,"file":"with-cache.mjs","sources":["../../src/with-cache.ts"],"sourcesContent":["import { LookupEntry } from \"./lookups\"\n\ntype FnWithStack, T> = (\n input: LookupEntry,\n cache: Map,\n stack: Set,\n ...rest: Other\n) => T\n\nexport const withCache =\n , T>(\n fn: FnWithStack,\n onEnterCircular: (\n cacheGetter: () => T,\n circular: LookupEntry,\n ...rest: Other\n ) => T,\n onExitCircular: (\n outter: T,\n inner: T,\n circular: LookupEntry,\n ...rest: Other\n ) => T,\n ): FnWithStack =>\n (input, cache, stack, ...rest) => {\n const { id } = input\n if (cache.has(id)) return cache.get(id)!\n\n if (stack.has(id)) {\n const res = onEnterCircular(() => cache.get(id)!, input, ...rest)\n cache.set(id, res)\n return res\n }\n\n stack.add(id)\n let result = fn(input, cache, stack, ...rest)\n stack.delete(id)\n\n if (cache.has(id))\n result = onExitCircular(result, cache.get(id)!, input, ...rest)\n\n cache.set(id, result)\n return result\n }\n"],"names":[],"mappings":"AASO,MAAM,SAAA,GACX,CACE,EAAA,EACA,eAAA,EAKA,mBAOF,CAAC,KAAA,EAAO,KAAA,EAAO,KAAA,EAAA,GAAU,IAAA,KAAS;AAChC,EAAA,MAAM,EAAE,IAAG,GAAI,KAAA;AACf,EAAA,IAAI,MAAM,GAAA,CAAI,EAAE,GAAG,OAAO,KAAA,CAAM,IAAI,EAAE,CAAA;AAEtC,EAAA,IAAI,KAAA,CAAM,GAAA,CAAI,EAAE,CAAA,EAAG;AACjB,IAAA,MAAM,GAAA,GAAM,gBAAgB,MAAM,KAAA,CAAM,IAAI,EAAE,CAAA,EAAI,KAAA,EAAO,GAAG,IAAI,CAAA;AAChE,IAAA,KAAA,CAAM,GAAA,CAAI,IAAI,GAAG,CAAA;AACjB,IAAA,OAAO,GAAA;AAAA,EACT;AAEA,EAAA,KAAA,CAAM,IAAI,EAAE,CAAA;AACZ,EAAA,IAAI,SAAS,EAAA,CAAG,KAAA,EAAO,KAAA,EAAO,KAAA,EAAO,GAAG,IAAI,CAAA;AAC5C,EAAA,KAAA,CAAM,OAAO,EAAE,CAAA;AAEf,EAAA,IAAI,KAAA,CAAM,IAAI,EAAE,CAAA;AACd,IAAA,MAAA,GAAS,cAAA,CAAe,QAAQ,KAAA,CAAM,GAAA,CAAI,EAAE,CAAA,EAAI,KAAA,EAAO,GAAG,IAAI,CAAA;AAEhE,EAAA,KAAA,CAAM,GAAA,CAAI,IAAI,MAAM,CAAA;AACpB,EAAA,OAAO,MAAA;AACT;;;;"} \ No newline at end of file diff --git a/packages/metadata-builders/dist/index.d.ts b/packages/metadata-builders/dist/index.d.ts new file mode 100644 index 0000000..0b5f4c2 --- /dev/null +++ b/packages/metadata-builders/dist/index.d.ts @@ -0,0 +1,152 @@ +import * as scale from '@pezkuwi/bizinikiwi-bindings'; +import { StringRecord, UnifiedMetadata, V14Lookup, Codec } from '@pezkuwi/bizinikiwi-bindings'; + +type SignedPrimitive = "i8" | "i16" | "i32" | "i64" | "i128" | "i256"; +type UnsignedPrimitive = "u8" | "u16" | "u32" | "u64" | "u128" | "u256"; +type MetadataPrimitives = "bool" | "char" | "str" | SignedPrimitive | UnsignedPrimitive; +type PrimitiveVar = { + type: "primitive"; + value: MetadataPrimitives; +}; +type VoidVar = { + type: "void"; +}; +type CompactVar = { + type: "compact"; + isBig: boolean; + size: UnsignedPrimitive; +}; +type BitSequenceVar = { + type: "bitSequence"; + isLSB: boolean; +}; +type AccountId32 = { + type: "AccountId32"; +}; +type AccountId20 = { + type: "AccountId20"; +}; +type TerminalVar = PrimitiveVar | VoidVar | CompactVar | BitSequenceVar | AccountId32 | AccountId20; +type TupleVar = { + type: "tuple"; + value: LookupEntry[]; + innerDocs: Array; +}; +type StructVar = { + type: "struct"; + value: StringRecord; + innerDocs: StringRecord; +}; +type EnumVar = { + type: "enum"; + value: StringRecord<({ + type: "lookupEntry"; + value: LookupEntry; + } | VoidVar | TupleVar | StructVar | ArrayVar) & { + idx: number; + }>; + innerDocs: StringRecord; + byteLength?: number; +}; +type OptionVar = { + type: "option"; + value: LookupEntry; +}; +type ResultVar = { + type: "result"; + value: { + ok: LookupEntry; + ko: LookupEntry; + }; +}; +type SequenceVar = { + type: "sequence"; + value: LookupEntry; +}; +type ArrayVar = { + type: "array"; + value: LookupEntry; + len: number; +}; +type ComposedVar = TupleVar | StructVar | SequenceVar | ArrayVar | OptionVar | ResultVar | EnumVar; +type Var = TerminalVar | ComposedVar; +type LookupEntry = { + id: number; +} & Var; +interface MetadataLookup { + (id: number): LookupEntry; + metadata: UnifiedMetadata; + call: number | null; +} +declare const denormalizeLookup: (lookupData: V14Lookup) => (id: number) => LookupEntry; +declare const getLookupFn: (metadata: UnifiedMetadata) => MetadataLookup; + +declare const getDynamicBuilder: (getLookupEntryDef: MetadataLookup) => { + buildDefinition: (id: number) => Codec; + buildStorage: (pallet: string, entry: string) => { + args: [scale.Encoder, scale.Decoder] & { + enc: scale.Encoder; + dec: scale.Decoder; + } & { + inner: Codec[]; + }; + keys: { + enc: (...args: any[]) => string; + dec: (value: string) => any[]; + }; + value: Codec; + len: number; + fallback: any; + }; + buildEvent: (pallet: string, name: string) => { + codec: Codec; + location: [number, number]; + }; + buildError: (pallet: string, name: string) => { + codec: Codec; + location: [number, number]; + }; + buildViewFn: (pallet: string, entry: string) => { + args: [scale.Encoder, scale.Decoder] & { + enc: scale.Encoder; + dec: scale.Decoder; + } & { + inner: Codec[]; + }; + value: Codec; + }; + buildRuntimeCall: (api: string, method: string) => { + args: [scale.Encoder, scale.Decoder] & { + enc: scale.Encoder; + dec: scale.Decoder; + } & { + inner: Codec[]; + }; + value: Codec; + }; + buildCall: (pallet: string, name: string) => { + codec: Codec; + location: [number, number]; + }; + buildConstant: (pallet: string, constantName: string) => Codec; + ss58Prefix: number | undefined; +}; + +declare const getChecksumBuilder: (getLookupEntryDef: MetadataLookup) => { + buildDefinition: (id: number) => string | null; + buildRuntimeCall: (api: string, method: string) => string | null; + buildStorage: (pallet: string, entry: string) => string | null; + buildViewFns: (pallet: string, entry: string) => string | null; + buildCall: (pallet: string, name: string) => string | null; + buildEvent: (pallet: string, name: string) => string | null; + buildError: (pallet: string, name: string) => string | null; + buildConstant: (pallet: string, constantName: string) => string | null; + buildComposite: (input: VoidVar | TupleVar | StructVar | ArrayVar) => string | null; + buildNamedTuple: (input: StructVar) => string | null; + getAllGeneratedChecksums: () => string[]; +}; + +declare const getLookupCodecBuilder: (lookup: (id: number) => LookupEntry, accountId?: Codec) => (id: number) => Codec; + +export { denormalizeLookup, getChecksumBuilder, getDynamicBuilder, getLookupCodecBuilder, getLookupFn }; +export type { AccountId20, AccountId32, ArrayVar, BitSequenceVar, CompactVar, ComposedVar, EnumVar, LookupEntry, MetadataLookup, MetadataPrimitives, OptionVar, PrimitiveVar, ResultVar, SequenceVar, SignedPrimitive, StructVar, TerminalVar, TupleVar, UnsignedPrimitive, Var, VoidVar }; diff --git a/packages/metadata-builders/dist/index.js b/packages/metadata-builders/dist/index.js new file mode 100644 index 0000000..e2ca77a --- /dev/null +++ b/packages/metadata-builders/dist/index.js @@ -0,0 +1,999 @@ +'use strict'; + +var scale = require('@pezkuwi/bizinikiwi-bindings'); +var utils = require('@pezkuwi/papi-utils'); + +function _interopNamespaceDefault(e) { + var n = Object.create(null); + if (e) { + Object.keys(e).forEach(function (k) { + if (k !== 'default') { + var d = Object.getOwnPropertyDescriptor(e, k); + Object.defineProperty(n, k, d.get ? d : { + enumerable: true, + get: function () { return e[k]; } + }); + } + }); + } + n.default = e; + return Object.freeze(n); +} + +var scale__namespace = /*#__PURE__*/_interopNamespaceDefault(scale); + +const isBytes = (value, nBytes) => value.type === "array" && value.len === nBytes && value.value.type === "primitive" && value.value.value === "u8"; +const _void = { type: "void" }; +const _denormalizeLookup = (lookupData, customMap = () => null) => { + const lookups = /* @__PURE__ */ new Map(); + const from = /* @__PURE__ */ new Set(); + const withCache = (fn) => { + return (id) => { + let entry = lookups.get(id); + if (entry) return entry; + if (from.has(id)) { + const entry2 = { + id + }; + lookups.set(id, entry2); + return entry2; + } + from.add(id); + const value = fn(id); + entry = lookups.get(id); + if (entry) { + Object.assign(entry, value); + } else { + entry = { + id, + ...value + }; + lookups.set(id, entry); + } + from.delete(id); + return entry; + }; + }; + let isAccountId32SearchOn = true; + let isAccountId20SearchOn = true; + const getLookupEntryDef = withCache((id) => { + const custom = customMap(lookupData[id]); + if (custom) return custom; + const { def, path, params } = lookupData[id]; + if (def.tag === "composite") { + if (def.value.length === 0) return _void; + if (def.value.length === 1) { + const inner = getLookupEntryDef(def.value[0].type); + if (isAccountId32SearchOn && path.at(-1) === "AccountId32" && isBytes(inner, 32)) { + isAccountId32SearchOn = false; + return { type: "AccountId32" }; + } + if (isAccountId20SearchOn && path.at(-1) === "AccountId20" && isBytes(inner, 20)) { + isAccountId20SearchOn = false; + return { type: "AccountId20" }; + } + return inner; + } + return getComplexVar(def.value); + } + if (def.tag === "variant") { + if (path.length === 1 && path[0] === "Option" && params.length === 1 && params[0].name === "T") { + const value = getLookupEntryDef(params[0].type); + return value.type === "void" ? ( + // Option would return a Codec which makes no sense + // Therefore, we better treat it as a bool + { type: "primitive", value: "bool" } + ) : { + type: "option", + value + }; + } + if (path.length === 1 && path[0] === "Result" && params.length === 2 && params[0].name === "T" && params[1].name === "E") { + return { + type: "result", + value: { + ok: getLookupEntryDef(params[0].type), + ko: getLookupEntryDef(params[1].type) + } + }; + } + if (def.value.length === 0) return _void; + const enumValue = {}; + const enumDocs = {}; + def.value.forEach((x) => { + const key = x.name; + enumDocs[key] = x.docs; + if (x.fields.length === 0) { + enumValue[key] = { ..._void, idx: x.index }; + return; + } + if (x.fields.length === 1 && !x.fields[0].name) { + enumValue[key] = { + type: "lookupEntry", + value: getLookupEntryDef(x.fields[0].type), + idx: x.index + }; + return; + } + enumValue[key] = { ...getComplexVar(x.fields), idx: x.index }; + }); + return { + type: "enum", + value: enumValue, + innerDocs: enumDocs + }; + } + if (def.tag === "sequence") + return { + type: "sequence", + value: getLookupEntryDef(def.value) + }; + if (def.tag === "array") { + const { len } = def.value; + const value = getLookupEntryDef(def.value.type); + return !len || value.type === "void" ? _void : len > 1 ? { + type: "array", + value, + len: def.value.len + } : value; + } + if (def.tag === "tuple") { + if (def.value.length === 0) return _void; + return def.value.length > 1 ? getArrayOrTuple( + def.value.map((x) => getLookupEntryDef(x)), + def.value.map((x) => lookupData[x].docs) + ) : getLookupEntryDef(def.value[0]); + } + if (def.tag === "primitive") { + return { + type: "primitive", + value: def.value.tag + }; + } + if (def.tag === "compact") { + const translated = getLookupEntryDef(def.value); + if (translated.type === "void") return _void; + const isBig = Number(translated.value.slice(1)) > 32; + return { + type: "compact", + isBig, + size: translated.value + }; + } + return { + type: def.tag, + isLSB: (lookupData[def.value.bitOrderType].path.at(-1) ?? "LSB").toUpperCase().startsWith("LSB") + }; + }); + const getComplexVar = (input) => { + let allKey = true; + const values = {}; + const innerDocs = {}; + input.forEach((x, idx) => { + allKey = allKey && !!x.name; + const key = x.name || idx; + const value = getLookupEntryDef(x.type); + if (value.type !== "void") { + values[key] = value; + innerDocs[key] = x.docs; + } + }); + return allKey ? { + type: "struct", + value: values, + innerDocs + } : getArrayOrTuple(Object.values(values), Object.values(innerDocs)); + }; + const getArrayOrTuple = (values, innerDocs) => { + if (values.every((v) => v.id === values[0].id) && innerDocs.every((doc) => !doc.length)) { + const [value] = values; + return value.type === "void" ? _void : { + type: "array", + value: values[0], + len: values.length + }; + } + return { + type: "tuple", + value: values, + innerDocs + }; + }; + return getLookupEntryDef; +}; +const denormalizeLookup = (lookupData) => _denormalizeLookup(lookupData); +const getLookupFn = (metadata) => { + const getLookupEntryDef = _denormalizeLookup(metadata.lookup, ({ def }) => { + if (def.tag === "composite") { + const moduleErrorLength = getModuleErrorLength(def); + if (moduleErrorLength) { + return { + type: "enum", + innerDocs: {}, + value: Object.fromEntries( + metadata.pallets.map((p) => [ + p.name, + p.errors == null ? { ..._void, idx: p.index } : { + type: "lookupEntry", + value: getLookupEntryDef(p.errors.type), + idx: p.index + } + ]) + ), + byteLength: moduleErrorLength + }; + } + } + return null; + }); + function getModuleErrorLength(def) { + const preChecks = def.value.length === 2 && def.value[0].name === "index" && def.value[1].name === "error"; + if (!preChecks) return null; + const index = getLookupEntryDef(def.value[0].type); + const error = getLookupEntryDef(def.value[1].type); + return index.type === "primitive" && index.value === "u8" && error.type === "array" && error.value.type === "primitive" && error.value.value === "u8" ? 1 + error.len : null; + } + const getCall = () => { + if ("call" in metadata.extrinsic) { + return metadata.extrinsic.call; + } + const extrinsic = metadata.lookup[metadata.extrinsic.type]; + const call = extrinsic?.params.find((p) => p.name === "Call"); + return call?.type ?? null; + }; + return Object.assign(getLookupEntryDef, { metadata, call: getCall() }); +}; + +const withCache = (fn, onEnterCircular, onExitCircular) => (input, cache, stack, ...rest) => { + const { id } = input; + if (cache.has(id)) return cache.get(id); + if (stack.has(id)) { + const res = onEnterCircular(() => cache.get(id), input, ...rest); + cache.set(id, res); + return res; + } + stack.add(id); + let result = fn(input, cache, stack, ...rest); + stack.delete(id); + if (cache.has(id)) + result = onExitCircular(result, cache.get(id), input, ...rest); + cache.set(id, result); + return result; +}; + +const _bytes = scale__namespace.Bin(); +const _buildCodec = (input, cache, stack, _accountId) => { + if (input.type === "primitive") return scale__namespace[input.value]; + if (input.type === "void") return scale__namespace._void; + if (input.type === "AccountId32") return _accountId; + if (input.type === "AccountId20") return scale__namespace.ethAccount; + if (input.type === "compact") + return input.isBig ? scale__namespace.compactBn : scale__namespace.compactNumber; + if (input.type === "bitSequence") return scale__namespace.BitSeq(input.isLSB); + const buildNextCodec = (nextInput) => buildCodec(nextInput, cache, stack, _accountId); + const buildVector = (inner2, len) => { + const innerCodec = buildNextCodec(inner2); + return len ? scale__namespace.Vector(innerCodec, len) : scale__namespace.Vector(innerCodec); + }; + const buildTuple = (value) => scale__namespace.Tuple(...value.map(buildNextCodec)); + const buildStruct = (value) => { + const inner2 = Object.fromEntries( + Object.entries(value).map(([key, value2]) => [key, buildNextCodec(value2)]) + ); + return scale__namespace.Struct(inner2); + }; + if (input.type === "sequence" && input.value.type === "primitive" && input.value.value === "u8") { + return _bytes; + } + if (input.type === "array") { + if (input.value.type === "primitive" && input.value.value === "u8") + return scale__namespace.Bin(input.len); + return buildVector(input.value, input.len); + } + if (input.type === "sequence") return buildVector(input.value); + if (input.type === "tuple") return buildTuple(input.value); + if (input.type === "struct") return buildStruct(input.value); + if (input.type === "option") return scale__namespace.Option(buildNextCodec(input.value)); + if (input.type === "result") + return scale__namespace.Result( + buildNextCodec(input.value.ok), + buildNextCodec(input.value.ko) + ); + const dependencies = Object.values(input.value).map((v) => { + switch (v.type) { + case "void": + return scale__namespace._void; + case "lookupEntry": + return buildNextCodec(v.value); + case "tuple": + return buildTuple(v.value); + case "struct": + return buildStruct(v.value); + case "array": + return buildVector(v.value, v.len); + } + }); + const inner = Object.fromEntries( + Object.keys(input.value).map((key, idx) => { + return [key, dependencies[idx]]; + }) + ); + const indexes = Object.values(input.value).map((x) => x.idx); + const areIndexesSorted = indexes.every((idx, i) => idx === i); + const variantCodec = areIndexesSorted ? scale__namespace.Variant(inner) : scale__namespace.Variant(inner, indexes); + return input.byteLength ? fixedSizeCodec(variantCodec, input.byteLength) : variantCodec; +}; +const buildCodec = withCache(_buildCodec, scale__namespace.Self, (res) => res); +const getLookupCodecBuilder = (lookup, accountId = scale__namespace.AccountId()) => { + const cache = /* @__PURE__ */ new Map(); + const buildDefinition = (id) => buildCodec(lookup(id), cache, /* @__PURE__ */ new Set(), accountId); + return (id) => buildDefinition(id); +}; +const fixedSizeCodec = (codec, size) => { + const allBytes = scale__namespace.Bytes(size); + return scale__namespace.createCodec( + (value) => allBytes.enc(codec.enc(value)), + (data) => codec.dec(allBytes.dec(data)) + ); +}; + +const nullCodec = scale__namespace.enhanceCodec( + scale__namespace._void, + () => void 0, + () => null +); +const getDynamicBuilder = (getLookupEntryDef) => { + const { metadata } = getLookupEntryDef; + let buildDefinition = getLookupCodecBuilder(getLookupEntryDef); + const prefix = metadata.pallets.find((x) => x.name === "System")?.constants.find((x) => x.name === "SS58Prefix"); + let ss58Prefix; + if (prefix) { + try { + const prefixVal = buildDefinition(prefix.type).dec(prefix.value); + if (typeof prefixVal === "number") { + ss58Prefix = prefixVal; + buildDefinition = getLookupCodecBuilder( + getLookupEntryDef, + scale__namespace.AccountId(prefixVal) + ); + } + } catch (_) { + } + } + const storagePallets = /* @__PURE__ */ new Map(); + const buildStorage = (pallet, entry) => { + let storagePallet = storagePallets.get(pallet); + if (!storagePallet) + storagePallets.set(pallet, storagePallet = scale__namespace.Storage(pallet)); + const storageEntry = metadata.pallets.find((x) => x.name === pallet).storage.items.find((s) => s.name === entry); + const withNullVoid = (codec) => codec === scale__namespace._void ? nullCodec : codec; + const storageWithFallback = (len, value2, ...args) => { + const keys = storagePallet(...args); + const [, ...encodersWithHash] = args; + return { + args: scale__namespace.Tuple(...encodersWithHash.map(([codec]) => codec)), + keys, + value: value2, + len, + fallback: storageEntry.modifier === 1 ? value2.dec(storageEntry.fallback) : void 0 + }; + }; + if (storageEntry.type.tag === "plain") + return storageWithFallback( + 0, + withNullVoid(buildDefinition(storageEntry.type.value)), + entry + ); + const { key, value, hashers } = storageEntry.type.value; + const val = withNullVoid(buildDefinition(value)); + const hashes = hashers.map((x) => scale__namespace[x.tag]); + const hashArgs = (() => { + if (hashes.length === 1) { + return [[buildDefinition(key), hashes[0]]]; + } + const keyDef = getLookupEntryDef(key); + switch (keyDef.type) { + case "array": + return hashes.map((hash) => [buildDefinition(keyDef.value.id), hash]); + case "tuple": + return keyDef.value.map((x, idx) => [ + buildDefinition(x.id), + hashes[idx] + ]); + default: + throw new Error("Invalid key type"); + } + })(); + return storageWithFallback(hashes.length, val, entry, ...hashArgs); + }; + const buildEnumEntry = (entry) => { + switch (entry.type) { + case "void": + return scale__namespace._void; + case "lookupEntry": + return buildDefinition(entry.value.id); + case "tuple": + return scale__namespace.Tuple( + ...Object.values(entry.value).map((l) => buildDefinition(l.id)) + ); + case "struct": + return scale__namespace.Struct( + utils.mapObject(entry.value, (x) => buildDefinition(x.id)) + ); + case "array": + return scale__namespace.Vector(buildDefinition(entry.value.id), entry.len); + } + }; + const buildConstant = (pallet, constantName) => { + const storageEntry = metadata.pallets.find((x) => x.name === pallet).constants.find((s) => s.name === constantName); + return buildDefinition(storageEntry.type); + }; + const buildVariant = (type) => (pallet, name) => { + const palletEntry = metadata.pallets.find((x) => x.name === pallet); + const lookup = getLookupEntryDef(palletEntry[type].type); + if (lookup.type !== "enum") throw null; + const entry = lookup.value[name]; + return { + location: [palletEntry.index, entry.idx], + codec: buildEnumEntry(lookup.value[name]) + }; + }; + const buildViewFn = (pallet, entry) => { + const fn = metadata.pallets.find((x) => x.name === pallet)?.viewFns.find((x) => x.name === entry); + if (!fn) throw null; + return { + args: scale__namespace.Tuple(...fn.inputs.map((x) => buildDefinition(x.type))), + value: buildDefinition(fn.output) + }; + }; + const buildRuntimeCall = (api, method) => { + const entry = metadata.apis.find((x) => x.name === api)?.methods.find((x) => x.name === method); + if (!entry) throw null; + return { + args: scale__namespace.Tuple(...entry.inputs.map((x) => buildDefinition(x.type))), + value: buildDefinition(entry.output) + }; + }; + return { + buildDefinition, + buildStorage, + buildEvent: buildVariant("events"), + buildError: buildVariant("errors"), + buildViewFn, + buildRuntimeCall, + buildCall: buildVariant("calls"), + buildConstant, + ss58Prefix + }; +}; + +function buildLookupGraph(lookupFn, lookupLength) { + const result = /* @__PURE__ */ new Map(); + const visited = /* @__PURE__ */ new Set(); + const addEdge = (from, to) => { + if (!result.has(from)) + result.set(from, { + entry: lookupFn(from), + backRefs: /* @__PURE__ */ new Set(), + refs: /* @__PURE__ */ new Set() + }); + if (!result.has(to)) + result.set(to, { + entry: lookupFn(to), + backRefs: /* @__PURE__ */ new Set(), + refs: /* @__PURE__ */ new Set() + }); + result.get(from).refs.add(to); + result.get(to).backRefs.add(from); + }; + for (let i = 0; i < lookupLength; i++) { + const entry = lookupFn(i); + if (i !== entry.id) { + addEdge(i, entry.id); + } + if (visited.has(entry.id)) continue; + visited.add(entry.id); + switch (entry.type) { + case "array": + case "option": + case "sequence": + addEdge(entry.id, entry.value.id); + break; + case "enum": + Object.values(entry.value).forEach((enumEntry) => { + switch (enumEntry.type) { + case "array": + case "lookupEntry": + addEdge(entry.id, enumEntry.value.id); + break; + case "struct": + case "tuple": + Object.values(enumEntry.value).forEach( + (v) => addEdge(entry.id, v.id) + ); + break; + } + }); + break; + case "result": + addEdge(entry.id, entry.value.ok.id); + addEdge(entry.id, entry.value.ko.id); + break; + case "struct": + case "tuple": + Object.values(entry.value).forEach((v) => addEdge(entry.id, v.id)); + break; + } + if (!result.has(entry.id)) { + result.set(entry.id, { + backRefs: /* @__PURE__ */ new Set(), + refs: /* @__PURE__ */ new Set(), + entry + }); + } + } + return result; +} +const subgraphCache = /* @__PURE__ */ new WeakMap(); +function _getSubgraph(id, graph, result, cache) { + if (result.has(id)) return; + const node = graph.get(id); + result.set(id, node); + cache.set(id, result); + node.refs.forEach((ref) => _getSubgraph(ref, graph, result, cache)); + node.backRefs.forEach((ref) => _getSubgraph(ref, graph, result, cache)); +} +function getSubgraph(id, graph) { + if (!subgraphCache.has(graph)) { + subgraphCache.set(graph, /* @__PURE__ */ new Map()); + } + const cache = subgraphCache.get(graph); + if (cache.has(id)) return cache.get(id); + const result = /* @__PURE__ */ new Map(); + _getSubgraph(id, graph, result, cache); + return result; +} +function getStronglyConnectedComponents(graph) { + const tarjanState = /* @__PURE__ */ new Map(); + let index = 0; + const stack = []; + const result = []; + function strongConnect(v) { + const state = { + index, + lowLink: index, + onStack: true + }; + tarjanState.set(v, state); + index++; + stack.push(v); + const edges = graph.get(v).refs; + for (let w of edges) { + const edgeState = tarjanState.get(w); + if (!edgeState) { + strongConnect(w); + state.lowLink = Math.min(state.lowLink, tarjanState.get(w).lowLink); + } else if (edgeState.onStack) { + state.lowLink = Math.min(state.lowLink, edgeState.index); + } + } + if (state.lowLink === state.index) { + const component = /* @__PURE__ */ new Set(); + let poppedNode = -1; + do { + poppedNode = stack.pop(); + tarjanState.get(poppedNode).onStack = false; + component.add(poppedNode); + } while (poppedNode !== v); + result.push(component); + } + } + for (const node of graph.keys()) { + if (!tarjanState.has(node)) { + strongConnect(node); + } + } + return result; +} +function mergeSCCsWithCommonNodes(stronglyConnectedComponents) { + const scc = stronglyConnectedComponents; + const ungroupedCycles = new Set(scc.map((_, i) => i)); + const edges = new Map(scc.map((_, i) => [i, /* @__PURE__ */ new Set()])); + scc.forEach((cycle, i) => { + scc.slice(i + 1).forEach((otherCycle, _j) => { + const j = _j + i + 1; + const combined = /* @__PURE__ */ new Set([...cycle, ...otherCycle]); + if (combined.size !== cycle.size + otherCycle.size) { + edges.get(i).add(j); + edges.get(j).add(i); + } + }); + }); + const groups = []; + while (ungroupedCycles.size) { + const group = /* @__PURE__ */ new Set(); + const toVisit = [ungroupedCycles.values().next().value]; + while (toVisit.length) { + const idx = toVisit.pop(); + if (!ungroupedCycles.has(idx)) continue; + ungroupedCycles.delete(idx); + const cycle = scc[idx]; + cycle.forEach((v) => group.add(Number(v))); + edges.get(idx).forEach((n) => toVisit.push(n)); + } + groups.push(group); + } + return groups; +} + +const textEncoder = new TextEncoder(); +const encodeText = textEncoder.encode.bind(textEncoder); +const getChecksum = (values) => { + const res = new Uint8Array(values.length * 8); + const dv = new DataView(res.buffer); + for (let i = 0; i < values.length; i++) dv.setBigUint64(i * 8, values[i]); + return scale.h64(res); +}; +const getStringChecksum = (values) => getChecksum(values.map((v) => scale.h64(encodeText(v)))); +const shapeIds = { + primitive: 0n, + vector: 1n, + tuple: 2n, + struct: 3n, + option: 4n, + result: 5n, + enum: 6n, + void: 7n +}; +const runtimePrimitiveIds = { + undefined: 0n, + number: 1n, + string: 2n, + bigint: 3n, + boolean: 4n, + bitSequence: 5n, + // {bitsLen: number, bytes: Uint8Array} + byteSequence: 6n, + // Binary + accountId32: 7n, + // SS58String + accountId20: 8n + // EthAccount +}; +const metadataPrimitiveIds = { + bool: runtimePrimitiveIds.boolean, + char: runtimePrimitiveIds.string, + str: runtimePrimitiveIds.string, + u8: runtimePrimitiveIds.number, + u16: runtimePrimitiveIds.number, + u32: runtimePrimitiveIds.number, + u64: runtimePrimitiveIds.bigint, + u128: runtimePrimitiveIds.bigint, + u256: runtimePrimitiveIds.bigint, + i8: runtimePrimitiveIds.number, + i16: runtimePrimitiveIds.number, + i32: runtimePrimitiveIds.number, + i64: runtimePrimitiveIds.bigint, + i128: runtimePrimitiveIds.bigint, + i256: runtimePrimitiveIds.bigint +}; +const structLikeBuilder = (shapeId, input, innerChecksum) => { + const sortedEntries = Object.entries(input).sort( + ([a], [b]) => a.localeCompare(b) + ); + const keysChecksum = getStringChecksum(sortedEntries.map(([key]) => key)); + const valuesChecksum = getChecksum( + sortedEntries.map(([, entry]) => innerChecksum(entry)) + ); + return getChecksum([shapeId, keysChecksum, valuesChecksum]); +}; +const _buildChecksum = (input, buildNextChecksum) => { + if (input.type === "primitive") + return getChecksum([shapeIds.primitive, metadataPrimitiveIds[input.value]]); + if (input.type === "void") return getChecksum([shapeIds.void]); + if (input.type === "compact") + return getChecksum([ + shapeIds.primitive, + runtimePrimitiveIds[input.isBig ? "bigint" : "number"] + ]); + if (input.type === "bitSequence") + return getChecksum([shapeIds.primitive, runtimePrimitiveIds.bitSequence]); + if (input.type === "AccountId32") { + return getChecksum([shapeIds.primitive, runtimePrimitiveIds.accountId32]); + } + if (input.type === "AccountId20") { + return getChecksum([shapeIds.primitive, runtimePrimitiveIds.accountId20]); + } + const buildVector = (entry, length) => { + const innerChecksum = buildNextChecksum(entry); + return getChecksum( + length !== void 0 ? [shapeIds.vector, innerChecksum, BigInt(length)] : [shapeIds.vector, innerChecksum] + ); + }; + if (input.type === "array") { + const innerValue = input.value; + if (innerValue.type === "primitive" && innerValue.value === "u8") { + return getChecksum([ + shapeIds.primitive, + runtimePrimitiveIds.byteSequence, + BigInt(input.len) + ]); + } + return buildVector(innerValue, input.len); + } + if (input.type === "sequence") { + const innerValue = input.value; + if (innerValue.type === "primitive" && innerValue.value === "u8") { + return getChecksum([shapeIds.primitive, runtimePrimitiveIds.byteSequence]); + } + return buildVector(innerValue); + } + const buildTuple = (entries) => getChecksum([shapeIds.tuple, ...entries.map(buildNextChecksum)]); + const buildStruct = (entries) => structLikeBuilder(shapeIds.struct, entries, buildNextChecksum); + if (input.type === "tuple") return buildTuple(input.value); + if (input.type === "struct") return buildStruct(input.value); + if (input.type === "option") + return getChecksum([shapeIds.option, buildNextChecksum(input.value)]); + if (input.type === "result") + return getChecksum([ + shapeIds.result, + buildNextChecksum(input.value.ok), + buildNextChecksum(input.value.ko) + ]); + return structLikeBuilder(shapeIds.enum, input.value, (entry) => { + if (entry.type === "lookupEntry") return buildNextChecksum(entry.value); + switch (entry.type) { + case "void": + return getChecksum([shapeIds.void]); + case "tuple": + return buildTuple(entry.value); + case "struct": + return buildStruct(entry.value); + case "array": + return buildVector(entry.value, entry.len); + } + }); +}; +const sortCyclicGroups = (groups, graph) => { + const getReachableNodes = (group) => { + const result2 = /* @__PURE__ */ new Set(); + const toVisit = Array.from(group); + while (toVisit.length) { + const id = toVisit.pop(); + if (result2.has(id)) continue; + result2.add(id); + graph.get(id)?.refs.forEach((id2) => toVisit.push(id2)); + } + return Array.from(result2); + }; + const result = new Array(); + function dependentsFirst(group) { + if (result.includes(group)) return; + const dependents = groups.filter( + (candidate) => candidate !== group && getReachableNodes(group).some((node) => candidate.has(node)) + ); + dependents.forEach((group2) => dependentsFirst(group2)); + if (result.includes(group)) return; + result.push(group); + } + groups.forEach((group) => dependentsFirst(group)); + return result; +}; +function iterateChecksums(group, iterations, cache, graph) { + const groupReadCache = new Map([...group].map((id) => [id, 0n])); + const groupWriteCache = /* @__PURE__ */ new Map(); + const recursiveBuildChecksum = (entry, skipCache = true) => { + if (!skipCache && (groupReadCache.has(entry.id) || cache.has(entry.id))) { + return groupReadCache.get(entry.id) ?? cache.get(entry.id); + } + const result = _buildChecksum( + entry, + (nextEntry) => recursiveBuildChecksum(nextEntry, false) + ); + if (group.has(entry.id)) { + groupWriteCache.set(entry.id, result); + } else { + cache.set(entry.id, result); + } + return result; + }; + for (let i = 0; i < iterations; i++) { + group.forEach((id) => recursiveBuildChecksum(graph.get(id).entry)); + group.forEach((id) => groupReadCache.set(id, groupWriteCache.get(id))); + } + return groupReadCache; +} +function getMirroredNodes(cyclicGroups, graph) { + const maxSize = cyclicGroups.reduce( + (acc, group) => Math.max(acc, group.size), + 0 + ); + const allEntries = new Set([...graph.values()].map((v) => v.entry.id)); + const resultingChecksums = iterateChecksums( + allEntries, + maxSize, + // Cache won't be used, since it's using the internal one for every node. + /* @__PURE__ */ new Map(), + graph + ); + const checksumToNodes = /* @__PURE__ */ new Map(); + for (const id of allEntries) { + const checksum = resultingChecksums.get(id); + if (checksum == void 0) throw new Error("Unreachable"); + if (!checksumToNodes.has(checksum)) { + checksumToNodes.set(checksum, []); + } + checksumToNodes.get(checksum).push(id); + } + const checksumsWithDuplicates = [...checksumToNodes.entries()].filter( + ([, nodes]) => nodes.length > 1 + ); + const duplicatesMap = {}; + checksumsWithDuplicates.forEach(([, nodes]) => { + nodes.forEach((n) => duplicatesMap[n] = nodes); + }); + return duplicatesMap; +} +const buildChecksum = (entry, cache, graph) => { + if (cache.has(entry.id)) return cache.get(entry.id); + const subGraph = getSubgraph(entry.id, graph); + const cycles = getStronglyConnectedComponents(subGraph).filter( + // SCCs can be of length=1, but for those we're only interested with those that are circular with themselves + (group) => group.size > 1 || isSelfCircular(group, subGraph) + ); + const cyclicGroups = mergeSCCsWithCommonNodes(cycles).filter((group) => { + return !cache.has(group.values().next().value); + }); + const mirrored = getMirroredNodes(cyclicGroups, subGraph); + const sortedCyclicGroups = sortCyclicGroups(cyclicGroups, subGraph); + sortedCyclicGroups.forEach((group) => { + if (cache.has(group.values().next().value)) { + return; + } + const result = iterateChecksums(group, group.size, cache, graph); + group.forEach((id) => { + const checksum = result.get(id); + if (id in mirrored) { + mirrored[id].forEach((id2) => cache.set(id2, checksum)); + } else { + cache.set(id, checksum); + } + }); + }); + const getChecksum2 = (entry2) => { + if (cache.has(entry2.id)) return cache.get(entry2.id); + return _buildChecksum(entry2, getChecksum2); + }; + return getChecksum2(entry); +}; +const isSelfCircular = (group, graph) => { + if (group.size !== 1) return false; + const [id] = group; + return graph.get(id).refs.has(id); +}; +const getChecksumBuilder = (getLookupEntryDef) => { + const { metadata } = getLookupEntryDef; + const graph = buildLookupGraph(getLookupEntryDef, metadata.lookup.length); + const cache = /* @__PURE__ */ new Map(); + const buildDefinition = (id) => buildChecksum(getLookupEntryDef(id), cache, graph); + const buildStorage = (pallet, entry) => { + try { + const storageEntry = metadata.pallets.find((x) => x.name === pallet).storage.items.find((s) => s.name === entry); + if (storageEntry.type.tag === "plain") + return buildDefinition(storageEntry.type.value); + const { key, value } = storageEntry.type.value; + const val = buildDefinition(value); + const returnKey = buildDefinition(key); + return getChecksum([val, returnKey]); + } catch (_) { + return null; + } + }; + const buildViewFns = (pallet, entry) => { + try { + const viewFn = metadata.pallets.find((x) => x.name === pallet)?.viewFns.find((x) => x.name === entry); + if (!viewFn) throw null; + const argNamesChecksum = getStringChecksum( + viewFn.inputs.map((x) => x.name) + ); + const argValuesChecksum = getChecksum( + viewFn.inputs.map((x) => buildDefinition(x.type)) + ); + const outputChecksum = buildDefinition(viewFn.output); + return getChecksum([argNamesChecksum, argValuesChecksum, outputChecksum]); + } catch (_) { + return null; + } + }; + const buildRuntimeCall = (api, method) => { + try { + const entry = metadata.apis.find((x) => x.name === api)?.methods.find((x) => x.name === method); + if (!entry) throw null; + const argNamesChecksum = getStringChecksum( + entry.inputs.map((x) => x.name) + ); + const argValuesChecksum = getChecksum( + entry.inputs.map((x) => buildDefinition(x.type)) + ); + const outputChecksum = buildDefinition(entry.output); + return getChecksum([argNamesChecksum, argValuesChecksum, outputChecksum]); + } catch (_) { + return null; + } + }; + const buildComposite = (input) => { + if (input.type === "void") return getChecksum([0n]); + if (input.type === "tuple") { + const values = Object.values(input.value).map( + (entry) => buildDefinition(entry.id) + ); + return getChecksum([shapeIds.tuple, ...values]); + } + if (input.type === "array") { + return getChecksum([ + shapeIds.vector, + buildDefinition(input.value.id), + BigInt(input.len) + ]); + } + return structLikeBuilder( + shapeIds.struct, + input.value, + (entry) => buildDefinition(entry.id) + ); + }; + const buildNamedTuple = (input) => { + return structLikeBuilder( + shapeIds.tuple, + input.value, + (entry) => buildDefinition(entry.id) + ); + }; + const variantShapeId = { + errors: 1n, + events: 2n, + calls: 3n + }; + const buildVariant = (variantType) => (pallet, name) => { + try { + const palletEntry = metadata.pallets.find((x) => x.name === pallet); + const enumLookup = getLookupEntryDef(palletEntry[variantType].type); + buildDefinition(enumLookup.id); + if (enumLookup.type !== "enum") throw null; + const entry = enumLookup.value[name]; + const valueChecksum = entry.type === "lookupEntry" ? buildDefinition(entry.value.id) : buildComposite(entry); + return getChecksum([variantShapeId[variantType], valueChecksum]); + } catch (_) { + return null; + } + }; + const buildConstant = (pallet, constantName) => { + try { + const storageEntry = metadata.pallets.find((x) => x.name === pallet).constants.find((s) => s.name === constantName); + return buildDefinition(storageEntry.type); + } catch (_) { + return null; + } + }; + const toStringEnhancer = (fn) => (...args) => fn(...args)?.toString(32) ?? null; + return { + buildDefinition: toStringEnhancer(buildDefinition), + buildRuntimeCall: toStringEnhancer(buildRuntimeCall), + buildStorage: toStringEnhancer(buildStorage), + buildViewFns: toStringEnhancer(buildViewFns), + buildCall: toStringEnhancer(buildVariant("calls")), + buildEvent: toStringEnhancer(buildVariant("events")), + buildError: toStringEnhancer(buildVariant("errors")), + buildConstant: toStringEnhancer(buildConstant), + buildComposite: toStringEnhancer(buildComposite), + buildNamedTuple: toStringEnhancer(buildNamedTuple), + getAllGeneratedChecksums: () => Array.from(cache.values()).map((v) => v.toString(32)) + }; +}; + +exports.denormalizeLookup = denormalizeLookup; +exports.getChecksumBuilder = getChecksumBuilder; +exports.getDynamicBuilder = getDynamicBuilder; +exports.getLookupCodecBuilder = getLookupCodecBuilder; +exports.getLookupFn = getLookupFn; +//# sourceMappingURL=index.js.map diff --git a/packages/metadata-builders/dist/index.js.map b/packages/metadata-builders/dist/index.js.map new file mode 100644 index 0000000..2a21910 --- /dev/null +++ b/packages/metadata-builders/dist/index.js.map @@ -0,0 +1 @@ +{"version":3,"file":"index.js","sources":["../src/lookups.ts","../src/with-cache.ts","../src/lookup-codec-builder.ts","../src/dynamic-builder.ts","../src/lookup-graph.ts","../src/checksum-builder.ts"],"sourcesContent":["import type {\n StringRecord,\n UnifiedMetadata,\n V14Lookup,\n} from \"@pezkuwi/bizinikiwi-bindings\"\n\nexport type SignedPrimitive = \"i8\" | \"i16\" | \"i32\" | \"i64\" | \"i128\" | \"i256\"\nexport type UnsignedPrimitive = \"u8\" | \"u16\" | \"u32\" | \"u64\" | \"u128\" | \"u256\"\nexport type MetadataPrimitives =\n | \"bool\"\n | \"char\"\n | \"str\"\n | SignedPrimitive\n | UnsignedPrimitive\n\nexport type PrimitiveVar = {\n type: \"primitive\"\n value: MetadataPrimitives\n}\n\nexport type VoidVar = { type: \"void\" }\nexport type CompactVar = {\n type: \"compact\"\n isBig: boolean\n size: UnsignedPrimitive\n}\nexport type BitSequenceVar = {\n type: \"bitSequence\"\n isLSB: boolean\n}\nexport type AccountId32 = { type: \"AccountId32\" }\nexport type AccountId20 = { type: \"AccountId20\" }\nexport type TerminalVar =\n | PrimitiveVar\n | VoidVar\n | CompactVar\n | BitSequenceVar\n | AccountId32\n | AccountId20\n\n/* Array-like vars:\n * - TupleVar: Mixed types, fixed length\n * - Sequence: One type, arbitrary length\n * - Array: One type, fixed length\n */\nexport type TupleVar = {\n type: \"tuple\"\n value: LookupEntry[]\n innerDocs: Array\n}\nexport type StructVar = {\n type: \"struct\"\n value: StringRecord\n innerDocs: StringRecord\n}\nexport type EnumVar = {\n type: \"enum\"\n value: StringRecord<\n (\n | { type: \"lookupEntry\"; value: LookupEntry }\n | VoidVar\n | TupleVar\n | StructVar\n | ArrayVar\n ) & { idx: number }\n >\n innerDocs: StringRecord\n byteLength?: number\n}\nexport type OptionVar = {\n type: \"option\"\n value: LookupEntry\n}\nexport type ResultVar = {\n type: \"result\"\n value: { ok: LookupEntry; ko: LookupEntry }\n}\nexport type SequenceVar = {\n type: \"sequence\"\n value: LookupEntry\n}\nexport type ArrayVar = {\n type: \"array\"\n value: LookupEntry\n len: number\n}\n\nexport type ComposedVar =\n | TupleVar\n | StructVar\n | SequenceVar\n | ArrayVar\n | OptionVar\n | ResultVar\n | EnumVar\n\nexport type Var = TerminalVar | ComposedVar\n\nexport type LookupEntry = {\n id: number\n} & Var\n\nconst isBytes = (value: LookupEntry, nBytes: number) =>\n value.type === \"array\" &&\n value.len === nBytes &&\n value.value.type === \"primitive\" &&\n value.value.value === \"u8\"\n\nconst _void: VoidVar = { type: \"void\" }\n\nexport interface MetadataLookup {\n (id: number): LookupEntry\n metadata: UnifiedMetadata\n call: number | null\n}\n\nconst _denormalizeLookup = (\n lookupData: V14Lookup,\n customMap: (value: V14Lookup[number]) => Var | null = () => null,\n): ((id: number) => LookupEntry) => {\n const lookups = new Map()\n const from = new Set()\n\n const withCache = (\n fn: (id: number) => Var,\n ): ((id: number) => LookupEntry) => {\n return (id) => {\n let entry = lookups.get(id)\n\n if (entry) return entry\n\n if (from.has(id)) {\n const entry = {\n id,\n } as LookupEntry\n\n lookups.set(id, entry)\n return entry\n }\n\n from.add(id)\n const value = fn(id)\n entry = lookups.get(id)\n\n if (entry) {\n Object.assign(entry, value)\n } else {\n entry = {\n id,\n ...value,\n }\n lookups.set(id, entry!)\n }\n from.delete(id)\n return entry\n }\n }\n\n let isAccountId32SearchOn = true\n let isAccountId20SearchOn = true\n const getLookupEntryDef = withCache((id): Var => {\n const custom = customMap(lookupData[id])\n if (custom) return custom\n\n const { def, path, params } = lookupData[id]\n\n if (def.tag === \"composite\") {\n if (def.value.length === 0) return _void\n\n // used to be a \"pointer\"\n if (def.value.length === 1) {\n const inner = getLookupEntryDef(def.value[0].type as number)\n\n if (\n isAccountId32SearchOn &&\n path.at(-1) === \"AccountId32\" &&\n isBytes(inner, 32)\n ) {\n isAccountId32SearchOn = false\n return { type: \"AccountId32\" }\n }\n\n if (\n isAccountId20SearchOn &&\n path.at(-1) === \"AccountId20\" &&\n isBytes(inner, 20)\n ) {\n isAccountId20SearchOn = false\n return { type: \"AccountId20\" }\n }\n\n return inner\n }\n\n return getComplexVar(def.value)\n }\n\n if (def.tag === \"variant\") {\n if (\n path.length === 1 &&\n path[0] === \"Option\" &&\n params.length === 1 &&\n params[0].name === \"T\"\n ) {\n const value = getLookupEntryDef(params[0].type!)\n return value.type === \"void\"\n ? // Option would return a Codec which makes no sense\n // Therefore, we better treat it as a bool\n { type: \"primitive\", value: \"bool\" }\n : {\n type: \"option\",\n value,\n }\n }\n\n if (\n path.length === 1 &&\n path[0] === \"Result\" &&\n params.length === 2 &&\n params[0].name === \"T\" &&\n params[1].name === \"E\"\n ) {\n return {\n type: \"result\",\n value: {\n ok: getLookupEntryDef(params[0].type as number),\n ko: getLookupEntryDef(params[1].type as number),\n },\n }\n }\n if (def.value.length === 0) return _void\n\n const enumValue: StringRecord =\n {}\n const enumDocs: StringRecord = {}\n\n def.value.forEach((x) => {\n const key = x.name\n enumDocs[key] = x.docs\n\n if (x.fields.length === 0) {\n enumValue[key] = { ..._void, idx: x.index }\n return\n }\n\n if (x.fields.length === 1 && !x.fields[0].name) {\n enumValue[key] = {\n type: \"lookupEntry\",\n value: getLookupEntryDef(x.fields[0].type),\n idx: x.index,\n }\n return\n }\n\n enumValue[key] = { ...getComplexVar(x.fields), idx: x.index }\n })\n\n return {\n type: \"enum\",\n value: enumValue,\n innerDocs: enumDocs,\n }\n }\n\n if (def.tag === \"sequence\")\n return {\n type: \"sequence\",\n value: getLookupEntryDef(def.value as number),\n }\n\n if (def.tag === \"array\") {\n const { len } = def.value\n const value = getLookupEntryDef(def.value.type)\n\n return !len || value.type === \"void\"\n ? _void\n : len > 1\n ? {\n type: \"array\",\n value,\n len: def.value.len,\n }\n : value\n }\n\n if (def.tag === \"tuple\") {\n if (def.value.length === 0) return _void\n\n return def.value.length > 1\n ? getArrayOrTuple(\n def.value.map((x) => getLookupEntryDef(x as number)),\n def.value.map((x) => lookupData[x].docs),\n )\n : getLookupEntryDef(def.value[0] as number) // use to be a \"pointer\"\n }\n\n if (def.tag === \"primitive\") {\n return {\n type: \"primitive\",\n value: def.value.tag,\n }\n }\n\n if (def.tag === \"compact\") {\n const translated = getLookupEntryDef(def.value) as PrimitiveVar | VoidVar\n if (translated.type === \"void\") return _void\n\n const isBig = Number(translated.value.slice(1)) > 32\n\n return {\n type: \"compact\",\n isBig,\n size: translated.value as UnsignedPrimitive,\n }\n }\n\n // bitSequence\n return {\n type: def.tag,\n isLSB: (lookupData[def.value.bitOrderType].path.at(-1) ?? \"LSB\")\n .toUpperCase()\n .startsWith(\"LSB\"),\n }\n })\n\n const getComplexVar = (\n input: Array<{ type: number; name?: string; docs: string[] }>,\n ): TupleVar | StructVar | ArrayVar | VoidVar => {\n let allKey = true\n\n const values: Record = {}\n const innerDocs: Record = {}\n\n input.forEach((x, idx) => {\n allKey = allKey && !!x.name\n const key = x.name || idx\n const value = getLookupEntryDef(x.type as number)\n if (value.type !== \"void\") {\n values[key] = value\n innerDocs[key] = x.docs\n }\n })\n return allKey\n ? {\n type: \"struct\",\n value: values as StringRecord,\n innerDocs: innerDocs as StringRecord,\n }\n : getArrayOrTuple(Object.values(values), Object.values(innerDocs))\n }\n\n const getArrayOrTuple = (\n values: Array,\n innerDocs: Array,\n ): TupleVar | ArrayVar | VoidVar => {\n if (\n values.every((v) => v.id === values[0].id) &&\n innerDocs.every((doc) => !doc.length)\n ) {\n const [value] = values\n return value.type === \"void\"\n ? _void\n : {\n type: \"array\",\n value: values[0],\n len: values.length,\n }\n }\n return {\n type: \"tuple\",\n value: values,\n innerDocs: innerDocs,\n }\n }\n\n return getLookupEntryDef\n}\n\nexport const denormalizeLookup = (lookupData: V14Lookup) =>\n _denormalizeLookup(lookupData)\n\nexport const getLookupFn = (metadata: UnifiedMetadata): MetadataLookup => {\n const getLookupEntryDef = _denormalizeLookup(metadata.lookup, ({ def }) => {\n if (def.tag === \"composite\") {\n const moduleErrorLength = getModuleErrorLength(def)\n if (moduleErrorLength) {\n return {\n type: \"enum\",\n innerDocs: {},\n value: Object.fromEntries(\n metadata.pallets.map((p) => [\n p.name,\n p.errors == null\n ? { ..._void, idx: p.index }\n : {\n type: \"lookupEntry\" as const,\n value: getLookupEntryDef(p.errors.type),\n idx: p.index,\n },\n ]),\n ) as StringRecord<\n (\n | VoidVar\n | {\n type: \"lookupEntry\"\n value: LookupEntry\n }\n ) & { idx: number }\n >,\n byteLength: moduleErrorLength,\n }\n }\n }\n return null\n })\n\n function getModuleErrorLength(def: {\n tag: \"composite\"\n value: {\n name: string | undefined\n type: number\n typeName: string | undefined\n docs: string[]\n }[]\n }) {\n const preChecks =\n def.value.length === 2 &&\n def.value[0].name === \"index\" &&\n def.value[1].name === \"error\"\n if (!preChecks) return null\n\n const index = getLookupEntryDef(def.value[0].type)\n const error = getLookupEntryDef(def.value[1].type)\n\n return index.type === \"primitive\" &&\n index.value === \"u8\" &&\n error.type === \"array\" &&\n error.value.type === \"primitive\" &&\n error.value.value === \"u8\"\n ? 1 + error.len\n : null\n }\n\n const getCall = () => {\n if (\"call\" in metadata.extrinsic) {\n return metadata.extrinsic.call\n }\n\n const extrinsic = metadata.lookup[metadata.extrinsic.type]\n const call = extrinsic?.params.find((p) => p.name === \"Call\")\n\n return call?.type ?? null\n }\n\n return Object.assign(getLookupEntryDef, { metadata, call: getCall() })\n}\n","import { LookupEntry } from \"./lookups\"\n\ntype FnWithStack, T> = (\n input: LookupEntry,\n cache: Map,\n stack: Set,\n ...rest: Other\n) => T\n\nexport const withCache =\n , T>(\n fn: FnWithStack,\n onEnterCircular: (\n cacheGetter: () => T,\n circular: LookupEntry,\n ...rest: Other\n ) => T,\n onExitCircular: (\n outter: T,\n inner: T,\n circular: LookupEntry,\n ...rest: Other\n ) => T,\n ): FnWithStack =>\n (input, cache, stack, ...rest) => {\n const { id } = input\n if (cache.has(id)) return cache.get(id)!\n\n if (stack.has(id)) {\n const res = onEnterCircular(() => cache.get(id)!, input, ...rest)\n cache.set(id, res)\n return res\n }\n\n stack.add(id)\n let result = fn(input, cache, stack, ...rest)\n stack.delete(id)\n\n if (cache.has(id))\n result = onExitCircular(result, cache.get(id)!, input, ...rest)\n\n cache.set(id, result)\n return result\n }\n","import type { Codec, StringRecord } from \"@pezkuwi/bizinikiwi-bindings\"\nimport * as scale from \"@pezkuwi/bizinikiwi-bindings\"\nimport type { LookupEntry } from \"./lookups\"\nimport { withCache } from \"./with-cache\"\n\nconst _bytes = scale.Bin()\n\nconst _buildCodec = (\n input: LookupEntry,\n cache: Map>,\n stack: Set,\n _accountId: Codec,\n): Codec => {\n if (input.type === \"primitive\") return scale[input.value]\n if (input.type === \"void\") return scale._void\n if (input.type === \"AccountId32\") return _accountId\n if (input.type === \"AccountId20\") return scale.ethAccount\n if (input.type === \"compact\")\n return input.isBig ? scale.compactBn : scale.compactNumber\n if (input.type === \"bitSequence\") return scale.BitSeq(input.isLSB)\n\n const buildNextCodec = (nextInput: LookupEntry): Codec =>\n buildCodec(nextInput, cache, stack, _accountId)\n\n const buildVector = (inner: LookupEntry, len?: number) => {\n const innerCodec = buildNextCodec(inner)\n return len ? scale.Vector(innerCodec, len) : scale.Vector(innerCodec)\n }\n\n const buildTuple = (value: LookupEntry[]) =>\n scale.Tuple(...value.map(buildNextCodec))\n\n const buildStruct = (value: StringRecord) => {\n const inner = Object.fromEntries(\n Object.entries(value).map(([key, value]) => [key, buildNextCodec(value)]),\n ) as StringRecord>\n return scale.Struct(inner)\n }\n\n if (\n input.type === \"sequence\" &&\n input.value.type === \"primitive\" &&\n input.value.value === \"u8\"\n ) {\n return _bytes\n }\n\n if (input.type === \"array\") {\n // Bytes case\n if (input.value.type === \"primitive\" && input.value.value === \"u8\")\n return scale.Bin(input.len)\n\n return buildVector(input.value, input.len)\n }\n\n if (input.type === \"sequence\") return buildVector(input.value)\n if (input.type === \"tuple\") return buildTuple(input.value)\n if (input.type === \"struct\") return buildStruct(input.value)\n\n if (input.type === \"option\") return scale.Option(buildNextCodec(input.value))\n\n if (input.type === \"result\")\n return scale.Result(\n buildNextCodec(input.value.ok),\n buildNextCodec(input.value.ko),\n )\n\n // it has to be an enum by now\n const dependencies = Object.values(input.value).map((v) => {\n switch (v.type) {\n case \"void\":\n return scale._void\n case \"lookupEntry\":\n return buildNextCodec(v.value)\n case \"tuple\":\n return buildTuple(v.value)\n case \"struct\":\n return buildStruct(v.value)\n case \"array\":\n return buildVector(v.value, v.len)\n }\n })\n\n const inner = Object.fromEntries(\n Object.keys(input.value).map((key, idx) => {\n return [key, dependencies[idx]]\n }),\n ) as StringRecord>\n\n const indexes = Object.values(input.value).map((x) => x.idx)\n const areIndexesSorted = indexes.every((idx, i) => idx === i)\n\n const variantCodec = areIndexesSorted\n ? scale.Variant(inner)\n : scale.Variant(inner, indexes as any)\n return input.byteLength\n ? fixedSizeCodec(variantCodec, input.byteLength)\n : variantCodec\n}\nconst buildCodec = withCache(_buildCodec, scale.Self, (res) => res)\n\nexport const getLookupCodecBuilder = (\n lookup: (id: number) => LookupEntry,\n accountId = scale.AccountId(),\n) => {\n const cache = new Map()\n const buildDefinition = (id: number) =>\n buildCodec(lookup(id), cache, new Set(), accountId)\n\n return (id: number) => buildDefinition(id)\n}\n\nconst fixedSizeCodec = (codec: Codec, size: number): Codec => {\n const allBytes = scale.Bytes(size)\n return scale.createCodec(\n (value: T) => allBytes.enc(codec.enc(value)),\n (data) => codec.dec(allBytes.dec(data)),\n )\n}\n","import type { Codec, StringRecord } from \"@pezkuwi/bizinikiwi-bindings\"\nimport * as scale from \"@pezkuwi/bizinikiwi-bindings\"\nimport { mapObject } from \"@pezkuwi/papi-utils\"\nimport type { EnumVar, MetadataLookup } from \"./lookups\"\nimport { getLookupCodecBuilder } from \"./lookup-codec-builder\"\n\nconst nullCodec = scale.enhanceCodec(\n scale._void,\n () => undefined,\n () => null,\n)\n\nexport const getDynamicBuilder = (getLookupEntryDef: MetadataLookup) => {\n const { metadata } = getLookupEntryDef\n let buildDefinition = getLookupCodecBuilder(getLookupEntryDef)\n\n const prefix = metadata.pallets\n .find((x) => x.name === \"System\")\n ?.constants.find((x) => x.name === \"SS58Prefix\")\n\n let ss58Prefix: number | undefined\n if (prefix) {\n try {\n const prefixVal = buildDefinition(prefix.type).dec(prefix.value)\n if (typeof prefixVal === \"number\") {\n ss58Prefix = prefixVal\n buildDefinition = getLookupCodecBuilder(\n getLookupEntryDef,\n scale.AccountId(prefixVal),\n )\n }\n } catch (_) {}\n }\n\n const storagePallets = new Map>()\n\n const buildStorage = (pallet: string, entry: string) => {\n let storagePallet = storagePallets.get(pallet)\n if (!storagePallet)\n storagePallets.set(pallet, (storagePallet = scale.Storage(pallet)))\n\n const storageEntry = metadata.pallets\n .find((x) => x.name === pallet)!\n .storage!.items.find((s) => s.name === entry)!\n\n // if val is `void` it decodes to `undefined`, making it impossible\n // to differentiate from a non-existant key\n // therefore, if the key exists => null, if it doesn't => undefined\n const withNullVoid = (codec: Codec) =>\n codec === scale._void ? nullCodec : codec\n\n const storageWithFallback = (\n len: number,\n value: Codec,\n ...args: Parameters>\n ) => {\n const keys = storagePallet!(...args)\n const [, ...encodersWithHash] = args\n return {\n args: scale.Tuple(...encodersWithHash.map(([codec]) => codec)),\n keys,\n value,\n len,\n fallback:\n storageEntry.modifier === 1\n ? value.dec(storageEntry.fallback)\n : undefined,\n }\n }\n\n if (storageEntry.type.tag === \"plain\")\n return storageWithFallback(\n 0,\n withNullVoid(buildDefinition(storageEntry.type.value)),\n entry,\n )\n\n const { key, value, hashers } = storageEntry.type.value\n const val = withNullVoid(buildDefinition(value))\n const hashes = hashers.map((x) => scale[x.tag])\n\n const hashArgs: scale.EncoderWithHash[] = (() => {\n if (hashes.length === 1) {\n return [[buildDefinition(key), hashes[0]]]\n }\n\n const keyDef = getLookupEntryDef(key)\n\n switch (keyDef.type) {\n case \"array\":\n return hashes.map((hash) => [buildDefinition(keyDef.value.id), hash])\n case \"tuple\":\n return keyDef.value.map((x, idx) => [\n buildDefinition(x.id),\n hashes[idx],\n ])\n default:\n throw new Error(\"Invalid key type\")\n }\n })()\n\n return storageWithFallback(hashes.length, val, entry, ...hashArgs)\n }\n\n const buildEnumEntry = (\n entry: EnumVar[\"value\"][keyof EnumVar[\"value\"]],\n ): Codec => {\n switch (entry.type) {\n case \"void\":\n return scale._void\n case \"lookupEntry\":\n return buildDefinition(entry.value.id)\n case \"tuple\":\n return scale.Tuple(\n ...Object.values(entry.value).map((l) => buildDefinition(l.id)),\n )\n case \"struct\":\n return scale.Struct(\n mapObject(entry.value, (x) => buildDefinition(x.id)) as StringRecord<\n Codec\n >,\n )\n case \"array\":\n return scale.Vector(buildDefinition(entry.value.id), entry.len)\n }\n }\n\n const buildConstant = (pallet: string, constantName: string) => {\n const storageEntry = metadata.pallets\n .find((x) => x.name === pallet)!\n .constants!.find((s) => s.name === constantName)!\n\n return buildDefinition(storageEntry.type as number)\n }\n\n const buildVariant =\n (type: \"errors\" | \"events\" | \"calls\") =>\n (\n pallet: string,\n name: string,\n ): {\n codec: Codec\n location: [number, number]\n } => {\n const palletEntry = metadata.pallets.find((x) => x.name === pallet)!\n const lookup = getLookupEntryDef(palletEntry[type]!.type)\n if (lookup.type !== \"enum\") throw null\n const entry = lookup.value[name]\n\n return {\n location: [palletEntry.index, entry.idx],\n codec: buildEnumEntry(lookup.value[name]),\n }\n }\n\n const buildViewFn = (pallet: string, entry: string) => {\n const fn = metadata.pallets\n .find((x) => x.name === pallet)\n ?.viewFns.find((x) => x.name === entry)\n if (!fn) throw null\n\n return {\n args: scale.Tuple(...fn.inputs.map((x) => buildDefinition(x.type))),\n value: buildDefinition(fn.output),\n }\n }\n\n const buildRuntimeCall = (api: string, method: string) => {\n const entry = metadata.apis\n .find((x) => x.name === api)\n ?.methods.find((x) => x.name === method)\n if (!entry) throw null\n\n return {\n args: scale.Tuple(...entry.inputs.map((x) => buildDefinition(x.type))),\n value: buildDefinition(entry.output),\n }\n }\n\n return {\n buildDefinition,\n buildStorage,\n buildEvent: buildVariant(\"events\"),\n buildError: buildVariant(\"errors\"),\n buildViewFn,\n buildRuntimeCall,\n buildCall: buildVariant(\"calls\"),\n buildConstant,\n ss58Prefix,\n }\n}\n","import { LookupEntry } from \"./lookups\"\n\nexport type LookupGraph = Map<\n number,\n { entry: LookupEntry; backRefs: Set; refs: Set }\n>\n\nexport function buildLookupGraph(\n lookupFn: (id: number) => LookupEntry,\n lookupLength: number,\n): LookupGraph {\n const result: LookupGraph = new Map()\n const visited = new Set()\n\n const addEdge = (from: number, to: number) => {\n if (!result.has(from))\n result.set(from, {\n entry: lookupFn(from),\n backRefs: new Set(),\n refs: new Set(),\n })\n if (!result.has(to))\n result.set(to, {\n entry: lookupFn(to),\n backRefs: new Set(),\n refs: new Set(),\n })\n result.get(from)!.refs.add(to)\n result.get(to)!.backRefs.add(from)\n }\n\n for (let i = 0; i < lookupLength; i++) {\n const entry = lookupFn(i)\n if (i !== entry.id) {\n // Lookup solved a pointer, but we still need to add that node into our\n // graph in case someone access it from there.\n addEdge(i, entry.id)\n }\n if (visited.has(entry.id)) continue\n visited.add(entry.id)\n\n switch (entry.type) {\n case \"array\":\n case \"option\":\n case \"sequence\":\n addEdge(entry.id, entry.value.id)\n break\n case \"enum\":\n Object.values(entry.value).forEach((enumEntry) => {\n switch (enumEntry.type) {\n case \"array\":\n case \"lookupEntry\":\n addEdge(entry.id, enumEntry.value.id)\n break\n case \"struct\":\n case \"tuple\":\n Object.values(enumEntry.value).forEach((v) =>\n addEdge(entry.id, v.id),\n )\n break\n }\n })\n break\n case \"result\":\n addEdge(entry.id, entry.value.ok.id)\n addEdge(entry.id, entry.value.ko.id)\n break\n case \"struct\":\n case \"tuple\":\n Object.values(entry.value).forEach((v) => addEdge(entry.id, v.id))\n break\n }\n\n // It could be that this node is not being referenced by any other type\n // nor it references anything. We still have to add it into the graph.\n if (!result.has(entry.id)) {\n result.set(entry.id, {\n backRefs: new Set(),\n refs: new Set(),\n entry,\n })\n }\n }\n\n return result\n}\n\nconst subgraphCache = new WeakMap>()\nfunction _getSubgraph(\n id: number,\n graph: LookupGraph,\n result: LookupGraph,\n cache: Map,\n) {\n if (result.has(id)) return\n const node = graph.get(id)!\n result.set(id, node)\n cache.set(id, result)\n\n node.refs.forEach((ref) => _getSubgraph(ref, graph, result, cache))\n node.backRefs.forEach((ref) => _getSubgraph(ref, graph, result, cache))\n}\n\nexport function getSubgraph(id: number, graph: LookupGraph) {\n if (!subgraphCache.has(graph)) {\n subgraphCache.set(graph, new Map())\n }\n const cache = subgraphCache.get(graph)!\n if (cache.has(id)) return cache.get(id)!\n\n const result: LookupGraph = new Map()\n _getSubgraph(id, graph, result, cache)\n return result\n}\n\nexport function getStronglyConnectedComponents(graph: LookupGraph) {\n // Tarjan's strongly connected components\n const tarjanState = new Map<\n number,\n {\n index: number\n lowLink: number\n onStack: boolean\n }\n >()\n let index = 0\n const stack: number[] = []\n const result: Array> = []\n\n function strongConnect(v: number): void {\n const state = {\n index: index,\n lowLink: index,\n onStack: true,\n }\n tarjanState.set(v, state)\n index++\n stack.push(v)\n\n const edges = graph.get(v)!.refs\n for (let w of edges) {\n const edgeState = tarjanState.get(w)\n if (!edgeState) {\n strongConnect(w)\n state.lowLink = Math.min(state.lowLink, tarjanState.get(w)!.lowLink)\n } else if (edgeState.onStack) {\n state.lowLink = Math.min(state.lowLink, edgeState.index)\n }\n }\n\n if (state.lowLink === state.index) {\n const component = new Set()\n\n let poppedNode = -1\n do {\n poppedNode = stack.pop()!\n tarjanState.get(poppedNode)!.onStack = false\n component.add(poppedNode)\n } while (poppedNode !== v)\n\n result.push(component)\n }\n }\n\n for (const node of graph.keys()) {\n if (!tarjanState.has(node)) {\n strongConnect(node)\n }\n }\n\n return result\n}\n\nexport function mergeSCCsWithCommonNodes(\n stronglyConnectedComponents: Array>,\n) {\n /**\n * For Nodes that are shared between two sets of SCCs, we need to calculate\n * the checksum for the both of them, which wouldn't work (it would give\n * different checksums).\n * So we merge the SCCs that are using shared nodes into one group.\n */\n const scc = stronglyConnectedComponents\n const ungroupedCycles = new Set(scc.map((_, i) => i))\n const edges = new Map(scc.map((_, i) => [i, new Set()]))\n scc.forEach((cycle, i) => {\n scc.slice(i + 1).forEach((otherCycle, _j) => {\n const j = _j + i + 1\n const combined = new Set([...cycle, ...otherCycle])\n if (combined.size !== cycle.size + otherCycle.size) {\n edges.get(i)!.add(j)\n edges.get(j)!.add(i)\n }\n })\n })\n const groups: Array> = []\n\n while (ungroupedCycles.size) {\n const group = new Set()\n const toVisit = [ungroupedCycles.values().next().value!]\n while (toVisit.length) {\n const idx = toVisit.pop()!\n if (!ungroupedCycles.has(idx)) continue\n ungroupedCycles.delete(idx)\n\n const cycle = scc[idx]\n cycle.forEach((v) => group.add(Number(v)))\n edges.get(idx)!.forEach((n) => toVisit.push(n))\n }\n groups.push(group)\n }\n\n return groups\n}\n","import type { StringRecord } from \"@pezkuwi/bizinikiwi-bindings\"\nimport { h64 } from \"@pezkuwi/bizinikiwi-bindings\"\nimport {\n LookupGraph,\n buildLookupGraph,\n getStronglyConnectedComponents,\n getSubgraph,\n mergeSCCsWithCommonNodes,\n} from \"./lookup-graph\"\nimport {\n ArrayVar,\n LookupEntry,\n MetadataLookup,\n MetadataPrimitives,\n StructVar,\n TupleVar,\n VoidVar,\n} from \"./lookups\"\n\nconst textEncoder = new TextEncoder()\nconst encodeText = textEncoder.encode.bind(textEncoder)\n\nconst getChecksum = (values: Array) => {\n const res = new Uint8Array(values.length * 8)\n const dv = new DataView(res.buffer)\n\n for (let i = 0; i < values.length; i++) dv.setBigUint64(i * 8, values[i])\n\n return h64(res)\n}\nconst getStringChecksum = (values: Array) =>\n getChecksum(values.map((v) => h64(encodeText(v))))\n\ntype Shape =\n | \"primitive\"\n | \"void\"\n | \"vector\"\n | \"tuple\"\n | \"struct\"\n | \"option\"\n | \"result\"\n | \"enum\"\nconst shapeIds: Record = {\n primitive: 0n,\n vector: 1n,\n tuple: 2n,\n struct: 3n,\n option: 4n,\n result: 5n,\n enum: 6n,\n void: 7n,\n}\n\ntype RuntimePrimitives =\n | \"undefined\"\n | \"number\"\n | \"string\"\n | \"bigint\"\n | \"boolean\"\n | \"bitSequence\"\n | \"byteSequence\"\n | \"accountId32\"\n | \"accountId20\"\n\nconst runtimePrimitiveIds: Record = {\n undefined: 0n,\n number: 1n,\n string: 2n,\n bigint: 3n,\n boolean: 4n,\n bitSequence: 5n, // {bitsLen: number, bytes: Uint8Array}\n byteSequence: 6n, // Binary\n accountId32: 7n, // SS58String\n accountId20: 8n, // EthAccount\n}\n\nconst metadataPrimitiveIds: Record = {\n bool: runtimePrimitiveIds.boolean,\n char: runtimePrimitiveIds.string,\n str: runtimePrimitiveIds.string,\n u8: runtimePrimitiveIds.number,\n u16: runtimePrimitiveIds.number,\n u32: runtimePrimitiveIds.number,\n u64: runtimePrimitiveIds.bigint,\n u128: runtimePrimitiveIds.bigint,\n u256: runtimePrimitiveIds.bigint,\n i8: runtimePrimitiveIds.number,\n i16: runtimePrimitiveIds.number,\n i32: runtimePrimitiveIds.number,\n i64: runtimePrimitiveIds.bigint,\n i128: runtimePrimitiveIds.bigint,\n i256: runtimePrimitiveIds.bigint,\n}\n\nconst structLikeBuilder = (\n shapeId: bigint,\n input: StringRecord,\n innerChecksum: (value: T) => bigint,\n) => {\n const sortedEntries = Object.entries(input).sort(([a], [b]) =>\n a.localeCompare(b),\n )\n const keysChecksum = getStringChecksum(sortedEntries.map(([key]) => key))\n const valuesChecksum = getChecksum(\n sortedEntries.map(([, entry]) => innerChecksum(entry)),\n )\n\n return getChecksum([shapeId, keysChecksum, valuesChecksum])\n}\n\nconst _buildChecksum = (\n input: LookupEntry,\n buildNextChecksum: (entry: LookupEntry) => bigint,\n): bigint => {\n if (input.type === \"primitive\")\n return getChecksum([shapeIds.primitive, metadataPrimitiveIds[input.value]])\n\n if (input.type === \"void\") return getChecksum([shapeIds.void])\n\n if (input.type === \"compact\")\n return getChecksum([\n shapeIds.primitive,\n runtimePrimitiveIds[input.isBig ? \"bigint\" : \"number\"],\n ])\n\n if (input.type === \"bitSequence\")\n return getChecksum([shapeIds.primitive, runtimePrimitiveIds.bitSequence])\n\n if (input.type === \"AccountId32\") {\n return getChecksum([shapeIds.primitive, runtimePrimitiveIds.accountId32])\n }\n\n if (input.type === \"AccountId20\") {\n return getChecksum([shapeIds.primitive, runtimePrimitiveIds.accountId20])\n }\n\n const buildVector = (entry: LookupEntry, length?: number) => {\n const innerChecksum = buildNextChecksum(entry)\n return getChecksum(\n length !== undefined\n ? [shapeIds.vector, innerChecksum, BigInt(length)]\n : [shapeIds.vector, innerChecksum],\n )\n }\n\n if (input.type === \"array\") {\n const innerValue = input.value\n if (innerValue.type === \"primitive\" && innerValue.value === \"u8\") {\n return getChecksum([\n shapeIds.primitive,\n runtimePrimitiveIds.byteSequence,\n BigInt(input.len),\n ])\n }\n return buildVector(innerValue, input.len)\n }\n\n if (input.type === \"sequence\") {\n const innerValue = input.value\n if (innerValue.type === \"primitive\" && innerValue.value === \"u8\") {\n return getChecksum([shapeIds.primitive, runtimePrimitiveIds.byteSequence])\n }\n return buildVector(innerValue)\n }\n\n const buildTuple = (entries: LookupEntry[]) =>\n getChecksum([shapeIds.tuple, ...entries.map(buildNextChecksum)])\n\n const buildStruct = (entries: StringRecord) =>\n structLikeBuilder(shapeIds.struct, entries, buildNextChecksum)\n\n if (input.type === \"tuple\") return buildTuple(input.value)\n\n if (input.type === \"struct\") return buildStruct(input.value)\n\n if (input.type === \"option\")\n return getChecksum([shapeIds.option, buildNextChecksum(input.value)])\n\n if (input.type === \"result\")\n return getChecksum([\n shapeIds.result,\n buildNextChecksum(input.value.ok),\n buildNextChecksum(input.value.ko),\n ])\n\n return structLikeBuilder(shapeIds.enum, input.value, (entry) => {\n if (entry.type === \"lookupEntry\") return buildNextChecksum(entry.value)\n switch (entry.type) {\n case \"void\":\n return getChecksum([shapeIds.void])\n case \"tuple\":\n return buildTuple(entry.value)\n case \"struct\":\n return buildStruct(entry.value)\n case \"array\":\n return buildVector(entry.value, entry.len)\n }\n })\n}\n\nconst sortCyclicGroups = (groups: Array>, graph: LookupGraph) => {\n const getReachableNodes = (group: Set) => {\n const result = new Set()\n const toVisit = Array.from(group)\n while (toVisit.length) {\n const id = toVisit.pop()!\n if (result.has(id)) continue\n result.add(id)\n\n graph.get(id)?.refs.forEach((id) => toVisit.push(id))\n }\n\n return Array.from(result)\n }\n\n const result: Array> = new Array()\n\n function dependentsFirst(group: Set) {\n if (result.includes(group)) return\n const dependents = groups.filter(\n (candidate) =>\n candidate !== group &&\n getReachableNodes(group).some((node) => candidate.has(node)),\n )\n dependents.forEach((group) => dependentsFirst(group))\n if (result.includes(group)) return\n result.push(group)\n }\n\n groups.forEach((group) => dependentsFirst(group))\n return result\n}\n\nfunction iterateChecksums(\n group: Set,\n iterations: number,\n cache: Map,\n graph: LookupGraph,\n) {\n // Keep the values that are getting changed on each iteration in a separate\n // cache, because two nodes referencing the same one should read the same\n // previous iteration checksum for that node.\n const groupReadCache = new Map([...group].map((id) => [id, 0n]))\n const groupWriteCache = new Map()\n\n const recursiveBuildChecksum = (\n entry: LookupEntry,\n // The first call has to skip the cache, otherwise it would return the\n // previous iteration result.\n skipCache = true,\n ): bigint => {\n if (!skipCache && (groupReadCache.has(entry.id) || cache.has(entry.id))) {\n return groupReadCache.get(entry.id) ?? cache.get(entry.id)!\n }\n const result = _buildChecksum(entry, (nextEntry) =>\n recursiveBuildChecksum(nextEntry, false),\n )\n if (group.has(entry.id)) {\n groupWriteCache.set(entry.id, result)\n } else {\n cache.set(entry.id, result)\n }\n return result\n }\n\n for (let i = 0; i < iterations; i++) {\n group.forEach((id) => recursiveBuildChecksum(graph.get(id)!.entry))\n\n group.forEach((id) => groupReadCache.set(id, groupWriteCache.get(id)!))\n }\n\n return groupReadCache\n}\n\nfunction getMirroredNodes(\n cyclicGroups: Array>,\n graph: LookupGraph,\n) {\n const maxSize = cyclicGroups.reduce(\n (acc, group) => Math.max(acc, group.size),\n 0,\n )\n const allEntries = new Set([...graph.values()].map((v) => v.entry.id))\n\n const resultingChecksums = iterateChecksums(\n allEntries,\n maxSize,\n // Cache won't be used, since it's using the internal one for every node.\n new Map(),\n graph,\n )\n\n const checksumToNodes = new Map()\n for (const id of allEntries) {\n const checksum = resultingChecksums.get(id)\n if (checksum == undefined) throw new Error(\"Unreachable\")\n if (!checksumToNodes.has(checksum)) {\n checksumToNodes.set(checksum, [])\n }\n checksumToNodes.get(checksum)!.push(id)\n }\n\n const checksumsWithDuplicates = [...checksumToNodes.entries()].filter(\n ([, nodes]) => nodes.length > 1,\n )\n\n const duplicatesMap: Record = {}\n checksumsWithDuplicates.forEach(([, nodes]) => {\n nodes.forEach((n) => (duplicatesMap[n] = nodes))\n })\n\n return duplicatesMap\n}\n\nconst buildChecksum = (\n entry: LookupEntry,\n cache: Map,\n graph: LookupGraph,\n) => {\n if (cache.has(entry.id)) return cache.get(entry.id)!\n\n const subGraph = getSubgraph(entry.id, graph)\n\n const cycles = getStronglyConnectedComponents(subGraph).filter(\n // SCCs can be of length=1, but for those we're only interested with those that are circular with themselves\n (group) => group.size > 1 || isSelfCircular(group, subGraph),\n )\n const cyclicGroups = mergeSCCsWithCommonNodes(cycles).filter((group) => {\n // Exclude groups that were previously calculated\n return !cache.has(group.values().next().value!)\n })\n const mirrored = getMirroredNodes(cyclicGroups, subGraph)\n const sortedCyclicGroups = sortCyclicGroups(cyclicGroups, subGraph)\n\n sortedCyclicGroups.forEach((group) => {\n if (cache.has(group.values().next().value!)) {\n // exclude mirrored groups\n return\n }\n\n const result = iterateChecksums(group, group.size, cache, graph)\n group.forEach((id) => {\n const checksum = result.get(id)!\n if (id in mirrored) {\n mirrored[id].forEach((id) => cache.set(id, checksum))\n } else {\n cache.set(id, checksum)\n }\n })\n })\n\n const getChecksum = (entry: LookupEntry) => {\n if (cache.has(entry.id)) return cache.get(entry.id)!\n return _buildChecksum(entry, getChecksum)\n }\n\n return getChecksum(entry)\n}\n\nconst isSelfCircular = (group: Set, graph: LookupGraph) => {\n if (group.size !== 1) return false\n const [id] = group\n\n return graph.get(id)!.refs.has(id)\n}\n\nexport const getChecksumBuilder = (getLookupEntryDef: MetadataLookup) => {\n const { metadata } = getLookupEntryDef\n const graph = buildLookupGraph(getLookupEntryDef, metadata.lookup.length)\n\n const cache = new Map()\n\n const buildDefinition = (id: number): bigint =>\n buildChecksum(getLookupEntryDef(id), cache, graph)\n\n const buildStorage = (pallet: string, entry: string): bigint | null => {\n try {\n const storageEntry = metadata.pallets\n .find((x) => x.name === pallet)!\n .storage!.items.find((s) => s.name === entry)!\n\n if (storageEntry.type.tag === \"plain\")\n return buildDefinition(storageEntry.type.value)\n\n const { key, value } = storageEntry.type.value\n const val = buildDefinition(value)\n const returnKey = buildDefinition(key)\n return getChecksum([val, returnKey])\n } catch (_) {\n return null\n }\n }\n\n const buildViewFns = (pallet: string, entry: string): bigint | null => {\n try {\n const viewFn = metadata.pallets\n .find((x) => x.name === pallet)\n ?.viewFns.find((x) => x.name === entry)\n if (!viewFn) throw null\n\n const argNamesChecksum = getStringChecksum(\n viewFn.inputs.map((x) => x.name),\n )\n const argValuesChecksum = getChecksum(\n viewFn.inputs.map((x) => buildDefinition(x.type)),\n )\n const outputChecksum = buildDefinition(viewFn.output)\n\n return getChecksum([argNamesChecksum, argValuesChecksum, outputChecksum])\n } catch (_) {\n return null\n }\n }\n\n const buildRuntimeCall = (api: string, method: string): bigint | null => {\n try {\n const entry = metadata.apis\n .find((x) => x.name === api)\n ?.methods.find((x) => x.name === method)\n if (!entry) throw null\n\n const argNamesChecksum = getStringChecksum(\n entry.inputs.map((x) => x.name),\n )\n const argValuesChecksum = getChecksum(\n entry.inputs.map((x) => buildDefinition(x.type)),\n )\n const outputChecksum = buildDefinition(entry.output)\n\n return getChecksum([argNamesChecksum, argValuesChecksum, outputChecksum])\n } catch (_) {\n return null\n }\n }\n\n const buildComposite = (\n input: TupleVar | StructVar | VoidVar | ArrayVar,\n ): bigint => {\n if (input.type === \"void\") return getChecksum([0n])\n\n if (input.type === \"tuple\") {\n const values = Object.values(input.value).map((entry) =>\n buildDefinition(entry.id),\n )\n\n return getChecksum([shapeIds.tuple, ...values])\n }\n\n if (input.type === \"array\") {\n return getChecksum([\n shapeIds.vector,\n buildDefinition(input.value.id),\n BigInt(input.len),\n ])\n }\n\n // Otherwise struct\n return structLikeBuilder(shapeIds.struct, input.value, (entry) =>\n buildDefinition(entry.id),\n )\n }\n\n const buildNamedTuple = (input: StructVar): bigint => {\n return structLikeBuilder(shapeIds.tuple, input.value, (entry) =>\n buildDefinition(entry.id),\n )\n }\n\n const variantShapeId = {\n errors: 1n,\n events: 2n,\n calls: 3n,\n }\n const buildVariant =\n (variantType: \"errors\" | \"events\" | \"calls\") =>\n (pallet: string, name: string): bigint | null => {\n try {\n const palletEntry = metadata.pallets.find((x) => x.name === pallet)!\n const enumLookup = getLookupEntryDef(palletEntry[variantType]!.type)\n buildDefinition(enumLookup.id)\n\n if (enumLookup.type !== \"enum\") throw null\n const entry = enumLookup.value[name]\n const valueChecksum =\n entry.type === \"lookupEntry\"\n ? buildDefinition(entry.value.id)\n : buildComposite(entry)\n return getChecksum([variantShapeId[variantType], valueChecksum])\n } catch (_) {\n return null\n }\n }\n\n const buildConstant = (\n pallet: string,\n constantName: string,\n ): bigint | null => {\n try {\n const storageEntry = metadata.pallets\n .find((x) => x.name === pallet)!\n .constants!.find((s) => s.name === constantName)!\n\n return buildDefinition(storageEntry.type)\n } catch (_) {\n return null\n }\n }\n\n const toStringEnhancer =\n >(\n fn: (...args: Args) => bigint | null,\n ): ((...args: Args) => string | null) =>\n (...args) =>\n fn(...args)?.toString(32) ?? null\n\n return {\n buildDefinition: toStringEnhancer(buildDefinition),\n buildRuntimeCall: toStringEnhancer(buildRuntimeCall),\n buildStorage: toStringEnhancer(buildStorage),\n buildViewFns: toStringEnhancer(buildViewFns),\n buildCall: toStringEnhancer(buildVariant(\"calls\")),\n buildEvent: toStringEnhancer(buildVariant(\"events\")),\n buildError: toStringEnhancer(buildVariant(\"errors\")),\n buildConstant: toStringEnhancer(buildConstant),\n buildComposite: toStringEnhancer(buildComposite),\n buildNamedTuple: toStringEnhancer(buildNamedTuple),\n getAllGeneratedChecksums: () =>\n Array.from(cache.values()).map((v) => v.toString(32)),\n }\n}\n"],"names":["entry","scale","inner","value","mapObject","h64","result","id","group","getChecksum"],"mappings":"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"} \ No newline at end of file diff --git a/packages/metadata-builders/package.json b/packages/metadata-builders/package.json new file mode 100644 index 0000000..8445f18 --- /dev/null +++ b/packages/metadata-builders/package.json @@ -0,0 +1,45 @@ +{ + "name": "@pezkuwi/metadata-builders", + "version": "1.0.0", + "author": "Dijital Kurdistan Tech Institute ", + "bugs": "https://github.com/pezkuwichain/pezkuwi-api/issues", + "homepage": "https://github.com/pezkuwichain/pezkuwi-api/tree/master/packages/metadata-builders#readme", + "repository": { + "directory": "packages/metadata-builders", + "type": "git", + "url": "https://github.com/pezkuwichain/pezkuwi-api.git" + }, + "license": "MIT", + "sideEffects": false, + "type": "module", + "exports": { + ".": { + "node": { + "production": { + "import": "./dist/esm/index.mjs", + "require": "./dist/index.js", + "default": "./dist/index.js" + }, + "import": "./dist/esm/index.mjs", + "require": "./dist/index.js", + "default": "./dist/index.js" + }, + "module": "./dist/esm/index.mjs", + "import": "./dist/esm/index.mjs", + "require": "./dist/index.js", + "default": "./dist/index.js" + }, + "./package.json": "./package.json" + }, + "main": "./dist/index.js", + "module": "./dist/esm/index.mjs", + "browser": "./dist/esm/index.mjs", + "types": "./dist/index.d.ts", + "files": [ + "dist" + ], + "dependencies": { + "@pezkuwi/bizinikiwi-bindings": "1.0.0", + "@pezkuwi/papi-utils": "1.0.0" + } +} diff --git a/packages/papi-utils/LICENSE b/packages/papi-utils/LICENSE new file mode 100644 index 0000000..e7c9b1a --- /dev/null +++ b/packages/papi-utils/LICENSE @@ -0,0 +1,21 @@ +MIT License + +Copyright (c) 2023 Josep M Sobrepere + +Permission is hereby granted, free of charge, to any person obtaining a copy +of this software and associated documentation files (the "Software"), to deal +in the Software without restriction, including without limitation the rights +to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +copies of the Software, and to permit persons to whom the Software is +furnished to do so, subject to the following conditions: + +The above copyright notice and this permission notice shall be included in all +copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +SOFTWARE. diff --git a/packages/papi-utils/README.md b/packages/papi-utils/README.md new file mode 100644 index 0000000..6cbfc5e --- /dev/null +++ b/packages/papi-utils/README.md @@ -0,0 +1 @@ +# @polkadot-api/utils diff --git a/packages/papi-utils/dist/esm/AbortError.mjs b/packages/papi-utils/dist/esm/AbortError.mjs new file mode 100644 index 0000000..2a7f1c3 --- /dev/null +++ b/packages/papi-utils/dist/esm/AbortError.mjs @@ -0,0 +1,9 @@ +class AbortError extends Error { + constructor() { + super("Abort Error"); + this.name = "AbortError"; + } +} + +export { AbortError }; +//# sourceMappingURL=AbortError.mjs.map diff --git a/packages/papi-utils/dist/esm/AbortError.mjs.map b/packages/papi-utils/dist/esm/AbortError.mjs.map new file mode 100644 index 0000000..1d8fe06 --- /dev/null +++ b/packages/papi-utils/dist/esm/AbortError.mjs.map @@ -0,0 +1 @@ +{"version":3,"file":"AbortError.mjs","sources":["../../src/AbortError.ts"],"sourcesContent":["export class AbortError extends Error {\n constructor() {\n super(\"Abort Error\")\n this.name = \"AbortError\"\n }\n}\n"],"names":[],"mappings":"AAAO,MAAM,mBAAmB,KAAM,CAAA;AAAA,EACpC,WAAc,GAAA;AACZ,IAAA,KAAA,CAAM,aAAa,CAAA;AACnB,IAAA,IAAA,CAAK,IAAO,GAAA,YAAA;AAAA;AAEhB;;;;"} \ No newline at end of file diff --git a/packages/papi-utils/dist/esm/filterObject.mjs b/packages/papi-utils/dist/esm/filterObject.mjs new file mode 100644 index 0000000..5f0109d --- /dev/null +++ b/packages/papi-utils/dist/esm/filterObject.mjs @@ -0,0 +1,8 @@ +function filterObject(input, filterFn) { + return Object.fromEntries( + Object.entries(input).filter(([key, value]) => filterFn(value, key)) + ); +} + +export { filterObject }; +//# sourceMappingURL=filterObject.mjs.map diff --git a/packages/papi-utils/dist/esm/filterObject.mjs.map b/packages/papi-utils/dist/esm/filterObject.mjs.map new file mode 100644 index 0000000..0967bdb --- /dev/null +++ b/packages/papi-utils/dist/esm/filterObject.mjs.map @@ -0,0 +1 @@ +{"version":3,"file":"filterObject.mjs","sources":["../../src/filterObject.ts"],"sourcesContent":["export function filterObject(\n input: Record,\n filterFn: (i: I, k: K) => boolean,\n): Record {\n return Object.fromEntries(\n Object.entries(input).filter(([key, value]: any) => filterFn(value, key)),\n ) as any\n}\n"],"names":[],"mappings":"AAAgB,SAAA,YAAA,CACd,OACA,QACc,EAAA;AACd,EAAA,OAAO,MAAO,CAAA,WAAA;AAAA,IACZ,MAAO,CAAA,OAAA,CAAQ,KAAK,CAAA,CAAE,MAAO,CAAA,CAAC,CAAC,GAAA,EAAK,KAAK,CAAA,KAAW,QAAS,CAAA,KAAA,EAAO,GAAG,CAAC;AAAA,GAC1E;AACF;;;;"} \ No newline at end of file diff --git a/packages/papi-utils/dist/esm/hex.mjs b/packages/papi-utils/dist/esm/hex.mjs new file mode 100644 index 0000000..6a832df --- /dev/null +++ b/packages/papi-utils/dist/esm/hex.mjs @@ -0,0 +1,51 @@ +const HEX_STR = "0123456789abcdef"; +function toHex(bytes) { + const result = new Array(bytes.length + 1); + result[0] = "0x"; + for (let i = 0; i < bytes.length; ) { + const b = bytes[i++]; + result[i] = HEX_STR[b >> 4] + HEX_STR[b & 15]; + } + return result.join(""); +} +const HEX_MAP = { + 0: 0, + 1: 1, + 2: 2, + 3: 3, + 4: 4, + 5: 5, + 6: 6, + 7: 7, + 8: 8, + 9: 9, + a: 10, + b: 11, + c: 12, + d: 13, + e: 14, + f: 15, + A: 10, + B: 11, + C: 12, + D: 13, + E: 14, + F: 15 +}; +function fromHex(hexString) { + const isOdd = hexString.length % 2; + const base = (hexString[1] === "x" ? 2 : 0) + isOdd; + const nBytes = (hexString.length - base) / 2 + isOdd; + const bytes = new Uint8Array(nBytes); + if (isOdd) bytes[0] = 0 | HEX_MAP[hexString[2]]; + for (let i = 0; i < nBytes; ) { + const idx = base + i * 2; + const a = HEX_MAP[hexString[idx]]; + const b = HEX_MAP[hexString[idx + 1]]; + bytes[isOdd + i++] = a << 4 | b; + } + return bytes; +} + +export { fromHex, toHex }; +//# sourceMappingURL=hex.mjs.map diff --git a/packages/papi-utils/dist/esm/hex.mjs.map b/packages/papi-utils/dist/esm/hex.mjs.map new file mode 100644 index 0000000..e6aaa5a --- /dev/null +++ b/packages/papi-utils/dist/esm/hex.mjs.map @@ -0,0 +1 @@ +{"version":3,"file":"hex.mjs","sources":["../../src/hex.ts"],"sourcesContent":["// https://jsben.ch/uWZw3\nconst HEX_STR = \"0123456789abcdef\"\nexport function toHex(bytes: Uint8Array): string {\n const result = new Array(bytes.length + 1)\n\n result[0] = \"0x\"\n\n for (let i = 0; i < bytes.length; ) {\n const b = bytes[i++]\n result[i] = HEX_STR[b >> 4] + HEX_STR[b & 15]\n }\n\n return result.join(\"\")\n}\n\n// https://jsben.ch/URe1X\nconst HEX_MAP: Record = {\n 0: 0,\n 1: 1,\n 2: 2,\n 3: 3,\n 4: 4,\n 5: 5,\n 6: 6,\n 7: 7,\n 8: 8,\n 9: 9,\n a: 10,\n b: 11,\n c: 12,\n d: 13,\n e: 14,\n f: 15,\n A: 10,\n B: 11,\n C: 12,\n D: 13,\n E: 14,\n F: 15,\n}\nexport function fromHex(hexString: string): Uint8Array {\n const isOdd = hexString.length % 2\n const base = (hexString[1] === \"x\" ? 2 : 0) + isOdd\n const nBytes = (hexString.length - base) / 2 + isOdd\n const bytes = new Uint8Array(nBytes)\n\n if (isOdd) bytes[0] = 0 | HEX_MAP[hexString[2]]\n\n for (let i = 0; i < nBytes; ) {\n const idx = base + i * 2\n const a = HEX_MAP[hexString[idx]]\n const b = HEX_MAP[hexString[idx + 1]]\n bytes[isOdd + i++] = (a << 4) | b\n }\n\n return bytes\n}\n"],"names":[],"mappings":"AACA,MAAM,OAAU,GAAA,kBAAA;AACT,SAAS,MAAM,KAA2B,EAAA;AAC/C,EAAA,MAAM,MAAS,GAAA,IAAI,KAAc,CAAA,KAAA,CAAM,SAAS,CAAC,CAAA;AAEjD,EAAA,MAAA,CAAO,CAAC,CAAI,GAAA,IAAA;AAEZ,EAAA,KAAA,IAAS,CAAI,GAAA,CAAA,EAAG,CAAI,GAAA,KAAA,CAAM,MAAU,IAAA;AAClC,IAAM,MAAA,CAAA,GAAI,MAAM,CAAG,EAAA,CAAA;AACnB,IAAO,MAAA,CAAA,CAAC,IAAI,OAAQ,CAAA,CAAA,IAAK,CAAC,CAAI,GAAA,OAAA,CAAQ,IAAI,EAAE,CAAA;AAAA;AAG9C,EAAO,OAAA,MAAA,CAAO,KAAK,EAAE,CAAA;AACvB;AAGA,MAAM,OAAkC,GAAA;AAAA,EACtC,CAAG,EAAA,CAAA;AAAA,EACH,CAAG,EAAA,CAAA;AAAA,EACH,CAAG,EAAA,CAAA;AAAA,EACH,CAAG,EAAA,CAAA;AAAA,EACH,CAAG,EAAA,CAAA;AAAA,EACH,CAAG,EAAA,CAAA;AAAA,EACH,CAAG,EAAA,CAAA;AAAA,EACH,CAAG,EAAA,CAAA;AAAA,EACH,CAAG,EAAA,CAAA;AAAA,EACH,CAAG,EAAA,CAAA;AAAA,EACH,CAAG,EAAA,EAAA;AAAA,EACH,CAAG,EAAA,EAAA;AAAA,EACH,CAAG,EAAA,EAAA;AAAA,EACH,CAAG,EAAA,EAAA;AAAA,EACH,CAAG,EAAA,EAAA;AAAA,EACH,CAAG,EAAA,EAAA;AAAA,EACH,CAAG,EAAA,EAAA;AAAA,EACH,CAAG,EAAA,EAAA;AAAA,EACH,CAAG,EAAA,EAAA;AAAA,EACH,CAAG,EAAA,EAAA;AAAA,EACH,CAAG,EAAA,EAAA;AAAA,EACH,CAAG,EAAA;AACL,CAAA;AACO,SAAS,QAAQ,SAA+B,EAAA;AACrD,EAAM,MAAA,KAAA,GAAQ,UAAU,MAAS,GAAA,CAAA;AACjC,EAAA,MAAM,QAAQ,SAAU,CAAA,CAAC,CAAM,KAAA,GAAA,GAAM,IAAI,CAAK,IAAA,KAAA;AAC9C,EAAA,MAAM,MAAU,GAAA,CAAA,SAAA,CAAU,MAAS,GAAA,IAAA,IAAQ,CAAI,GAAA,KAAA;AAC/C,EAAM,MAAA,KAAA,GAAQ,IAAI,UAAA,CAAW,MAAM,CAAA;AAEnC,EAAI,IAAA,KAAA,QAAa,CAAC,CAAA,GAAI,IAAI,OAAQ,CAAA,SAAA,CAAU,CAAC,CAAC,CAAA;AAE9C,EAAS,KAAA,IAAA,CAAA,GAAI,CAAG,EAAA,CAAA,GAAI,MAAU,IAAA;AAC5B,IAAM,MAAA,GAAA,GAAM,OAAO,CAAI,GAAA,CAAA;AACvB,IAAA,MAAM,CAAI,GAAA,OAAA,CAAQ,SAAU,CAAA,GAAG,CAAC,CAAA;AAChC,IAAA,MAAM,CAAI,GAAA,OAAA,CAAQ,SAAU,CAAA,GAAA,GAAM,CAAC,CAAC,CAAA;AACpC,IAAA,KAAA,CAAM,KAAQ,GAAA,CAAA,EAAG,CAAK,GAAA,CAAA,IAAK,CAAK,GAAA,CAAA;AAAA;AAGlC,EAAO,OAAA,KAAA;AACT;;;;"} \ No newline at end of file diff --git a/packages/papi-utils/dist/esm/index.mjs b/packages/papi-utils/dist/esm/index.mjs new file mode 100644 index 0000000..3eb5623 --- /dev/null +++ b/packages/papi-utils/dist/esm/index.mjs @@ -0,0 +1,8 @@ +export { fromHex, toHex } from './hex.mjs'; +export { mapObject, mapStringRecord } from './mapObject.mjs'; +export { filterObject } from './filterObject.mjs'; +export { mergeUint8 } from './mergeUint8.mjs'; +export { noop } from './noop.mjs'; +export { AbortError } from './AbortError.mjs'; +export { jsonPrint } from './jsonPrint.mjs'; +//# sourceMappingURL=index.mjs.map diff --git a/packages/papi-utils/dist/esm/index.mjs.map b/packages/papi-utils/dist/esm/index.mjs.map new file mode 100644 index 0000000..ee29cc3 --- /dev/null +++ b/packages/papi-utils/dist/esm/index.mjs.map @@ -0,0 +1 @@ +{"version":3,"file":"index.mjs","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;"} \ No newline at end of file diff --git a/packages/papi-utils/dist/esm/jsonPrint.mjs b/packages/papi-utils/dist/esm/jsonPrint.mjs new file mode 100644 index 0000000..b63b9cd --- /dev/null +++ b/packages/papi-utils/dist/esm/jsonPrint.mjs @@ -0,0 +1,8 @@ +const jsonPrint = (value, indent = 2) => JSON.stringify( + value, + (_, v) => typeof v === "bigint" ? `${v}n` : typeof v === "object" && typeof v?.asHex === "function" ? v.asHex() : v, + indent +); + +export { jsonPrint }; +//# sourceMappingURL=jsonPrint.mjs.map diff --git a/packages/papi-utils/dist/esm/jsonPrint.mjs.map b/packages/papi-utils/dist/esm/jsonPrint.mjs.map new file mode 100644 index 0000000..f501911 --- /dev/null +++ b/packages/papi-utils/dist/esm/jsonPrint.mjs.map @@ -0,0 +1 @@ +{"version":3,"file":"jsonPrint.mjs","sources":["../../src/jsonPrint.ts"],"sourcesContent":["export const jsonPrint = (value: any, indent = 2) =>\n JSON.stringify(\n value,\n (_, v) =>\n typeof v === \"bigint\"\n ? `${v}n`\n : typeof v === \"object\" && typeof v?.asHex === \"function\"\n ? v.asHex()\n : v,\n indent,\n )\n"],"names":[],"mappings":"AAAO,MAAM,SAAY,GAAA,CAAC,KAAY,EAAA,MAAA,GAAS,MAC7C,IAAK,CAAA,SAAA;AAAA,EACH,KAAA;AAAA,EACA,CAAC,CAAG,EAAA,CAAA,KACF,OAAO,CAAM,KAAA,QAAA,GACT,GAAG,CAAC,CAAA,CAAA,CAAA,GACJ,OAAO,CAAA,KAAM,YAAY,OAAO,CAAA,EAAG,UAAU,UAC3C,GAAA,CAAA,CAAE,OACF,GAAA,CAAA;AAAA,EACR;AACF;;;;"} \ No newline at end of file diff --git a/packages/papi-utils/dist/esm/mapObject.mjs b/packages/papi-utils/dist/esm/mapObject.mjs new file mode 100644 index 0000000..44f56b5 --- /dev/null +++ b/packages/papi-utils/dist/esm/mapObject.mjs @@ -0,0 +1,13 @@ +function mapObject(input, mapper) { + return Object.fromEntries( + Object.entries(input).map( + ([key, value]) => [key, mapper(value, key)] + ) + ); +} +const mapStringRecord = (input, mapper) => Object.fromEntries( + Object.entries(input).map(([key, value]) => [key, mapper(value, key)]) +); + +export { mapObject, mapStringRecord }; +//# sourceMappingURL=mapObject.mjs.map diff --git a/packages/papi-utils/dist/esm/mapObject.mjs.map b/packages/papi-utils/dist/esm/mapObject.mjs.map new file mode 100644 index 0000000..161fb24 --- /dev/null +++ b/packages/papi-utils/dist/esm/mapObject.mjs.map @@ -0,0 +1 @@ +{"version":3,"file":"mapObject.mjs","sources":["../../src/mapObject.ts"],"sourcesContent":["export function mapObject(\n input: Record,\n mapper: (i: I, k: K) => O,\n): Record\n\nexport function mapObject(\n input: Record,\n mapper: (i: I, k?: K) => O,\n): Record {\n return Object.fromEntries(\n Object.entries(input).map(\n ([key, value]: any) => [key, mapper(value, key)] as const,\n ),\n ) as any\n}\n\nexport type StringRecord = {\n [Sym: symbol]: never\n [Num: number]: never\n [Str: string]: T\n}\n\nexport const mapStringRecord = (\n input: StringRecord,\n mapper: (value: I, key: string) => O,\n): StringRecord =>\n Object.fromEntries(\n Object.entries(input).map(([key, value]) => [key, mapper(value, key)]),\n ) as StringRecord\n"],"names":[],"mappings":"AAKgB,SAAA,SAAA,CACd,OACA,MACc,EAAA;AACd,EAAA,OAAO,MAAO,CAAA,WAAA;AAAA,IACZ,MAAA,CAAO,OAAQ,CAAA,KAAK,CAAE,CAAA,GAAA;AAAA,MACpB,CAAC,CAAC,GAAA,EAAK,KAAK,CAAA,KAAW,CAAC,GAAK,EAAA,MAAA,CAAO,KAAO,EAAA,GAAG,CAAC;AAAA;AACjD,GACF;AACF;AAQO,MAAM,eAAkB,GAAA,CAC7B,KACA,EAAA,MAAA,KAEA,MAAO,CAAA,WAAA;AAAA,EACL,OAAO,OAAQ,CAAA,KAAK,CAAE,CAAA,GAAA,CAAI,CAAC,CAAC,GAAA,EAAK,KAAK,CAAA,KAAM,CAAC,GAAK,EAAA,MAAA,CAAO,KAAO,EAAA,GAAG,CAAC,CAAC;AACvE;;;;"} \ No newline at end of file diff --git a/packages/papi-utils/dist/esm/mergeUint8.mjs b/packages/papi-utils/dist/esm/mergeUint8.mjs new file mode 100644 index 0000000..5aa9ad8 --- /dev/null +++ b/packages/papi-utils/dist/esm/mergeUint8.mjs @@ -0,0 +1,14 @@ +const mergeUint8 = (...i) => { + const inputs = Array.isArray(i[0]) ? i[0] : i; + const totalLen = inputs.reduce((acc, a) => acc + a.byteLength, 0); + const result = new Uint8Array(totalLen); + for (let idx = 0, at = 0; idx < inputs.length; idx++) { + const current = inputs[idx]; + result.set(current, at); + at += current.byteLength; + } + return result; +}; + +export { mergeUint8 }; +//# sourceMappingURL=mergeUint8.mjs.map diff --git a/packages/papi-utils/dist/esm/mergeUint8.mjs.map b/packages/papi-utils/dist/esm/mergeUint8.mjs.map new file mode 100644 index 0000000..a8b2782 --- /dev/null +++ b/packages/papi-utils/dist/esm/mergeUint8.mjs.map @@ -0,0 +1 @@ +{"version":3,"file":"mergeUint8.mjs","sources":["../../src/mergeUint8.ts"],"sourcesContent":["// TODO: deprecate spread overload in papi v2\n\ninterface MergeUint8 {\n /**\n * @deprecated This overload will be removed in PAPI v2. Migrate as\n * follows:\n * mergeUint8(arr1, arr2) => mergeUint8([arr1, arr2])\n */\n (...inputs: Array): Uint8Array\n (inputs: Array): Uint8Array\n}\n\nexport const mergeUint8: MergeUint8 = (...i) => {\n const inputs = (Array.isArray(i[0]) ? i[0] : i) as Uint8Array[]\n const totalLen = inputs.reduce((acc, a) => acc + a.byteLength, 0)\n const result = new Uint8Array(totalLen)\n\n for (let idx = 0, at = 0; idx < inputs.length; idx++) {\n const current = inputs[idx]\n result.set(current, at)\n at += current.byteLength\n }\n\n return result\n}\n"],"names":[],"mappings":"AAYa,MAAA,UAAA,GAAyB,IAAI,CAAM,KAAA;AAC9C,EAAM,MAAA,MAAA,GAAU,MAAM,OAAQ,CAAA,CAAA,CAAE,CAAC,CAAC,CAAA,GAAI,CAAE,CAAA,CAAC,CAAI,GAAA,CAAA;AAC7C,EAAM,MAAA,QAAA,GAAW,OAAO,MAAO,CAAA,CAAC,KAAK,CAAM,KAAA,GAAA,GAAM,CAAE,CAAA,UAAA,EAAY,CAAC,CAAA;AAChE,EAAM,MAAA,MAAA,GAAS,IAAI,UAAA,CAAW,QAAQ,CAAA;AAEtC,EAAA,KAAA,IAAS,MAAM,CAAG,EAAA,EAAA,GAAK,GAAG,GAAM,GAAA,MAAA,CAAO,QAAQ,GAAO,EAAA,EAAA;AACpD,IAAM,MAAA,OAAA,GAAU,OAAO,GAAG,CAAA;AAC1B,IAAO,MAAA,CAAA,GAAA,CAAI,SAAS,EAAE,CAAA;AACtB,IAAA,EAAA,IAAM,OAAQ,CAAA,UAAA;AAAA;AAGhB,EAAO,OAAA,MAAA;AACT;;;;"} \ No newline at end of file diff --git a/packages/papi-utils/dist/esm/noop.mjs b/packages/papi-utils/dist/esm/noop.mjs new file mode 100644 index 0000000..6fffee1 --- /dev/null +++ b/packages/papi-utils/dist/esm/noop.mjs @@ -0,0 +1,4 @@ +const noop = Function.prototype; + +export { noop }; +//# sourceMappingURL=noop.mjs.map diff --git a/packages/papi-utils/dist/esm/noop.mjs.map b/packages/papi-utils/dist/esm/noop.mjs.map new file mode 100644 index 0000000..521f8a0 --- /dev/null +++ b/packages/papi-utils/dist/esm/noop.mjs.map @@ -0,0 +1 @@ +{"version":3,"file":"noop.mjs","sources":["../../src/noop.ts"],"sourcesContent":["export const noop: () => void = Function.prototype as any\n"],"names":[],"mappings":"AAAO,MAAM,OAAmB,QAAS,CAAA;;;;"} \ No newline at end of file diff --git a/packages/papi-utils/dist/index.d.ts b/packages/papi-utils/dist/index.d.ts new file mode 100644 index 0000000..e146e89 --- /dev/null +++ b/packages/papi-utils/dist/index.d.ts @@ -0,0 +1,33 @@ +declare function toHex(bytes: Uint8Array): string; +declare function fromHex(hexString: string): Uint8Array; + +declare function mapObject(input: Record, mapper: (i: I, k: K) => O): Record; +type StringRecord = { + [Sym: symbol]: never; + [Num: number]: never; + [Str: string]: T; +}; +declare const mapStringRecord: (input: StringRecord, mapper: (value: I, key: string) => O) => StringRecord; + +declare function filterObject(input: Record, filterFn: (i: I, k: K) => boolean): Record; + +interface MergeUint8 { + /** + * @deprecated This overload will be removed in PAPI v2. Migrate as + * follows: + * mergeUint8(arr1, arr2) => mergeUint8([arr1, arr2]) + */ + (...inputs: Array): Uint8Array; + (inputs: Array): Uint8Array; +} +declare const mergeUint8: MergeUint8; + +declare const noop: () => void; + +declare class AbortError extends Error { + constructor(); +} + +declare const jsonPrint: (value: any, indent?: number) => string; + +export { AbortError, filterObject, fromHex, jsonPrint, mapObject, mapStringRecord, mergeUint8, noop, toHex }; diff --git a/packages/papi-utils/dist/index.js b/packages/papi-utils/dist/index.js new file mode 100644 index 0000000..ebebafe --- /dev/null +++ b/packages/papi-utils/dist/index.js @@ -0,0 +1,105 @@ +'use strict'; + +const HEX_STR = "0123456789abcdef"; +function toHex(bytes) { + const result = new Array(bytes.length + 1); + result[0] = "0x"; + for (let i = 0; i < bytes.length; ) { + const b = bytes[i++]; + result[i] = HEX_STR[b >> 4] + HEX_STR[b & 15]; + } + return result.join(""); +} +const HEX_MAP = { + 0: 0, + 1: 1, + 2: 2, + 3: 3, + 4: 4, + 5: 5, + 6: 6, + 7: 7, + 8: 8, + 9: 9, + a: 10, + b: 11, + c: 12, + d: 13, + e: 14, + f: 15, + A: 10, + B: 11, + C: 12, + D: 13, + E: 14, + F: 15 +}; +function fromHex(hexString) { + const isOdd = hexString.length % 2; + const base = (hexString[1] === "x" ? 2 : 0) + isOdd; + const nBytes = (hexString.length - base) / 2 + isOdd; + const bytes = new Uint8Array(nBytes); + if (isOdd) bytes[0] = 0 | HEX_MAP[hexString[2]]; + for (let i = 0; i < nBytes; ) { + const idx = base + i * 2; + const a = HEX_MAP[hexString[idx]]; + const b = HEX_MAP[hexString[idx + 1]]; + bytes[isOdd + i++] = a << 4 | b; + } + return bytes; +} + +function mapObject(input, mapper) { + return Object.fromEntries( + Object.entries(input).map( + ([key, value]) => [key, mapper(value, key)] + ) + ); +} +const mapStringRecord = (input, mapper) => Object.fromEntries( + Object.entries(input).map(([key, value]) => [key, mapper(value, key)]) +); + +function filterObject(input, filterFn) { + return Object.fromEntries( + Object.entries(input).filter(([key, value]) => filterFn(value, key)) + ); +} + +const mergeUint8 = (...i) => { + const inputs = Array.isArray(i[0]) ? i[0] : i; + const totalLen = inputs.reduce((acc, a) => acc + a.byteLength, 0); + const result = new Uint8Array(totalLen); + for (let idx = 0, at = 0; idx < inputs.length; idx++) { + const current = inputs[idx]; + result.set(current, at); + at += current.byteLength; + } + return result; +}; + +const noop = Function.prototype; + +class AbortError extends Error { + constructor() { + super("Abort Error"); + this.name = "AbortError"; + } +} + +const jsonPrint = (value, indent = 2) => JSON.stringify( + value, + (_, v) => typeof v === "bigint" ? `${v}n` : typeof v === "object" && typeof v?.asHex === "function" ? v.asHex() : v, + indent +); + +exports.AbortError = AbortError; +exports.filterObject = filterObject; +exports.fromHex = fromHex; +exports.jsonPrint = jsonPrint; +exports.mapObject = mapObject; +exports.mapStringRecord = mapStringRecord; +exports.mergeUint8 = mergeUint8; +exports.noop = noop; +exports.toHex = toHex; +//# sourceMappingURL=index.js.map diff --git a/packages/papi-utils/dist/index.js.map b/packages/papi-utils/dist/index.js.map new file mode 100644 index 0000000..077bde1 --- /dev/null +++ b/packages/papi-utils/dist/index.js.map @@ -0,0 +1 @@ +{"version":3,"file":"index.js","sources":["../src/hex.ts","../src/mapObject.ts","../src/filterObject.ts","../src/mergeUint8.ts","../src/noop.ts","../src/AbortError.ts","../src/jsonPrint.ts"],"sourcesContent":["// https://jsben.ch/uWZw3\nconst HEX_STR = \"0123456789abcdef\"\nexport function toHex(bytes: Uint8Array): string {\n const result = new Array(bytes.length + 1)\n\n result[0] = \"0x\"\n\n for (let i = 0; i < bytes.length; ) {\n const b = bytes[i++]\n result[i] = HEX_STR[b >> 4] + HEX_STR[b & 15]\n }\n\n return result.join(\"\")\n}\n\n// https://jsben.ch/URe1X\nconst HEX_MAP: Record = {\n 0: 0,\n 1: 1,\n 2: 2,\n 3: 3,\n 4: 4,\n 5: 5,\n 6: 6,\n 7: 7,\n 8: 8,\n 9: 9,\n a: 10,\n b: 11,\n c: 12,\n d: 13,\n e: 14,\n f: 15,\n A: 10,\n B: 11,\n C: 12,\n D: 13,\n E: 14,\n F: 15,\n}\nexport function fromHex(hexString: string): Uint8Array {\n const isOdd = hexString.length % 2\n const base = (hexString[1] === \"x\" ? 2 : 0) + isOdd\n const nBytes = (hexString.length - base) / 2 + isOdd\n const bytes = new Uint8Array(nBytes)\n\n if (isOdd) bytes[0] = 0 | HEX_MAP[hexString[2]]\n\n for (let i = 0; i < nBytes; ) {\n const idx = base + i * 2\n const a = HEX_MAP[hexString[idx]]\n const b = HEX_MAP[hexString[idx + 1]]\n bytes[isOdd + i++] = (a << 4) | b\n }\n\n return bytes\n}\n","export function mapObject(\n input: Record,\n mapper: (i: I, k: K) => O,\n): Record\n\nexport function mapObject(\n input: Record,\n mapper: (i: I, k?: K) => O,\n): Record {\n return Object.fromEntries(\n Object.entries(input).map(\n ([key, value]: any) => [key, mapper(value, key)] as const,\n ),\n ) as any\n}\n\nexport type StringRecord = {\n [Sym: symbol]: never\n [Num: number]: never\n [Str: string]: T\n}\n\nexport const mapStringRecord = (\n input: StringRecord,\n mapper: (value: I, key: string) => O,\n): StringRecord =>\n Object.fromEntries(\n Object.entries(input).map(([key, value]) => [key, mapper(value, key)]),\n ) as StringRecord\n","export function filterObject(\n input: Record,\n filterFn: (i: I, k: K) => boolean,\n): Record {\n return Object.fromEntries(\n Object.entries(input).filter(([key, value]: any) => filterFn(value, key)),\n ) as any\n}\n","// TODO: deprecate spread overload in papi v2\n\ninterface MergeUint8 {\n /**\n * @deprecated This overload will be removed in PAPI v2. Migrate as\n * follows:\n * mergeUint8(arr1, arr2) => mergeUint8([arr1, arr2])\n */\n (...inputs: Array): Uint8Array\n (inputs: Array): Uint8Array\n}\n\nexport const mergeUint8: MergeUint8 = (...i) => {\n const inputs = (Array.isArray(i[0]) ? i[0] : i) as Uint8Array[]\n const totalLen = inputs.reduce((acc, a) => acc + a.byteLength, 0)\n const result = new Uint8Array(totalLen)\n\n for (let idx = 0, at = 0; idx < inputs.length; idx++) {\n const current = inputs[idx]\n result.set(current, at)\n at += current.byteLength\n }\n\n return result\n}\n","export const noop: () => void = Function.prototype as any\n","export class AbortError extends Error {\n constructor() {\n super(\"Abort Error\")\n this.name = \"AbortError\"\n }\n}\n","export const jsonPrint = (value: any, indent = 2) =>\n JSON.stringify(\n value,\n (_, v) =>\n typeof v === \"bigint\"\n ? `${v}n`\n : typeof v === \"object\" && typeof v?.asHex === \"function\"\n ? v.asHex()\n : v,\n indent,\n )\n"],"names":[],"mappings":"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"} \ No newline at end of file diff --git a/packages/papi-utils/package.json b/packages/papi-utils/package.json new file mode 100644 index 0000000..885d6b6 --- /dev/null +++ b/packages/papi-utils/package.json @@ -0,0 +1,41 @@ +{ + "name": "@pezkuwi/papi-utils", + "version": "1.0.0", + "author": "Dijital Kurdistan Tech Institute ", + "bugs": "https://github.com/pezkuwichain/pezkuwi-api/issues", + "homepage": "https://github.com/pezkuwichain/pezkuwi-api/tree/master/packages/papi-utils#readme", + "repository": { + "directory": "packages/papi-utils", + "type": "git", + "url": "https://github.com/pezkuwichain/pezkuwi-api.git" + }, + "license": "MIT", + "sideEffects": false, + "type": "module", + "exports": { + ".": { + "node": { + "production": { + "import": "./dist/esm/index.mjs", + "require": "./dist/index.js", + "default": "./dist/index.js" + }, + "import": "./dist/esm/index.mjs", + "require": "./dist/index.js", + "default": "./dist/index.js" + }, + "module": "./dist/esm/index.mjs", + "import": "./dist/esm/index.mjs", + "require": "./dist/index.js", + "default": "./dist/index.js" + }, + "./package.json": "./package.json" + }, + "main": "./dist/index.js", + "module": "./dist/esm/index.mjs", + "browser": "./dist/esm/index.mjs", + "types": "./dist/index.d.ts", + "files": [ + "dist" + ] +}