@polkadot-api/substrate-bindings 0.6.0 → 0.6.1

package/dist/esm/codecs/blockHeader.mjs

@@ -0,0 +1,42 @@
+import { enhanceCodec, Bytes, Struct, Vector, _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';
+
+const textEncoder = new TextEncoder();
+const textDecoder = new TextDecoder();
+const fourChars = enhanceCodec(
+  Bytes(4),
+  textEncoder.encode.bind(textEncoder),
+  textDecoder.decode.bind(textDecoder)
+);
+const diggestVal = Struct({
+  engine: fourChars,
+  payload: Hex()
+});
+const diggest = Variant(
+  {
+    consensus: diggestVal,
+    seal: diggestVal,
+    preRuntime: diggestVal,
+    runtimeUpdated: _void
+  },
+  [4, 5, 6, 8]
+);
+const hex32 = Hex(32);
+const blockHeader = Struct({
+  parentHash: hex32,
+  number: compactNumber,
+  stateRoot: hex32,
+  extrinsicRoot: hex32,
+  digests: Vector(diggest)
+});
+
+export { blockHeader };
+//# sourceMappingURL=blockHeader.mjs.map

package/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    consensus: diggestVal,\n    seal: diggestVal,\n    preRuntime: diggestVal,\n    runtimeUpdated: _void,\n  },\n  [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<typeof blockHeader>\n"],"names":[],"mappings":";;;;;;;;;;;AAYA,MAAM,WAAA,GAAc,IAAI,WAAY,EAAA,CAAA;AACpC,MAAM,WAAA,GAAc,IAAI,WAAY,EAAA,CAAA;AAEpC,MAAM,SAAY,GAAA,YAAA;AAAA,EAChB,MAAM,CAAC,CAAA;AAAA,EACP,WAAA,CAAY,MAAO,CAAA,IAAA,CAAK,WAAW,CAAA;AAAA,EACnC,WAAA,CAAY,MAAO,CAAA,IAAA,CAAK,WAAW,CAAA;AACrC,CAAA,CAAA;AAEA,MAAM,aAAa,MAAO,CAAA;AAAA,EACxB,MAAQ,EAAA,SAAA;AAAA,EACR,SAAS,GAAI,EAAA;AACf,CAAC,CAAA,CAAA;AAED,MAAM,OAAU,GAAA,OAAA;AAAA,EACd;AAAA,IACE,SAAW,EAAA,UAAA;AAAA,IACX,IAAM,EAAA,UAAA;AAAA,IACN,UAAY,EAAA,UAAA;AAAA,IACZ,cAAgB,EAAA,KAAA;AAAA,GAClB;AAAA,EACA,CAAC,CAAA,EAAG,CAAG,EAAA,CAAA,EAAG,CAAC,CAAA;AACb,CAAA,CAAA;AAEA,MAAM,KAAA,GAAQ,IAAI,EAAE,CAAA,CAAA;AACb,MAAM,cAAc,MAAO,CAAA;AAAA,EAChC,UAAY,EAAA,KAAA;AAAA,EACZ,MAAQ,EAAA,aAAA;AAAA,EACR,SAAW,EAAA,KAAA;AAAA,EACX,aAAe,EAAA,KAAA;AAAA,EACf,OAAA,EAAS,OAAO,OAAO,CAAA;AACzB,CAAC;;;;"}

package/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

package/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":";;AAEa,MAAA,IAAA,GAAO,OAAO,GAAG;;;;"}

package/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

package/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<typeof lookup>\n"],"names":[],"mappings":";;;;AAcA,MAAM,IAAA,GAAO,OAAO,GAAG,CAAA,CAAA;AAEvB,MAAM,YAAY,IAAK,CAAA;AAAA,EACrB,IAAM,EAAA,KAAA;AAAA,EACN,IAAM,EAAA,KAAA;AAAA,EACN,GAAK,EAAA,KAAA;AAAA,EACL,EAAI,EAAA,KAAA;AAAA,EACJ,GAAK,EAAA,KAAA;AAAA,EACL,GAAK,EAAA,KAAA;AAAA,EACL,GAAK,EAAA,KAAA;AAAA,EACL,IAAM,EAAA,KAAA;AAAA,EACN,IAAM,EAAA,KAAA;AAAA,EACN,EAAI,EAAA,KAAA;AAAA,EACJ,GAAK,EAAA,KAAA;AAAA,EACL,GAAK,EAAA,KAAA;AAAA,EACL,GAAK,EAAA,KAAA;AAAA,EACL,IAAM,EAAA,KAAA;AAAA,EACN,IAAM,EAAA,KAAA;AACR,CAAC,CAAA,CAAA;AAED,MAAM,MAAS,GAAA,MAAA;AAAA,EACb,MAAO,CAAA;AAAA,IACL,IAAM,EAAA,IAAA;AAAA,IACN,IAAM,EAAA,aAAA;AAAA,IACN,QAAU,EAAA,IAAA;AAAA,IACV,IAAA;AAAA,GACD,CAAA;AACH,CAAA,CAAA;AAEA,MAAM,MAAM,MAAO,CAAA;AAAA,EACjB,GAAK,EAAA,GAAA;AAAA,EACL,IAAM,EAAA,aAAA;AACR,CAAC,CAAA,CAAA;AAED,MAAM,cAAc,MAAO,CAAA;AAAA,EACzB,YAAc,EAAA,aAAA;AAAA,EACd,YAAc,EAAA,aAAA;AAChB,CAAC,CAAA,CAAA;AAED,MAAM,OAAU,GAAA,MAAA;AAAA,EACd,MAAO,CAAA;AAAA,IACL,IAAM,EAAA,GAAA;AAAA,IACN,MAAA;AAAA,IACA,KAAO,EAAA,EAAA;AAAA,IACP,IAAA;AAAA,GACD,CAAA;AACH,CAAA,CAAA;AAEA,MAAM,MAAM,IAAK,CAAA;AAAA,EACf,SAAW,EAAA,MAAA;AAAA,EACX,OAAA;AAAA,EACA,QAAU,EAAA,aAAA;AAAA,EACV,KAAO,EAAA,GAAA;AAAA,EACP,KAAA,EAAO,OAAO,aAAa,CAAA;AAAA,EAC3B,SAAA;AAAA,EACA,OAAS,EAAA,aAAA;AAAA,EACT,WAAA;AACF,CAAC,CAAA,CAAA;AAED,MAAM,QAAQ,MAAO,CAAA;AAAA,EACnB,IAAM,EAAA,GAAA;AAAA,EACN,IAAA,EAAM,OAAO,aAAa,CAAA;AAC5B,CAAC,CAAA,CAAA;AACD,MAAM,MAAA,GAAS,OAAO,KAAK,CAAA,CAAA;AAE3B,MAAM,QAAQ,MAAO,CAAA;AAAA,EACnB,EAAI,EAAA,aAAA;AAAA,EACJ,IAAM,EAAA,IAAA;AAAA,EACN,MAAA;AAAA,EACA,GAAA;AAAA,EACA,IAAA;AACF,CAAC,CAAA,CAAA;AAEY,MAAA,MAAA,GAAS,OAAO,KAAK;;;;"}

package/dist/esm/codecs/metadata/metadata.mjs

@@ -0,0 +1,35 @@
+import { createCodec, Struct, u32, Enum } from 'scale-ts';
+import { v15 } from './v15.mjs';
+import { v14 } from './v14.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
+  })
+});
+
+export { metadata };
+//# sourceMappingURL=metadata.mjs.map

package/dist/esm/codecs/metadata/metadata.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"metadata.mjs","sources":["../../../../src/codecs/metadata/metadata.ts"],"sourcesContent":["import { Enum, Struct, u32, Codec, createCodec } from \"scale-ts\"\nimport { v15 } from \"./v15\"\nimport { v14 } from \"./v14\"\n\nconst unsupportedFn = () => {\n  throw new Error(\"Unsupported metadata version!\")\n}\n\nconst unsupported = createCodec(\n  unsupportedFn,\n  unsupportedFn,\n) as unknown as Codec<unknown>\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  }),\n})\n"],"names":[],"mappings":";;;;AAIA,MAAM,gBAAgB,MAAM;AAC1B,EAAM,MAAA,IAAI,MAAM,+BAA+B,CAAA,CAAA;AACjD,CAAA,CAAA;AAEA,MAAM,WAAc,GAAA,WAAA;AAAA,EAClB,aAAA;AAAA,EACA,aAAA;AACF,CAAA,CAAA;AAEO,MAAM,WAAW,MAAO,CAAA;AAAA,EAC7B,WAAa,EAAA,GAAA;AAAA,EACb,UAAU,IAAK,CAAA;AAAA,IACb,EAAI,EAAA,WAAA;AAAA,IACJ,EAAI,EAAA,WAAA;AAAA,IACJ,EAAI,EAAA,WAAA;AAAA,IACJ,EAAI,EAAA,WAAA;AAAA,IACJ,EAAI,EAAA,WAAA;AAAA,IACJ,EAAI,EAAA,WAAA;AAAA,IACJ,EAAI,EAAA,WAAA;AAAA,IACJ,EAAI,EAAA,WAAA;AAAA,IACJ,EAAI,EAAA,WAAA;AAAA,IACJ,EAAI,EAAA,WAAA;AAAA,IACJ,GAAK,EAAA,WAAA;AAAA,IACL,GAAK,EAAA,WAAA;AAAA,IACL,GAAK,EAAA,WAAA;AAAA,IACL,GAAK,EAAA,WAAA;AAAA,IACL,GAAA;AAAA,IACA,GAAA;AAAA,GACD,CAAA;AACH,CAAC;;;;"}

package/dist/esm/codecs/metadata/pallets.mjs

@@ -0,0 +1,66 @@
+import { Enum, _void, Vector, Struct, str, u8, Option } 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 { docs } from './docs.mjs';
+
+const hashType = Enum({
+  Blake2128: _void,
+  Blake2256: _void,
+  Blake2128Concat: _void,
+  Twox128: _void,
+  Twox256: _void,
+  Twox64Concat: _void,
+  Identity: _void
+});
+const hashers = Vector(hashType);
+const storageMap = Struct({
+  hashers,
+  key: compactNumber,
+  value: compactNumber
+});
+const storageItem = Struct({
+  name: str,
+  modifier: u8,
+  type: Enum({
+    plain: compactNumber,
+    map: storageMap
+  }),
+  fallback: Hex(),
+  docs
+});
+const storage = Option(
+  Struct({
+    prefix: str,
+    items: Vector(storageItem)
+  })
+);
+const v14Pallet = {
+  name: str,
+  storage,
+  calls: Option(compactNumber),
+  events: Option(compactNumber),
+  constants: Vector(
+    Struct({
+      name: str,
+      type: compactNumber,
+      value: Hex(),
+      docs
+    })
+  ),
+  errors: Option(compactNumber),
+  index: u8
+};
+const v15Pallet = {
+  ...v14Pallet,
+  docs
+};
+
+export { v14Pallet, v15Pallet };
+//# sourceMappingURL=pallets.mjs.map

package/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\"\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\nconst storageMap = Struct({\n  hashers,\n  key: compactNumber,\n  value: compactNumber,\n})\n\nconst storageItem = Struct({\n  name: str,\n  modifier: u8,\n  type: Enum({\n    plain: compactNumber,\n    map: storageMap,\n  }),\n  fallback: Hex(),\n  docs,\n})\n\nconst storage = Option(\n  Struct({\n    prefix: str,\n    items: Vector(storageItem),\n  }),\n)\n\nexport const v14Pallet = {\n  name: str,\n  storage,\n  calls: Option(compactNumber),\n  events: Option(compactNumber),\n  constants: Vector(\n    Struct({\n      name: str,\n      type: compactNumber,\n      value: Hex(),\n      docs,\n    }),\n  ),\n  errors: Option(compactNumber),\n  index: u8,\n}\n\nexport const v15Pallet = {\n  ...v14Pallet,\n  docs,\n}\n"],"names":[],"mappings":";;;;;;;;;;;;AAIA,MAAM,WAAW,IAAK,CAAA;AAAA,EACpB,SAAW,EAAA,KAAA;AAAA,EACX,SAAW,EAAA,KAAA;AAAA,EACX,eAAiB,EAAA,KAAA;AAAA,EACjB,OAAS,EAAA,KAAA;AAAA,EACT,OAAS,EAAA,KAAA;AAAA,EACT,YAAc,EAAA,KAAA;AAAA,EACd,QAAU,EAAA,KAAA;AACZ,CAAC,CAAA,CAAA;AAED,MAAM,OAAA,GAAU,OAAO,QAAQ,CAAA,CAAA;AAE/B,MAAM,aAAa,MAAO,CAAA;AAAA,EACxB,OAAA;AAAA,EACA,GAAK,EAAA,aAAA;AAAA,EACL,KAAO,EAAA,aAAA;AACT,CAAC,CAAA,CAAA;AAED,MAAM,cAAc,MAAO,CAAA;AAAA,EACzB,IAAM,EAAA,GAAA;AAAA,EACN,QAAU,EAAA,EAAA;AAAA,EACV,MAAM,IAAK,CAAA;AAAA,IACT,KAAO,EAAA,aAAA;AAAA,IACP,GAAK,EAAA,UAAA;AAAA,GACN,CAAA;AAAA,EACD,UAAU,GAAI,EAAA;AAAA,EACd,IAAA;AACF,CAAC,CAAA,CAAA;AAED,MAAM,OAAU,GAAA,MAAA;AAAA,EACd,MAAO,CAAA;AAAA,IACL,MAAQ,EAAA,GAAA;AAAA,IACR,KAAA,EAAO,OAAO,WAAW,CAAA;AAAA,GAC1B,CAAA;AACH,CAAA,CAAA;AAEO,MAAM,SAAY,GAAA;AAAA,EACvB,IAAM,EAAA,GAAA;AAAA,EACN,OAAA;AAAA,EACA,KAAA,EAAO,OAAO,aAAa,CAAA;AAAA,EAC3B,MAAA,EAAQ,OAAO,aAAa,CAAA;AAAA,EAC5B,SAAW,EAAA,MAAA;AAAA,IACT,MAAO,CAAA;AAAA,MACL,IAAM,EAAA,GAAA;AAAA,MACN,IAAM,EAAA,aAAA;AAAA,MACN,OAAO,GAAI,EAAA;AAAA,MACX,IAAA;AAAA,KACD,CAAA;AAAA,GACH;AAAA,EACA,MAAA,EAAQ,OAAO,aAAa,CAAA;AAAA,EAC5B,KAAO,EAAA,EAAA;AACT,EAAA;AAEO,MAAM,SAAY,GAAA;AAAA,EACvB,GAAG,SAAA;AAAA,EACH,IAAA;AACF;;;;"}

package/dist/esm/codecs/metadata/runtime-api.mjs

@@ -0,0 +1,32 @@
+import { Struct, str, Vector } 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 '../scale/Hex.mjs';
+import '../scale/fixed-str.mjs';
+import '../scale/Variant.mjs';
+import '../scale/ethAccount.mjs';
+
+const runtimeApi = Struct({
+  name: str,
+  methods: Vector(
+    Struct({
+      name: str,
+      inputs: Vector(
+        Struct({
+          name: str,
+          type: compactNumber
+        })
+      ),
+      output: compactNumber,
+      docs
+    })
+  ),
+  docs
+});
+
+export { runtimeApi };
+//# sourceMappingURL=runtime-api.mjs.map

package/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 as ty } from \"../scale\"\n\nexport const runtimeApi = Struct({\n  name: str,\n  methods: Vector(\n    Struct({\n      name: str,\n      inputs: Vector(\n        Struct({\n          name: str,\n          type: ty,\n        }),\n      ),\n      output: ty,\n      docs,\n    }),\n  ),\n  docs,\n})\n"],"names":["ty"],"mappings":";;;;;;;;;;;;AAIO,MAAM,aAAa,MAAO,CAAA;AAAA,EAC/B,IAAM,EAAA,GAAA;AAAA,EACN,OAAS,EAAA,MAAA;AAAA,IACP,MAAO,CAAA;AAAA,MACL,IAAM,EAAA,GAAA;AAAA,MACN,MAAQ,EAAA,MAAA;AAAA,QACN,MAAO,CAAA;AAAA,UACL,IAAM,EAAA,GAAA;AAAA,UACN,IAAM,EAAAA,aAAA;AAAA,SACP,CAAA;AAAA,OACH;AAAA,MACA,MAAQ,EAAAA,aAAA;AAAA,MACR,IAAA;AAAA,KACD,CAAA;AAAA,GACH;AAAA,EACA,IAAA;AACF,CAAC;;;;"}

package/dist/esm/codecs/metadata/v14.mjs

@@ -0,0 +1,39 @@
+import { Struct, u8, Vector, 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 { v14Pallet } from './pallets.mjs';
+
+const empty = new Uint8Array();
+const Always = (value) => createCodec(
+  () => empty,
+  () => value
+);
+const extrinsic = 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,
+  type: compactNumber,
+  apis: Always([])
+});
+
+export { v14 };
+//# sourceMappingURL=v14.mjs.map

package/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 = <T>(value: T) =>\n  createCodec<T>(\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})\nexport type V14Extrinsic = CodecType<typeof extrinsic>\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<CodecType<typeof runtimeApi>>),\n})\nexport type V14 = CodecType<typeof v14>\n"],"names":[],"mappings":";;;;;;;;;;;;;AAMA,MAAM,KAAA,GAAQ,IAAI,UAAW,EAAA,CAAA;AAC7B,MAAM,MAAA,GAAS,CAAI,KACjB,KAAA,WAAA;AAAA,EACE,MAAM,KAAA;AAAA,EACN,MAAM,KAAA;AACR,CAAA,CAAA;AAEF,MAAM,YAAY,MAAO,CAAA;AAAA,EACvB,IAAM,EAAA,aAAA;AAAA,EACN,OAAS,EAAA,EAAA;AAAA,EACT,gBAAkB,EAAA,MAAA;AAAA,IAChB,MAAO,CAAA;AAAA,MACL,UAAY,EAAA,GAAA;AAAA,MACZ,IAAM,EAAA,aAAA;AAAA,MACN,gBAAkB,EAAA,aAAA;AAAA,KACnB,CAAA;AAAA,GACH;AACF,CAAC,CAAA,CAAA;AAGM,MAAM,MAAM,MAAO,CAAA;AAAA,EACxB,MAAA;AAAA,EACA,OAAS,EAAA,MAAA,CAAO,MAAO,CAAA,EAAE,GAAG,SAAA,EAAW,IAAM,EAAA,MAAA,CAAO,EAAc,CAAE,EAAC,CAAC,CAAA;AAAA,EACtE,SAAA;AAAA,EACA,IAAM,EAAA,aAAA;AAAA,EACN,IAAA,EAAM,MAAO,CAAA,EAAyC,CAAA;AACxD,CAAC;;;;"}

package/dist/esm/codecs/metadata/v15.mjs

@@ -0,0 +1,44 @@
+import { Struct, u8, Vector, 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 { runtimeApi } from './runtime-api.mjs';
+
+const extrinsic = 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,
+  type: compactNumber,
+  apis: Vector(runtimeApi),
+  outerEnums: Struct({
+    call: compactNumber,
+    event: compactNumber,
+    error: compactNumber
+  }),
+  custom: Vector(Tuple(str, Struct({ type: compactNumber, value: Hex() })))
+});
+
+export { v15 };
+//# sourceMappingURL=v15.mjs.map

package/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 { runtimeApi } from \"./runtime-api\"\nexport type { V14Lookup } from \"./lookup\"\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})\nexport type V15Extrinsic = CodecType<typeof extrinsic>\n\nexport const v15 = Struct({\n  lookup,\n  pallets: Vector(Struct(v15Pallet)),\n  extrinsic,\n  type: ty,\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 V15 = CodecType<typeof v15>\n"],"names":["ty"],"mappings":";;;;;;;;;;;;;;AAOA,MAAM,YAAY,MAAO,CAAA;AAAA,EACvB,OAAS,EAAA,EAAA;AAAA,EACT,OAAS,EAAAA,aAAA;AAAA,EACT,IAAM,EAAAA,aAAA;AAAA,EACN,SAAW,EAAAA,aAAA;AAAA,EACX,KAAO,EAAAA,aAAA;AAAA,EACP,gBAAkB,EAAA,MAAA;AAAA,IAChB,MAAO,CAAA;AAAA,MACL,UAAY,EAAA,GAAA;AAAA,MACZ,IAAM,EAAAA,aAAA;AAAA,MACN,gBAAkB,EAAAA,aAAA;AAAA,KACnB,CAAA;AAAA,GACH;AACF,CAAC,CAAA,CAAA;AAGM,MAAM,MAAM,MAAO,CAAA;AAAA,EACxB,MAAA;AAAA,EACA,OAAS,EAAA,MAAA,CAAO,MAAO,CAAA,SAAS,CAAC,CAAA;AAAA,EACjC,SAAA;AAAA,EACA,IAAM,EAAAA,aAAA;AAAA,EACN,IAAA,EAAM,OAAO,UAAU,CAAA;AAAA,EACvB,YAAY,MAAO,CAAA;AAAA,IACjB,IAAM,EAAAA,aAAA;AAAA,IACN,KAAO,EAAAA,aAAA;AAAA,IACP,KAAO,EAAAA,aAAA;AAAA,GACR,CAAA;AAAA,EACD,MAAQ,EAAA,MAAA,CAAO,KAAM,CAAA,GAAA,EAAK,MAAO,CAAA,EAAE,IAAM,EAAAA,aAAA,EAAI,KAAO,EAAA,GAAA,EAAM,EAAC,CAAC,CAAC,CAAA;AAC/D,CAAC;;;;"}

package/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

package/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,WAAqB,EAAA;AAC/D,EAAA,OAAO,CAAC,OAAwB,KAAA;AAC9B,IAAM,MAAA,IAAA,GAAO,mBAAmB,OAAO,CAAA,CAAA;AACvC,IAAA,IAAI,CAAC,IAAK,CAAA,OAAA,EAAe,MAAA,IAAI,MAAM,kBAAkB,CAAA,CAAA;AACrD,IAAM,MAAA,EAAE,WAAc,GAAA,IAAA,CAAA;AACtB,IAAA,IAAI,UAAU,MAAW,KAAA,MAAA;AACvB,MAAM,MAAA,IAAI,MAAM,2BAA2B,CAAA,CAAA;AAE7C,IAAO,OAAA,SAAA,CAAA;AAAA,GACT,CAAA;AACF,CAAA;AAEO,MAAM,SAAY,GAAA,CAAC,UAAqB,GAAA,EAAA,EAAI,SAAkB,EACnE,KAAA,YAAA;AAAA,EACE,MAAM,MAAM,CAAA;AAAA,EACZ,kBAAA,CAAmB,MAAkB,CAAA;AAAA,EACrC,mBAAmB,UAAU,CAAA;AAC/B;;;;"}

package/dist/esm/codecs/scale/Binary.mjs

@@ -0,0 +1,62 @@
+import { createCodec, Bytes } from 'scale-ts';
+import { fromHex, toHex } from '@polkadot-api/utils';
+
+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, _hex, _str;
+const textEncoder = new TextEncoder();
+const textDecoder = new TextDecoder();
+const _Binary = class _Binary {
+  constructor(data) {
+    __privateAdd(this, _bytes);
+    __privateAdd(this, _hex, null);
+    __privateAdd(this, _str, null);
+    __publicField(this, "asText", () => __privateGet(this, _str) === null ? __privateSet(this, _str, textDecoder.decode(__privateGet(this, _bytes))) : __privateGet(this, _str));
+    __publicField(this, "asHex", () => __privateGet(this, _hex) === null ? __privateSet(this, _hex, toHex(__privateGet(this, _bytes))) : __privateGet(this, _hex));
+    __publicField(this, "asBytes", () => __privateGet(this, _bytes));
+    __privateSet(this, _bytes, data);
+  }
+  static fromText(input) {
+    return new _Binary(textEncoder.encode(input));
+  }
+  static fromHex(input) {
+    return new _Binary(fromHex(input));
+  }
+  static fromBytes(input) {
+    return new _Binary(input);
+  }
+};
+_bytes = new WeakMap();
+_hex = new WeakMap();
+_str = new WeakMap();
+let Binary = _Binary;
+class FixedSizeBinary extends Binary {
+  constructor(data) {
+    super(data);
+  }
+  static fromArray(input) {
+    return new FixedSizeBinary(new Uint8Array(input));
+  }
+}
+const enc = (nBytes) => {
+  const _enc = Bytes.enc(nBytes);
+  return (value) => _enc(value.asBytes());
+};
+const dec = (nBytes) => {
+  const _dec = Bytes.dec(nBytes);
+  return (value) => Binary.fromBytes(_dec(value));
+};
+const Bin = (nBytes) => createCodec(enc(nBytes), dec(nBytes));
+Bin.enc = enc;
+Bin.dec = dec;
+
+export { Bin, Binary, FixedSizeBinary };
+//# sourceMappingURL=Binary.mjs.map

package/dist/esm/codecs/scale/Binary.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"Binary.mjs","sources":["../../../../src/codecs/scale/Binary.ts"],"sourcesContent":["import { Bytes, Codec, Decoder, Encoder, createCodec } from \"scale-ts\"\nimport { fromHex, toHex } from \"@polkadot-api/utils\"\nimport { HexString } from \"./Hex\"\n\nconst textEncoder = new TextEncoder()\nconst textDecoder = new TextDecoder()\n\nexport class Binary {\n  #bytes: Uint8Array\n  #hex: HexString | null = null\n  #str: string | null = null\n\n  constructor(data: Uint8Array) {\n    this.#bytes = data\n  }\n\n  asText = () =>\n    this.#str === null\n      ? (this.#str = textDecoder.decode(this.#bytes))\n      : this.#str\n\n  asHex = () =>\n    this.#hex === null ? (this.#hex = toHex(this.#bytes)) : this.#hex\n\n  asBytes = () => this.#bytes\n\n  static fromText(input: string): Binary {\n    return new Binary(textEncoder.encode(input))\n  }\n  static fromHex(input: HexString): Binary {\n    return new Binary(fromHex(input))\n  }\n  static fromBytes(input: Uint8Array): Binary {\n    return new Binary(input)\n  }\n}\n\nexport class FixedSizeBinary<_L extends number> extends Binary {\n  constructor(data: Uint8Array) {\n    super(data)\n  }\n\n  static fromArray<L extends number, I extends Array<number> & { length: L }>(\n    input: I,\n  ) {\n    return new FixedSizeBinary<L>(new Uint8Array(input))\n  }\n}\n\nconst enc = (nBytes?: number): Encoder<Binary> => {\n  const _enc = Bytes.enc(nBytes)\n  return (value) => _enc(value.asBytes())\n}\n\nconst dec = (nBytes?: number): Decoder<Binary> => {\n  const _dec = Bytes.dec(nBytes)\n  return (value) => Binary.fromBytes(_dec(value))\n}\n\nexport const Bin = (nBytes?: number): Codec<Binary> =>\n  createCodec(enc(nBytes), dec(nBytes))\n\nBin.enc = enc\nBin.dec = dec\n"],"names":[],"mappings":"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"}

package/dist/esm/codecs/scale/Hex.mjs

@@ -0,0 +1,17 @@
+import { fromHex, toHex } from '@polkadot-api/utils';
+import { createCodec, Bytes } from 'scale-ts';
+
+const enc = (nBytes) => {
+  const _enc = Bytes.enc(nBytes);
+  return (value) => _enc(fromHex(value));
+};
+const dec = (nBytes) => {
+  const _dec = Bytes.dec(nBytes);
+  return (value) => toHex(_dec(value));
+};
+const Hex = (nBytes) => createCodec(enc(nBytes), dec(nBytes));
+Hex.enc = enc;
+Hex.dec = dec;
+
+export { Hex };
+//# sourceMappingURL=Hex.mjs.map

package/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 \"@polkadot-api/utils\"\nimport { Bytes, Codec, Decoder, Encoder, createCodec } from \"scale-ts\"\n\nexport type HexString = string & { __hexString?: unknown }\n\nconst enc = (nBytes?: number): Encoder<HexString> => {\n  const _enc = Bytes.enc(nBytes)\n  return (value: string) => _enc(fromHex(value))\n}\n\nconst dec = (nBytes?: number): Decoder<HexString> => {\n  const _dec = Bytes.dec(nBytes)\n  return (value) => toHex(_dec(value)) as HexString\n}\n\nexport const Hex = (nBytes?: number): Codec<HexString> =>\n  createCodec(enc(nBytes), dec(nBytes))\n\nHex.enc = enc\nHex.dec = dec\n"],"names":[],"mappings":";;;AAKA,MAAM,GAAA,GAAM,CAAC,MAAwC,KAAA;AACnD,EAAM,MAAA,IAAA,GAAO,KAAM,CAAA,GAAA,CAAI,MAAM,CAAA,CAAA;AAC7B,EAAA,OAAO,CAAC,KAAA,KAAkB,IAAK,CAAA,OAAA,CAAQ,KAAK,CAAC,CAAA,CAAA;AAC/C,CAAA,CAAA;AAEA,MAAM,GAAA,GAAM,CAAC,MAAwC,KAAA;AACnD,EAAM,MAAA,IAAA,GAAO,KAAM,CAAA,GAAA,CAAI,MAAM,CAAA,CAAA;AAC7B,EAAA,OAAO,CAAC,KAAA,KAAU,KAAM,CAAA,IAAA,CAAK,KAAK,CAAC,CAAA,CAAA;AACrC,CAAA,CAAA;AAEa,MAAA,GAAA,GAAM,CAAC,MAClB,KAAA,WAAA,CAAY,IAAI,MAAM,CAAA,EAAG,GAAI,CAAA,MAAM,CAAC,EAAA;AAEtC,GAAA,CAAI,GAAM,GAAA,GAAA,CAAA;AACV,GAAA,CAAI,GAAM,GAAA,GAAA;;;;"}

package/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

package/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 = <T>(value: () => Encoder<T>): Encoder<T> => {\n  let cache: Encoder<T> = (x) => {\n    const encoder = value()\n    cache = encoder\n    return encoder(x)\n  }\n\n  return (x) => cache(x)\n}\n\nexport const selfDecoder = <T>(value: () => Decoder<T>): Decoder<T> => {\n  let cache: Decoder<T> = (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 = <T>(value: () => Codec<T>): Codec<T> =>\n  createCodec(\n    selfEncoder(() => value().enc),\n    selfDecoder(() => value().dec),\n  )\n"],"names":[],"mappings":";;AAEa,MAAA,WAAA,GAAc,CAAI,KAAwC,KAAA;AACrE,EAAI,IAAA,KAAA,GAAoB,CAAC,CAAM,KAAA;AAC7B,IAAA,MAAM,UAAU,KAAM,EAAA,CAAA;AACtB,IAAQ,KAAA,GAAA,OAAA,CAAA;AACR,IAAA,OAAO,QAAQ,CAAC,CAAA,CAAA;AAAA,GAClB,CAAA;AAEA,EAAO,OAAA,CAAC,CAAM,KAAA,KAAA,CAAM,CAAC,CAAA,CAAA;AACvB,EAAA;AAEa,MAAA,WAAA,GAAc,CAAI,KAAwC,KAAA;AACrE,EAAI,IAAA,KAAA,GAAoB,CAAC,CAAM,KAAA;AAC7B,IAAA,MAAM,UAAU,KAAM,EAAA,CAAA;AACtB,IAAA,MAAM,MAAS,GAAA,OAAA,CAAA;AACf,IAAQ,KAAA,GAAA,OAAA,CAAA;AACR,IAAA,OAAO,OAAO,CAAC,CAAA,CAAA;AAAA,GACjB,CAAA;AAEA,EAAO,OAAA,CAAC,CAAM,KAAA,KAAA,CAAM,CAAC,CAAA,CAAA;AACvB,EAAA;AAEa,MAAA,IAAA,GAAO,CAAI,KACtB,KAAA,WAAA;AAAA,EACE,WAAY,CAAA,MAAM,KAAM,EAAA,CAAE,GAAG,CAAA;AAAA,EAC7B,WAAY,CAAA,MAAM,KAAM,EAAA,CAAE,GAAG,CAAA;AAC/B;;;;"}

package/dist/esm/codecs/scale/Variant.mjs

@@ -0,0 +1,30 @@
+import { createCodec, Enum } from 'scale-ts';
+import { mapObject } from '@polkadot-api/utils';
+import { Enum as Enum$1 } from '../../types/enum.mjs';
+
+const VariantEnc = (...args) => {
+  const enc = Enum.enc(...args);
+  return (v) => enc({ tag: v.type, value: v.value });
+};
+const VariantDec = (...args) => {
+  const dec = Enum.dec(...args);
+  return (v) => {
+    const { tag, value } = dec(v);
+    return Enum$1(tag, value);
+  };
+};
+const Variant = (inner, ...args) => createCodec(
+  VariantEnc(
+    mapObject(inner, ([encoder]) => encoder),
+    ...args
+  ),
+  VariantDec(
+    mapObject(inner, ([, decoder]) => decoder),
+    ...args
+  )
+);
+Variant.enc = VariantEnc;
+Variant.dec = VariantDec;
+
+export { Variant };
+//# sourceMappingURL=Variant.mjs.map

package/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 ScaleEnum,\n  StringRecord,\n  createCodec,\n} from \"scale-ts\"\nimport { mapObject } from \"@polkadot-api/utils\"\nimport { Enum } from \"@/types/enum\"\n\ntype Tuple<T, N extends number> = readonly [T, ...T[]] & { length: N }\n\ntype Push<T extends any[], V> = [...T, V]\n\ntype UnionToIntersection<U> = (U extends any ? (k: U) => void : never) extends (\n  k: infer I,\n) => void\n  ? I\n  : never\n\ntype LastOf<T> =\n  UnionToIntersection<T extends any ? () => T : never> extends () => infer R\n    ? R\n    : never\n\ntype TuplifyUnion<\n  T,\n  L = LastOf<T>,\n  N = [T] extends [never] ? true : false,\n> = true extends N ? [] : Push<TuplifyUnion<Exclude<T, L>>, L>\n\ntype RestrictedLenTuple<T, O extends StringRecord<any>> = Tuple<\n  T,\n  TuplifyUnion<keyof O> extends Tuple<any, infer V> ? V : 0\n>\n\nconst VariantEnc = <O extends StringRecord<Encoder<any>>>(\n  ...args: [inner: O, x?: RestrictedLenTuple<number, O>]\n): Encoder<\n  Enum<{\n    [K in keyof O]: EncoderType<O[K]>\n  }>\n> => {\n  const enc = ScaleEnum.enc<O>(...(args as [any, any]))\n  return (v) => enc({ tag: v.type, value: v.value })\n}\n\nconst VariantDec = <O extends StringRecord<Decoder<any>>>(\n  ...args: [inner: O, x?: RestrictedLenTuple<number, O>]\n): Decoder<\n  Enum<{\n    [K in keyof O]: DecoderType<O[K]>\n  }>\n> => {\n  const dec = ScaleEnum.dec<O>(...(args as [any, any]))\n  return (v) => {\n    const { tag, value } = dec(v)\n    return Enum(tag as any, value as any) as any\n  }\n}\n\nexport const Variant = <O extends StringRecord<Codec<any>>>(\n  inner: O,\n  ...args: [indexes?: RestrictedLenTuple<number, O>]\n): Codec<\n  Enum<{\n    [K in keyof O]: CodecType<O[K]>\n  }>\n> =>\n  createCodec(\n    VariantEnc(\n      mapObject(inner, ([encoder]) => encoder) as StringRecord<\n        O[keyof O][\"enc\"]\n      >,\n      ...(args as any[]),\n    ) as Encoder<\n      Enum<{\n        [K in keyof O]: CodecType<O[K]>\n      }>\n    >,\n    VariantDec(\n      mapObject(inner, ([, decoder]) => decoder) as StringRecord<\n        O[keyof O][\"dec\"]\n      >,\n      ...(args as any[]),\n    ) as Decoder<\n      Enum<{\n        [K in keyof O]: CodecType<O[K]>\n      }>\n    >,\n  )\n\nVariant.enc = VariantEnc\nVariant.dec = VariantDec\n"],"names":["ScaleEnum","Enum"],"mappings":";;;;AAwCA,MAAM,UAAA,GAAa,IACd,IAKA,KAAA;AACH,EAAA,MAAM,GAAM,GAAAA,IAAA,CAAU,GAAO,CAAA,GAAI,IAAmB,CAAA,CAAA;AACpD,EAAO,OAAA,CAAC,CAAM,KAAA,GAAA,CAAI,EAAE,GAAA,EAAK,EAAE,IAAM,EAAA,KAAA,EAAO,CAAE,CAAA,KAAA,EAAO,CAAA,CAAA;AACnD,CAAA,CAAA;AAEA,MAAM,UAAA,GAAa,IACd,IAKA,KAAA;AACH,EAAA,MAAM,GAAM,GAAAA,IAAA,CAAU,GAAO,CAAA,GAAI,IAAmB,CAAA,CAAA;AACpD,EAAA,OAAO,CAAC,CAAM,KAAA;AACZ,IAAA,MAAM,EAAE,GAAA,EAAK,KAAM,EAAA,GAAI,IAAI,CAAC,CAAA,CAAA;AAC5B,IAAO,OAAAC,MAAA,CAAK,KAAY,KAAY,CAAA,CAAA;AAAA,GACtC,CAAA;AACF,CAAA,CAAA;AAEa,MAAA,OAAA,GAAU,CACrB,KAAA,EAAA,GACG,IAMH,KAAA,WAAA;AAAA,EACE,UAAA;AAAA,IACE,UAAU,KAAO,EAAA,CAAC,CAAC,OAAO,MAAM,OAAO,CAAA;AAAA,IAGvC,GAAI,IAAA;AAAA,GACN;AAAA,EAKA,UAAA;AAAA,IACE,UAAU,KAAO,EAAA,CAAC,GAAG,OAAO,MAAM,OAAO,CAAA;AAAA,IAGzC,GAAI,IAAA;AAAA,GACN;AAKF,EAAA;AAEF,OAAA,CAAQ,GAAM,GAAA,UAAA,CAAA;AACd,OAAA,CAAQ,GAAM,GAAA,UAAA;;;;"}

package/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 = createCodec(bitSequenceEncoder, bitSequenceDecoder);
+
+export { bitSequence };
+//# sourceMappingURL=bitSequence.mjs.map

package/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<BitSequence> = 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<BitSequence> = (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":[],"mappings":";;;AAQA,MAAM,kBAAA,GAA2C,aAAc,CAAA,CAAC,IAAS,KAAA;AACvE,EAAM,MAAA,OAAA,GAAU,aAAc,CAAA,GAAA,CAAI,IAAI,CAAA,CAAA;AAEtC,EAAA,MAAM,QAAW,GAAA,IAAA,CAAK,IAAK,CAAA,OAAA,GAAU,CAAC,CAAA,CAAA;AACtC,EAAA,MAAM,KAAQ,GAAA,KAAA,CAAM,QAAQ,CAAA,CAAE,IAAI,IAAI,CAAA,CAAA;AACtC,EAAO,OAAA,EAAE,OAAO,OAAQ,EAAA,CAAA;AAC1B,CAAC,CAAA,CAAA;AAED,MAAM,kBAAA,GAA2C,CAAC,KAAU,KAAA;AAC1D,EAAA,IAAI,KAAM,CAAA,OAAA,GAAU,KAAM,CAAA,KAAA,CAAM,MAAS,GAAA,CAAA;AACvC,IAAA,MAAM,IAAI,KAAA;AAAA,MACR,8BAA8B,KAAM,CAAA,OAAO,CAAc,WAAA,EAAA,KAAA,CAAM,MAAM,MAAM,CAAA,CAAA,CAAA;AAAA,KAC7E,CAAA;AAEF,EAAA,MAAM,UAAa,GAAA,aAAA,CAAc,GAAI,CAAA,KAAA,CAAM,OAAO,CAAA,CAAA;AAClD,EAAA,MAAM,SAAS,IAAI,UAAA,CAAW,MAAM,KAAM,CAAA,MAAA,GAAS,WAAW,MAAM,CAAA,CAAA;AACpE,EAAO,MAAA,CAAA,GAAA,CAAI,YAAY,CAAC,CAAA,CAAA;AACxB,EAAA,MAAA,CAAO,GAAI,CAAA,KAAA,CAAM,KAAO,EAAA,UAAA,CAAW,MAAM,CAAA,CAAA;AACzC,EAAO,OAAA,MAAA,CAAA;AACT,CAAA,CAAA;AAEa,MAAA,WAAA,GAAc,WAAY,CAAA,kBAAA,EAAoB,kBAAkB;;;;"}

package/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

package/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,IAAO,GAAA,YAAA;AAAA,EAClB,EAAA;AAAA,EACA,CAAC,GAAA,KAAgB,GAAI,CAAA,UAAA,CAAW,CAAC,CAAA;AAAA,EACjC,MAAO,CAAA,YAAA;AACT;;;;"}

package/dist/esm/codecs/scale/compact.mjs

@@ -0,0 +1,7 @@
+import { compact } from 'scale-ts';
+
+const compactNumber = compact;
+const compactBn = compact;
+
+export { compactBn, compactNumber };
+//# sourceMappingURL=compact.mjs.map