@polkadot-api/substrate-bindings 0.12.0 → 0.14.0

package/dist/index.js

@@ -98,10 +98,10 @@ class Binary {
     __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.asBytes())));
     __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)
-    )));
+    __publicField(this, "asOpaqueBytes", () => __privateGet(this, _opaqueBytes) || __privateSet(this, _opaqueBytes, utils.mergeUint8([
+      __privateGet(this, _bytes),
+      scaleTs.compact[0](__privateGet(this, _bytes).length)
+    ])));
     if (opaque) {
       try {
         const [len, bytes] = opaqueBytesDec(data);
@@ -433,6 +433,61 @@ const entry = scaleTs.Struct({
 });
 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,
@@ -448,7 +503,7 @@ const storageMap = scaleTs.Struct({
   key: compactNumber,
   value: compactNumber
 });
-const storageItem = scaleTs.Struct({
+const storageItem = {
   name: scaleTs.str,
   modifier: scaleTs.u8,
   type: scaleTs.Enum({
@@ -457,18 +512,18 @@ const storageItem = scaleTs.Struct({
   }),
   fallback: Hex(),
   docs
-});
-const storage = scaleTs.Option(
-  scaleTs.Struct({
-    prefix: scaleTs.str,
-    items: scaleTs.Vector(storageItem)
-  })
-);
+};
+const enumRefV14 = scaleTs.Option(compactNumber);
 const v14Pallet = {
   name: scaleTs.str,
-  storage,
-  calls: scaleTs.Option(compactNumber),
-  events: scaleTs.Option(compactNumber),
+  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,
@@ -477,20 +532,60 @@ const v14Pallet = {
       docs
     })
   ),
-  errors: scaleTs.Option(compactNumber),
+  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$1 = scaleTs.Struct({
+const extrinsic$2 = scaleTs.Struct({
   type: compactNumber,
   version: scaleTs.u8,
   signedExtensions: scaleTs.Vector(
@@ -504,35 +599,45 @@ const extrinsic$1 = scaleTs.Struct({
 const v14 = scaleTs.Struct({
   lookup,
   pallets: scaleTs.Vector(scaleTs.Struct({ ...v14Pallet, docs: Always([]) })),
-  extrinsic: extrinsic$1,
+  extrinsic: extrinsic$2,
   type: compactNumber,
   apis: Always([])
 });
 
-const runtimeApi = scaleTs.Struct({
-  name: scaleTs.str,
-  methods: scaleTs.Vector(
+const extrinsic$1 = scaleTs.Struct({
+  version: scaleTs.u8,
+  address: compactNumber,
+  call: compactNumber,
+  signature: compactNumber,
+  extra: compactNumber,
+  signedExtensions: scaleTs.Vector(
     scaleTs.Struct({
-      name: scaleTs.str,
-      inputs: scaleTs.Vector(
-        scaleTs.Struct({
-          name: scaleTs.str,
-          type: compactNumber
-        })
-      ),
-      output: compactNumber,
-      docs
+      identifier: scaleTs.str,
+      type: compactNumber,
+      additionalSigned: compactNumber
     })
-  ),
-  docs
+  )
+});
+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.u8,
+  version: scaleTs.Vector(scaleTs.u8),
   address: compactNumber,
   call: compactNumber,
   signature: compactNumber,
-  extra: compactNumber,
+  signedExtensionsByVersion: scaleTs.Vector(scaleTs.Tuple(scaleTs.u8, scaleTs.Vector(compactNumber))),
   signedExtensions: scaleTs.Vector(
     scaleTs.Struct({
       identifier: scaleTs.str,
@@ -541,11 +646,10 @@ const extrinsic = scaleTs.Struct({
     })
   )
 });
-const v15 = scaleTs.Struct({
+const v16 = scaleTs.Struct({
   lookup,
-  pallets: scaleTs.Vector(scaleTs.Struct(v15Pallet)),
+  pallets: scaleTs.Vector(scaleTs.Struct(v16Pallet)),
   extrinsic,
-  type: compactNumber,
   apis: scaleTs.Vector(runtimeApi),
   outerEnums: scaleTs.Struct({
     call: compactNumber,
@@ -580,7 +684,8 @@ const metadata = scaleTs.Struct({
     v12: unsupported,
     v13: unsupported,
     v14,
-    v15
+    v15,
+    v16
   })
 });
 const opaqueBytes = scaleTs.Bytes();
@@ -606,15 +711,83 @@ const decAnyMetadata = (input) => {
   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 len32$1 = { dkLen: 32 };
 const Blake2256 = (encoded) => blake2b.blake2b(encoded, len32$1);
 const len16 = { dkLen: 16 };
 const Blake2128 = (encoded) => blake2b.blake2b(encoded, len16);
-const Blake2128Concat = (encoded) => utils.mergeUint8(Blake2128(encoded), encoded);
+const Blake2128Concat = (encoded) => utils.mergeUint8([Blake2128(encoded), encoded]);
 
 const len32 = { dkLen: 32 };
 const Blake3256 = (encoded) => blake3.blake3(encoded, len32);
-const Blake3256Concat = (encoded) => utils.mergeUint8(Blake3256(encoded), encoded);
+const Blake3256Concat = (encoded) => utils.mergeUint8([Blake3256(encoded), encoded]);
 
 const Identity = (encoded) => encoded;
 
@@ -766,7 +939,7 @@ const Twox256 = (input) => {
   dv.setBigUint64(24, h64(input, 3n), true);
   return result;
 };
-const Twox64Concat = (encoded) => utils.mergeUint8(scaleTs.u64.enc(h64(encoded)), encoded);
+const Twox64Concat = (encoded) => utils.mergeUint8([scaleTs.u64.enc(h64(encoded)), encoded]);
 
 const textEncoder = new TextEncoder();
 const hashers = /* @__PURE__ */ new Map([
@@ -781,10 +954,10 @@ const hashers = /* @__PURE__ */ new Map([
 const Storage = (pallet) => {
   const palledEncoded = Twox128(textEncoder.encode(pallet));
   return (name, ...encoders) => {
-    const palletItemEncoded = utils.mergeUint8(
+    const palletItemEncoded = utils.mergeUint8([
       palledEncoded,
       Twox128(textEncoder.encode(name))
-    );
+    ]);
     const palletItemEncodedHex = utils.toHex(palletItemEncoded);
     const dec = (key) => {
       if (!key.startsWith(palletItemEncodedHex))
@@ -812,7 +985,10 @@ const Storage = (pallet) => {
       ([{ enc: enc2 }, hash]) => (val) => hash(enc2(val))
     );
     const enc = (...args) => utils.toHex(
-      utils.mergeUint8(palletItemEncoded, ...args.map((val, idx) => fns[idx](val)))
+      utils.mergeUint8([
+        palletItemEncoded,
+        ...args.map((val, idx) => fns[idx](val))
+      ])
     );
     return {
       enc,
@@ -827,12 +1003,12 @@ const getMultisigAccountId = ({
   signatories
 }) => {
   const sortedSignatories = sortMultisigSignatories(signatories);
-  const payload = utils.mergeUint8(
+  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) => {
@@ -966,6 +1142,7 @@ exports.compactBn = compactBn;
 exports.compactNumber = compactNumber;
 exports.decAnyMetadata = decAnyMetadata;
 exports.ethAccount = ethAccount;
+exports.extrinsicFormat = extrinsicFormat;
 exports.fixedStr = fixedStr;
 exports.fromBufferToBase58 = fromBufferToBase58;
 exports.getMultisigAccountId = getMultisigAccountId;
@@ -975,7 +1152,9 @@ exports.metadata = metadata;
 exports.selfDecoder = selfDecoder;
 exports.selfEncoder = selfEncoder;
 exports.sortMultisigSignatories = sortMultisigSignatories;
+exports.unifyMetadata = unifyMetadata;
 exports.v14 = v14;
 exports.v14Lookup = lookup;
 exports.v15 = v15;
+exports.v16 = v16;
 //# sourceMappingURL=index.js.map