@polkadot-api/substrate-bindings 0.1.0 → 0.3.0

package/dist/index.js

@@ -100,6 +100,7 @@ __export(src_exports, {
   u32: () => import_scale_ts8.u32,
   u64: () => import_scale_ts8.u64,
   u8: () => import_scale_ts8.u8,
+  v14: () => v14,
   v15: () => v15
 });
 module.exports = __toCommonJS(src_exports);
@@ -261,7 +262,7 @@ var bitSequence = (0, import_scale_ts4.createCodec)(bitSequenceEncoder, bitSeque
 var import_scale_ts5 = require("scale-ts");
 var char = (0, import_scale_ts5.enhanceCodec)(
   import_scale_ts5.u8,
-  (str5) => str5.charCodeAt(0),
+  (str8) => str8.charCodeAt(0),
   String.fromCharCode
 );
 
@@ -286,7 +287,7 @@ var textEncoder2 = new TextEncoder();
 var textDecoder2 = new TextDecoder();
 var fixedStr = (nBytes) => (0, import_scale_ts7.enhanceCodec)(
   (0, import_scale_ts7.Bytes)(nBytes),
-  (str5) => textEncoder2.encode(str5),
+  (str8) => textEncoder2.encode(str8),
   (bytes) => textDecoder2.decode(bytes)
 );
 
@@ -320,6 +321,22 @@ var Self = (value) => (0, import_scale_ts9.createCodec)(
 // src/codecs/scale/Variant.ts
 var import_scale_ts10 = require("scale-ts");
 var import_utils3 = require("@polkadot-api/utils");
+
+// src/types/enum.ts
+var Enum = (type, value) => {
+  return {
+    type,
+    value,
+    as(_type) {
+      if (type !== _type)
+        throw new Error(`Enum.as(${_type}) used with actual type ${type}`);
+      return value;
+    },
+    is(_type) {
+      return type === _type;
+    }
+  };
+};
 var _Enum = new Proxy(
   {},
   {
@@ -328,16 +345,8 @@ var _Enum = new Proxy(
     }
   }
 );
-var Enum = (_type, _value) => ({
-  as: (type) => {
-    if (type !== _type)
-      throw new Error(`Enum.as(${type}) used with actual type ${_type}`);
-    return _value;
-  },
-  is: (type) => type === _type,
-  type: _type,
-  value: _value
-});
+
+// src/codecs/scale/Variant.ts
 var VariantEnc = (...args) => {
   const enc3 = import_scale_ts10.Enum.enc(...args);
   return (v) => enc3({ tag: v.type, value: v.value });
@@ -423,141 +432,150 @@ var blockHeader = (0, import_scale_ts8.Struct)({
   digests: (0, import_scale_ts8.Vector)(diggest)
 });
 
-// src/codecs/metadata/v15/v15.ts
-var import_scale_ts14 = require("scale-ts");
+// src/codecs/metadata/metadata.ts
+var import_scale_ts18 = require("scale-ts");
+
+// src/codecs/metadata/v15.ts
+var import_scale_ts16 = require("scale-ts");
 
-// src/codecs/metadata/v15/lookup.ts
+// src/codecs/metadata/lookup.ts
+var import_scale_ts13 = require("scale-ts");
+
+// src/codecs/metadata/docs.ts
 var import_scale_ts12 = require("scale-ts");
-var oStr = (0, import_scale_ts12.Option)(import_scale_ts12.str);
-var strs = (0, import_scale_ts12.Vector)(import_scale_ts12.str);
-var primitive = (0, import_scale_ts12.Enum)({
-  bool: import_scale_ts12._void,
-  char: import_scale_ts12._void,
-  str: import_scale_ts12._void,
-  u8: import_scale_ts12._void,
-  u16: import_scale_ts12._void,
-  u32: import_scale_ts12._void,
-  u64: import_scale_ts12._void,
-  u128: import_scale_ts12._void,
-  u256: import_scale_ts12._void,
-  i8: import_scale_ts12._void,
-  i16: import_scale_ts12._void,
-  i32: import_scale_ts12._void,
-  i64: import_scale_ts12._void,
-  i128: import_scale_ts12._void,
-  i256: import_scale_ts12._void
+var docs = (0, import_scale_ts12.Vector)(import_scale_ts12.str);
+
+// src/codecs/metadata/lookup.ts
+var oStr = (0, import_scale_ts13.Option)(import_scale_ts13.str);
+var primitive = (0, import_scale_ts13.Enum)({
+  bool: import_scale_ts13._void,
+  char: import_scale_ts13._void,
+  str: import_scale_ts13._void,
+  u8: import_scale_ts13._void,
+  u16: import_scale_ts13._void,
+  u32: import_scale_ts13._void,
+  u64: import_scale_ts13._void,
+  u128: import_scale_ts13._void,
+  u256: import_scale_ts13._void,
+  i8: import_scale_ts13._void,
+  i16: import_scale_ts13._void,
+  i32: import_scale_ts13._void,
+  i64: import_scale_ts13._void,
+  i128: import_scale_ts13._void,
+  i256: import_scale_ts13._void
 });
-var fields = (0, import_scale_ts12.Vector)(
-  (0, import_scale_ts12.Struct)({
+var fields = (0, import_scale_ts13.Vector)(
+  (0, import_scale_ts13.Struct)({
     name: oStr,
     type: compactNumber,
     typeName: oStr,
-    docs: strs
+    docs
   })
 );
-var arr = (0, import_scale_ts12.Struct)({
-  len: import_scale_ts12.u32,
+var arr = (0, import_scale_ts13.Struct)({
+  len: import_scale_ts13.u32,
   type: compactNumber
 });
-var bitSequence2 = (0, import_scale_ts12.Struct)({
+var bitSequence2 = (0, import_scale_ts13.Struct)({
   bitStoreType: compactNumber,
   bitOrderType: compactNumber
 });
-var variant = (0, import_scale_ts12.Vector)(
-  (0, import_scale_ts12.Struct)({
-    name: import_scale_ts12.str,
+var variant = (0, import_scale_ts13.Vector)(
+  (0, import_scale_ts13.Struct)({
+    name: import_scale_ts13.str,
     fields,
-    index: import_scale_ts12.u8,
-    docs: strs
+    index: import_scale_ts13.u8,
+    docs
   })
 );
-var def = (0, import_scale_ts12.Enum)({
+var def = (0, import_scale_ts13.Enum)({
   composite: fields,
   variant,
   sequence: compactNumber,
   array: arr,
-  tuple: (0, import_scale_ts12.Vector)(compactNumber),
+  tuple: (0, import_scale_ts13.Vector)(compactNumber),
   primitive,
   compact: compactNumber,
   bitSequence: bitSequence2
 });
-var param = (0, import_scale_ts12.Struct)({
-  name: import_scale_ts12.str,
-  type: (0, import_scale_ts12.Option)(compactNumber)
+var param = (0, import_scale_ts13.Struct)({
+  name: import_scale_ts13.str,
+  type: (0, import_scale_ts13.Option)(compactNumber)
 });
-var params = (0, import_scale_ts12.Vector)(param);
-var entry = (0, import_scale_ts12.Struct)({
+var params = (0, import_scale_ts13.Vector)(param);
+var entry = (0, import_scale_ts13.Struct)({
   id: compactNumber,
-  path: strs,
+  path: docs,
   params,
   def,
-  docs: strs
+  docs
 });
-var lookup = (0, import_scale_ts12.Vector)(entry);
+var lookup = (0, import_scale_ts13.Vector)(entry);
 
-// src/codecs/metadata/v15/pallets.ts
-var import_scale_ts13 = require("scale-ts");
-var hashType = (0, import_scale_ts13.Enum)({
-  Blake2128: import_scale_ts13._void,
-  Blake2256: import_scale_ts13._void,
-  Blake2128Concat: import_scale_ts13._void,
-  Twox128: import_scale_ts13._void,
-  Twox256: import_scale_ts13._void,
-  Twox64Concat: import_scale_ts13._void,
-  Identity: import_scale_ts13._void
+// src/codecs/metadata/pallets.ts
+var import_scale_ts14 = require("scale-ts");
+var hashType = (0, import_scale_ts14.Enum)({
+  Blake2128: import_scale_ts14._void,
+  Blake2256: import_scale_ts14._void,
+  Blake2128Concat: import_scale_ts14._void,
+  Twox128: import_scale_ts14._void,
+  Twox256: import_scale_ts14._void,
+  Twox64Concat: import_scale_ts14._void,
+  Identity: import_scale_ts14._void
 });
-var hashers = (0, import_scale_ts13.Vector)(hashType);
-var storageMap = (0, import_scale_ts13.Struct)({
+var hashers = (0, import_scale_ts14.Vector)(hashType);
+var storageMap = (0, import_scale_ts14.Struct)({
   hashers,
   key: compactNumber,
   value: compactNumber
 });
-var storageItem = (0, import_scale_ts13.Struct)({
-  name: import_scale_ts13.str,
-  modifier: import_scale_ts13.u8,
-  type: (0, import_scale_ts13.Enum)({
+var storageItem = (0, import_scale_ts14.Struct)({
+  name: import_scale_ts14.str,
+  modifier: import_scale_ts14.u8,
+  type: (0, import_scale_ts14.Enum)({
     plain: compactNumber,
     map: storageMap
   }),
   fallback: Hex(),
-  docs: (0, import_scale_ts13.Vector)(import_scale_ts13.str)
+  docs
 });
-var storage = (0, import_scale_ts13.Option)(
-  (0, import_scale_ts13.Struct)({
-    prefix: import_scale_ts13.str,
-    items: (0, import_scale_ts13.Vector)(storageItem)
+var storage = (0, import_scale_ts14.Option)(
+  (0, import_scale_ts14.Struct)({
+    prefix: import_scale_ts14.str,
+    items: (0, import_scale_ts14.Vector)(storageItem)
   })
 );
-var pallets = (0, import_scale_ts13.Vector)(
-  (0, import_scale_ts13.Struct)({
-    name: import_scale_ts13.str,
-    storage,
-    calls: (0, import_scale_ts13.Option)(compactNumber),
-    events: (0, import_scale_ts13.Option)(compactNumber),
-    constants: (0, import_scale_ts13.Vector)(
-      (0, import_scale_ts13.Struct)({
-        name: import_scale_ts13.str,
-        type: compactNumber,
-        value: Hex(),
-        docs: (0, import_scale_ts13.Vector)(import_scale_ts13.str)
-      })
-    ),
-    errors: (0, import_scale_ts13.Option)(compactNumber),
-    index: import_scale_ts13.u8,
-    docs: (0, import_scale_ts13.Vector)(import_scale_ts13.str)
-  })
-);
-
-// src/codecs/metadata/v15/v15.ts
-var docs = (0, import_scale_ts14.Vector)(import_scale_ts14.str);
-var runtimeApi = (0, import_scale_ts14.Struct)({
+var v14Pallet = {
   name: import_scale_ts14.str,
-  methods: (0, import_scale_ts14.Vector)(
+  storage,
+  calls: (0, import_scale_ts14.Option)(compactNumber),
+  events: (0, import_scale_ts14.Option)(compactNumber),
+  constants: (0, import_scale_ts14.Vector)(
     (0, import_scale_ts14.Struct)({
       name: import_scale_ts14.str,
-      inputs: (0, import_scale_ts14.Vector)(
-        (0, import_scale_ts14.Struct)({
-          name: import_scale_ts14.str,
+      type: compactNumber,
+      value: Hex(),
+      docs
+    })
+  ),
+  errors: (0, import_scale_ts14.Option)(compactNumber),
+  index: import_scale_ts14.u8
+};
+var v15Pallet = {
+  ...v14Pallet,
+  docs
+};
+
+// src/codecs/metadata/runtime-api.ts
+var import_scale_ts15 = require("scale-ts");
+var runtimeApi = (0, import_scale_ts15.Struct)({
+  name: import_scale_ts15.str,
+  methods: (0, import_scale_ts15.Vector)(
+    (0, import_scale_ts15.Struct)({
+      name: import_scale_ts15.str,
+      inputs: (0, import_scale_ts15.Vector)(
+        (0, import_scale_ts15.Struct)({
+          name: import_scale_ts15.str,
           type: compactNumber
         })
       ),
@@ -567,46 +585,73 @@ var runtimeApi = (0, import_scale_ts14.Struct)({
   ),
   docs
 });
-var extrinsic = (0, import_scale_ts14.Struct)({
-  version: import_scale_ts14.u8,
+
+// src/codecs/metadata/v15.ts
+var extrinsic = (0, import_scale_ts16.Struct)({
+  version: import_scale_ts16.u8,
   address: compactNumber,
   call: compactNumber,
   signature: compactNumber,
   extra: compactNumber,
-  signedExtensions: (0, import_scale_ts14.Vector)(
-    (0, import_scale_ts14.Struct)({
-      identifier: import_scale_ts14.str,
+  signedExtensions: (0, import_scale_ts16.Vector)(
+    (0, import_scale_ts16.Struct)({
+      identifier: import_scale_ts16.str,
       type: compactNumber,
       additionalSigned: compactNumber
     })
   )
 });
-var v15 = (0, import_scale_ts14.Struct)({
+var v15 = (0, import_scale_ts16.Struct)({
   lookup,
-  pallets,
+  pallets: (0, import_scale_ts16.Vector)((0, import_scale_ts16.Struct)(v15Pallet)),
   extrinsic,
   type: compactNumber,
-  apis: (0, import_scale_ts14.Vector)(runtimeApi),
-  outerEnums: (0, import_scale_ts14.Struct)({
+  apis: (0, import_scale_ts16.Vector)(runtimeApi),
+  outerEnums: (0, import_scale_ts16.Struct)({
     call: compactNumber,
     event: compactNumber,
     error: compactNumber
   }),
-  custom: (0, import_scale_ts14.Vector)((0, import_scale_ts14.Tuple)(import_scale_ts14.str, (0, import_scale_ts14.Struct)({ type: compactNumber, value: Hex() })))
+  custom: (0, import_scale_ts16.Vector)((0, import_scale_ts16.Tuple)(import_scale_ts16.str, (0, import_scale_ts16.Struct)({ type: compactNumber, value: Hex() })))
+});
+
+// src/codecs/metadata/v14.ts
+var import_scale_ts17 = require("scale-ts");
+var empty = new Uint8Array();
+var Always = (value) => (0, import_scale_ts17.createCodec)(
+  () => empty,
+  () => value
+);
+var extrinsic2 = (0, import_scale_ts17.Struct)({
+  type: compactNumber,
+  version: import_scale_ts17.u8,
+  signedExtensions: (0, import_scale_ts17.Vector)(
+    (0, import_scale_ts17.Struct)({
+      identifier: import_scale_ts17.str,
+      type: compactNumber,
+      additionalSigned: compactNumber
+    })
+  )
+});
+var v14 = (0, import_scale_ts17.Struct)({
+  lookup,
+  pallets: (0, import_scale_ts17.Vector)((0, import_scale_ts17.Struct)({ ...v14Pallet, docs: Always([]) })),
+  extrinsic: extrinsic2,
+  type: compactNumber,
+  apis: Always([])
 });
 
 // src/codecs/metadata/metadata.ts
-var import_scale_ts15 = require("scale-ts");
 var unsupportedFn = () => {
   throw new Error("Unsupported metadata version!");
 };
-var unsupported = (0, import_scale_ts15.createCodec)(
+var unsupported = (0, import_scale_ts18.createCodec)(
   unsupportedFn,
   unsupportedFn
 );
-var metadata = (0, import_scale_ts15.Struct)({
-  magicNumber: import_scale_ts15.u32,
-  metadata: (0, import_scale_ts15.Enum)({
+var metadata = (0, import_scale_ts18.Struct)({
+  magicNumber: import_scale_ts18.u32,
+  metadata: (0, import_scale_ts18.Enum)({
     v0: unsupported,
     v1: unsupported,
     v2: unsupported,
@@ -621,7 +666,7 @@ var metadata = (0, import_scale_ts15.Struct)({
     v11: unsupported,
     v12: unsupported,
     v13: unsupported,
-    v14: unsupported,
+    v14,
     v15
   })
 });
@@ -640,7 +685,7 @@ var Identity = (encoded) => encoded;
 
 // src/hashes/twoX.ts
 var import_utils6 = require("@polkadot-api/utils");
-var import_scale_ts16 = require("scale-ts");
+var import_scale_ts19 = require("scale-ts");
 
 // src/hashes/h64.ts
 var bigintFromU16 = (v0, v1, v2, v3) => new DataView(new Uint16Array([v0, v1, v2, v3]).buffer).getBigUint64(0, true);
@@ -793,7 +838,7 @@ var Twox256 = (input) => {
   dv.setBigUint64(24, h64(input, 3n), true);
   return result;
 };
-var Twox64Concat = (encoded) => (0, import_utils6.mergeUint8)(import_scale_ts16.u64.enc(h64(encoded)), encoded);
+var Twox64Concat = (encoded) => (0, import_utils6.mergeUint8)(import_scale_ts19.u64.enc(h64(encoded)), encoded);
 
 // src/storage.ts
 var import_utils7 = require("@polkadot-api/utils");