@polkadot-api/substrate-bindings 0.0.1 → 0.2.0

package/dist/index.js

@@ -79,6 +79,7 @@ __export(src_exports, {
   enhanceCodec: () => import_scale_ts8.enhanceCodec,
   enhanceDecoder: () => import_scale_ts8.enhanceDecoder,
   enhanceEncoder: () => import_scale_ts8.enhanceEncoder,
+  ethAccount: () => ethAccount,
   fixedStr: () => fixedStr,
   fromBufferToBase58: () => fromBufferToBase58,
   getSs58AddressInfo: () => getSs58AddressInfo,
@@ -99,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);
@@ -260,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
 );
 
@@ -285,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)
 );
 
@@ -361,6 +363,37 @@ var Variant = (inner, ...args) => (0, import_scale_ts10.createCodec)(
 Variant.enc = VariantEnc;
 Variant.dec = VariantDec;
 
+// src/codecs/scale/ethAccount.ts
+var import_utils4 = require("@polkadot-api/utils");
+var import_scale_ts11 = require("scale-ts");
+var import_sha3 = require("@noble/hashes/sha3");
+var getFormattedAddress = (hexAddress) => {
+  const nonChecksum = hexAddress.slice(2);
+  const hashedAddress = (0, import_utils4.toHex)((0, import_sha3.keccak_256)(nonChecksum)).slice(2);
+  const result = new Array(40);
+  for (let i = 0; i < 40; i++) {
+    const checksumVal = parseInt(hashedAddress[i], 16);
+    const char2 = nonChecksum[i];
+    result[i] = checksumVal > 7 ? char2.toUpperCase() : char2;
+  }
+  return `0x${result.join("")}`;
+};
+var bytes20Dec = (0, import_scale_ts11.Bytes)(20)[1];
+var ethAccount = (0, import_scale_ts11.createCodec)(
+  (input) => {
+    const bytes = (0, import_utils4.fromHex)(input);
+    if (bytes.length !== 20)
+      throw new Error(`Invalid length found on EthAddress(${input})`);
+    const hexAddress = (0, import_utils4.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;
+  },
+  (0, import_scale_ts11.createDecoder)((bytes) => getFormattedAddress((0, import_utils4.toHex)(bytes20Dec(bytes))))
+);
+
 // src/codecs/blockHeader.ts
 var textEncoder3 = new TextEncoder();
 var textDecoder3 = new TextDecoder();
@@ -391,141 +424,150 @@ var blockHeader = (0, import_scale_ts8.Struct)({
   digests: (0, import_scale_ts8.Vector)(diggest)
 });
 
-// src/codecs/metadata/v15/v15.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/lookup.ts
 var import_scale_ts13 = require("scale-ts");
 
-// src/codecs/metadata/v15/lookup.ts
-var import_scale_ts11 = require("scale-ts");
-var oStr = (0, import_scale_ts11.Option)(import_scale_ts11.str);
-var strs = (0, import_scale_ts11.Vector)(import_scale_ts11.str);
-var primitive = (0, import_scale_ts11.Enum)({
-  bool: import_scale_ts11._void,
-  char: import_scale_ts11._void,
-  str: import_scale_ts11._void,
-  u8: import_scale_ts11._void,
-  u16: import_scale_ts11._void,
-  u32: import_scale_ts11._void,
-  u64: import_scale_ts11._void,
-  u128: import_scale_ts11._void,
-  u256: import_scale_ts11._void,
-  i8: import_scale_ts11._void,
-  i16: import_scale_ts11._void,
-  i32: import_scale_ts11._void,
-  i64: import_scale_ts11._void,
-  i128: import_scale_ts11._void,
-  i256: import_scale_ts11._void
+// src/codecs/metadata/docs.ts
+var import_scale_ts12 = require("scale-ts");
+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_ts11.Vector)(
-  (0, import_scale_ts11.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_ts11.Struct)({
-  len: import_scale_ts11.u32,
+var arr = (0, import_scale_ts13.Struct)({
+  len: import_scale_ts13.u32,
   type: compactNumber
 });
-var bitSequence2 = (0, import_scale_ts11.Struct)({
+var bitSequence2 = (0, import_scale_ts13.Struct)({
   bitStoreType: compactNumber,
   bitOrderType: compactNumber
 });
-var variant = (0, import_scale_ts11.Vector)(
-  (0, import_scale_ts11.Struct)({
-    name: import_scale_ts11.str,
+var variant = (0, import_scale_ts13.Vector)(
+  (0, import_scale_ts13.Struct)({
+    name: import_scale_ts13.str,
     fields,
-    index: import_scale_ts11.u8,
-    docs: strs
+    index: import_scale_ts13.u8,
+    docs
   })
 );
-var def = (0, import_scale_ts11.Enum)({
+var def = (0, import_scale_ts13.Enum)({
   composite: fields,
   variant,
   sequence: compactNumber,
   array: arr,
-  tuple: (0, import_scale_ts11.Vector)(compactNumber),
+  tuple: (0, import_scale_ts13.Vector)(compactNumber),
   primitive,
   compact: compactNumber,
   bitSequence: bitSequence2
 });
-var param = (0, import_scale_ts11.Struct)({
-  name: import_scale_ts11.str,
-  type: (0, import_scale_ts11.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_ts11.Vector)(param);
-var entry = (0, import_scale_ts11.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_ts11.Vector)(entry);
+var lookup = (0, import_scale_ts13.Vector)(entry);
 
-// src/codecs/metadata/v15/pallets.ts
-var import_scale_ts12 = require("scale-ts");
-var hashType = (0, import_scale_ts12.Enum)({
-  Blake2128: import_scale_ts12._void,
-  Blake2256: import_scale_ts12._void,
-  Blake2128Concat: import_scale_ts12._void,
-  Twox128: import_scale_ts12._void,
-  Twox256: import_scale_ts12._void,
-  Twox64Concat: import_scale_ts12._void,
-  Identity: import_scale_ts12._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_ts12.Vector)(hashType);
-var storageMap = (0, import_scale_ts12.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_ts12.Struct)({
-  name: import_scale_ts12.str,
-  modifier: import_scale_ts12.u8,
-  type: (0, import_scale_ts12.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_ts12.Vector)(import_scale_ts12.str)
+  docs
 });
-var storage = (0, import_scale_ts12.Option)(
-  (0, import_scale_ts12.Struct)({
-    prefix: import_scale_ts12.str,
-    items: (0, import_scale_ts12.Vector)(storageItem)
-  })
-);
-var pallets = (0, import_scale_ts12.Vector)(
-  (0, import_scale_ts12.Struct)({
-    name: import_scale_ts12.str,
-    storage,
-    calls: (0, import_scale_ts12.Option)(compactNumber),
-    events: (0, import_scale_ts12.Option)(compactNumber),
-    constants: (0, import_scale_ts12.Vector)(
-      (0, import_scale_ts12.Struct)({
-        name: import_scale_ts12.str,
-        type: compactNumber,
-        value: Hex(),
-        docs: (0, import_scale_ts12.Vector)(import_scale_ts12.str)
-      })
-    ),
-    errors: (0, import_scale_ts12.Option)(compactNumber),
-    index: import_scale_ts12.u8,
-    docs: (0, import_scale_ts12.Vector)(import_scale_ts12.str)
+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 v14Pallet = {
+  name: import_scale_ts14.str,
+  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,
+      type: compactNumber,
+      value: Hex(),
+      docs
+    })
+  ),
+  errors: (0, import_scale_ts14.Option)(compactNumber),
+  index: import_scale_ts14.u8
+};
+var v15Pallet = {
+  ...v14Pallet,
+  docs
+};
 
-// src/codecs/metadata/v15/v15.ts
-var docs = (0, import_scale_ts13.Vector)(import_scale_ts13.str);
-var runtimeApi = (0, import_scale_ts13.Struct)({
-  name: import_scale_ts13.str,
-  methods: (0, import_scale_ts13.Vector)(
-    (0, import_scale_ts13.Struct)({
-      name: import_scale_ts13.str,
-      inputs: (0, import_scale_ts13.Vector)(
-        (0, import_scale_ts13.Struct)({
-          name: import_scale_ts13.str,
+// 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
         })
       ),
@@ -535,46 +577,73 @@ var runtimeApi = (0, import_scale_ts13.Struct)({
   ),
   docs
 });
-var extrinsic = (0, import_scale_ts13.Struct)({
-  version: import_scale_ts13.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_ts13.Vector)(
-    (0, import_scale_ts13.Struct)({
-      identifier: import_scale_ts13.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_ts13.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_ts13.Vector)(runtimeApi),
-  outerEnums: (0, import_scale_ts13.Struct)({
+  apis: (0, import_scale_ts16.Vector)(runtimeApi),
+  outerEnums: (0, import_scale_ts16.Struct)({
     call: compactNumber,
     event: compactNumber,
     error: compactNumber
   }),
-  custom: (0, import_scale_ts13.Vector)((0, import_scale_ts13.Tuple)(import_scale_ts13.str, (0, import_scale_ts13.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_ts14 = require("scale-ts");
 var unsupportedFn = () => {
   throw new Error("Unsupported metadata version!");
 };
-var unsupported = (0, import_scale_ts14.createCodec)(
+var unsupported = (0, import_scale_ts18.createCodec)(
   unsupportedFn,
   unsupportedFn
 );
-var metadata = (0, import_scale_ts14.Struct)({
-  magicNumber: import_scale_ts14.u32,
-  metadata: (0, import_scale_ts14.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,
@@ -589,26 +658,26 @@ var metadata = (0, import_scale_ts14.Struct)({
     v11: unsupported,
     v12: unsupported,
     v13: unsupported,
-    v14: unsupported,
+    v14,
     v15
   })
 });
 
 // src/hashes/blake2.ts
-var import_utils4 = require("@polkadot-api/utils");
+var import_utils5 = require("@polkadot-api/utils");
 var import_blake2b2 = require("@noble/hashes/blake2b");
 var len32 = { dkLen: 32 };
 var Blake2256 = (encoded) => (0, import_blake2b2.blake2b)(encoded, len32);
 var len16 = { dkLen: 16 };
 var Blake2128 = (encoded) => (0, import_blake2b2.blake2b)(encoded, len16);
-var Blake2128Concat = (encoded) => (0, import_utils4.mergeUint8)(Blake2128(encoded), encoded);
+var Blake2128Concat = (encoded) => (0, import_utils5.mergeUint8)(Blake2128(encoded), encoded);
 
 // src/hashes/identity.ts
 var Identity = (encoded) => encoded;
 
 // src/hashes/twoX.ts
-var import_utils5 = require("@polkadot-api/utils");
-var import_scale_ts15 = require("scale-ts");
+var import_utils6 = require("@polkadot-api/utils");
+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);
@@ -761,19 +830,19 @@ var Twox256 = (input) => {
   dv.setBigUint64(24, h64(input, 3n), true);
   return result;
 };
-var Twox64Concat = (encoded) => (0, import_utils5.mergeUint8)(import_scale_ts15.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_utils6 = require("@polkadot-api/utils");
+var import_utils7 = require("@polkadot-api/utils");
 var textEncoder4 = new TextEncoder();
 var Storage = (pallet) => {
   const palledEncoded = Twox128(textEncoder4.encode(pallet));
   return (name, dec3, ...encoders) => {
-    const palletItemEncoded = (0, import_utils6.mergeUint8)(
+    const palletItemEncoded = (0, import_utils7.mergeUint8)(
       palledEncoded,
       Twox128(textEncoder4.encode(name))
     );
-    const palletItemEncodedHex = (0, import_utils6.toHex)(palletItemEncoded);
+    const palletItemEncodedHex = (0, import_utils7.toHex)(palletItemEncoded);
     const bytesToSkip = encoders.map((e) => e[1]).map((x) => {
       if (x === Identity)
         return 0;
@@ -803,8 +872,8 @@ var Storage = (pallet) => {
     const fns = encoders.map(
       ([{ enc: enc4 }, hash]) => (val) => hash(enc4(val))
     );
-    const enc3 = (...args) => (0, import_utils6.toHex)(
-      (0, import_utils6.mergeUint8)(palletItemEncoded, ...args.map((val, idx) => fns[idx](val)))
+    const enc3 = (...args) => (0, import_utils7.toHex)(
+      (0, import_utils7.mergeUint8)(palletItemEncoded, ...args.map((val, idx) => fns[idx](val)))
     );
     return {
       enc: enc3,