@polkadot-api/merkleize-metadata 1.0.0

package/dist/min/index.js

@@ -0,0 +1,2 @@
+"use strict";var L=Object.defineProperty;var Q=Object.getOwnPropertyDescriptor;var X=Object.getOwnPropertyNames;var Y=Object.prototype.hasOwnProperty;var Z=(t,a)=>{for(var s in a)L(t,s,{get:a[s],enumerable:!0})},ee=(t,a,s,p)=>{if(a&&typeof a=="object"||typeof a=="function")for(let o of X(a))!Y.call(t,o)&&o!==s&&L(t,o,{get:()=>a[o],enumerable:!(p=Q(a,o))||p.enumerable});return t};var te=t=>ee(L({},"__esModule",{value:!0}),t);var le={};Z(le,{extraInfo:()=>I,extrinsicMetadata:()=>U,hash:()=>A,lookup:()=>M,lookupType:()=>k,merkleizeMetadata:()=>de,proof:()=>O});module.exports=te(le);var h=require("@polkadot-api/substrate-bindings");var e=require("@polkadot-api/substrate-bindings"),B={specVersion:e.u32,specName:e.str,base58Prefix:e.u16,decimals:e.u8,tokenSymbol:e.str},I=(0,e.Struct)(B),A=(0,e.Bytes)(32),F=(0,e.ScaleEnum)({V0:e._void,V1:(0,e.Struct)({typeInformationTreeRoot:A,extrinsicMetadataHash:A,...B})}),ve=(0,e.ScaleEnum)({bool:e._void,char:e._void,str:e._void,u8:e._void,u16:e._void,u32:e._void,u64:e._void,u128:e._void,u256:e._void,i8:e._void,i16:e._void,i32:e._void,i64:e._void,i128:e._void,i256:e._void}),T=(0,e.ScaleEnum)({bool:e._void,char:e._void,str:e._void,u8:e._void,u16:e._void,u32:e._void,u64:e._void,u128:e._void,u256:e._void,i8:e._void,i16:e._void,i32:e._void,i64:e._void,i128:e._void,i256:e._void,compactU8:e._void,compactU16:e._void,compactU32:e._void,compactU64:e._void,compactU128:e._void,compactU256:e._void,void:e._void,perId:e.compactNumber}),C=(0,e.Struct)({name:(0,e.Option)(e.str),ty:T,typeName:(0,e.Option)(e.str)}),re=(0,e.ScaleEnum)({composite:(0,e.Vector)(C),enumeration:(0,e.Struct)({name:e.str,fields:(0,e.Vector)(C),index:e.compactNumber}),sequence:T,array:(0,e.Struct)({len:e.u32,typeParam:T}),tuple:(0,e.Vector)(T),bitSequence:(0,e.Struct)({numBytes:e.u8,leastSignificantBitFirst:e.bool})}),k=(0,e.Struct)({path:(0,e.Vector)(e.str),typeDef:re,typeId:e.compactNumber}),M=(0,e.Vector)(k),U=(0,e.Struct)({version:e.u8,addressTy:T,callTy:T,signatureTy:T,signedExtensions:(0,e.Vector)((0,e.Struct)({identifier:e.str,includedInExtrinsic:T,includedInSignedData:T}))}),ne=(0,e.enhanceDecoder)(e.u8[1],t=>({version:t&-129,signed:!!(t&128)})),N=e.Tuple.dec(e.compact[1],ne,(0,e.Bytes)(1/0)[1]),O=(0,e.Struct)({leaves:M,leafIdxs:(0,e.Vector)(e.u32),proofs:(0,e.Vector)(A),extrinsic:U,info:I});var _=(t,a)=>{let s=new Set,p=r=>{if(s.has(r))return;let{tag:n,value:i}=a.get(r).def;switch(n){case"composite":if(!i.length)break;s.add(r),i.forEach(({type:u})=>{p(u)});break;case"variant":if(!i.length)break;s.add(r),i.forEach(({fields:u})=>{u.forEach(({type:l})=>{p(l)})});break;case"tuple":if(!i.length)break;s.add(r),i.forEach(p);break;case"sequence":s.add(r),p(i);break;case"array":s.add(r),p(i.type);break;case"bitSequence":s.add(r)}};p(t.extrinsic.call),p(t.extrinsic.address),p(t.extrinsic.signature),t.extrinsic.signedExtensions.forEach(({type:r,additionalSigned:n})=>{p(r),p(n)});let o=[...s].sort((r,n)=>r-n);return new Map(o.map((r,n)=>[r,n]))};var oe={u8:1,u16:2,u32:4,u64:8},ae=(t,a,s,p)=>{let{def:{tag:o,value:r}}=t.get(p);switch(o){case"composite":return[{tag:o,value:r.map(n=>({name:n.name,typeName:n.typeName,ty:a(n.type)}))}];case"variant":return r.map(n=>({tag:"enumeration",value:{name:n.name,index:n.index,fields:n.fields.map(i=>({name:i.name,typeName:i.typeName,ty:a(i.type)}))}}));case"sequence":return[{tag:o,value:a(r)}];case"array":return[{tag:o,value:{len:r.len,typeParam:a(r.type)}}];case"tuple":return[{tag:o,value:r.map(a)}];case"bitSequence":{let n=s(r.bitStoreType),i=oe[n];if(!i)throw new Error("Invalid primitive for BitSequence");let u=t.get(r.bitOrderType).path,l=u.includes("Lsb0");if(!l&&!u.includes("Msb0"))throw new Error("BitOrderType not recognized");return[{tag:"bitSequence",value:{numBytes:i,leastSignificantBitFirst:l}}]}}throw new Error(`FrameId(${p}) should have been filtered out`)},z=(t,a,s,p)=>{let o=[];return[...a.entries()].forEach(([r,n])=>{let{path:i}=t.get(r);ae(t,s,p,r).forEach(u=>{o.push({path:i,typeId:n,typeDef:u})})}),o.sort((r,n)=>{if(r.typeId!==n.typeId)return r.typeId-n.typeId;if(r.typeDef.tag!=="enumeration"||n.typeDef.tag!=="enumeration")throw new Error("Found two types with same id");return r.typeDef.value.index-n.typeDef.value.index}),o};var x=require("@polkadot-api/substrate-bindings"),P=(0,x.Bytes)(),ie=(0,x.Option)(P),ce=(0,x.Tuple)(x.compact,P),se=t=>{try{return x.metadata.dec(t)}catch{}try{return x.metadata.dec(ie.dec(t))}catch{}try{return x.metadata.dec(P.dec(t))}catch{}try{return x.metadata.dec(ce.dec(t)[1])}catch{}throw null},K=t=>{try{let{metadata:a}=se(t);if(a.tag!=="v15")throw new Error("Wrong metadata version");return a.value}catch(a){throw a||new Error("Unable to decode metadata")}};var W=require("@polkadot-api/utils"),D=t=>{let a=t.length,s=0;for(let o=0;o<a;o++)s+=t[o].byteLength;let p=new Uint8Array(s);for(let o=0,r=0;o<a;o++){let n=t[o];p.set(n,r),r+=n.byteLength}return p},H=t=>typeof t=="string"?(0,W.fromHex)(t):t,$={null:"void",u8:"compactU8",u16:"compactU16",u32:"compactU32",u64:"compactU64",u128:"compactU128",u256:"compactU256"};var c=require("@polkadot-api/substrate-bindings"),pe={bool:c.u8,char:c.u8,str:c.str,u8:c.u8,u16:c.u16,u32:c.u32,u64:c.u64,u128:c.u128,u256:c.u256,i8:c.i8,i16:c.i16,i32:c.i32,i64:c.i64,i128:c.i128,i256:c.i256,void:c._void,compactU8:c.compact,compactU16:c.compact,compactU32:c.compact,compactU64:c.compact,compactU128:c.compact,compactU256:c.compact},j=(t,a,s,p,o)=>{if(a.tag!=="perId"){pe[a.tag][1](t);return}let r=l=>{j(t,l,s,p,o)},n=s.get(a.value),[i]=n,u=p[i];switch(n.length===1&&o.add(i),u.typeDef.tag){case"enumeration":{let l=c.u8.dec(t),[y,E]=n.map(f=>[p[f].typeDef,f]).find(([f])=>f.value.index===l);o.add(E),y.value.fields.forEach(({ty:f})=>{r(f)});break}case"sequence":{let l=c.compact.dec(t);for(let y=0;y<l;y++)r(u.typeDef.value);break}case"array":{for(let l=0;l<u.typeDef.value.len;l++)r(u.typeDef.value.typeParam);break}case"composite":{u.typeDef.value.forEach(l=>{r(l.ty)});break}case"tuple":{u.typeDef.value.forEach(r);break}case"bitSequence":throw new Error("bitSequence is not supported")}},V=(t,a,s)=>{let p=new Uint8Array;(0,c.createDecoder)(n=>{p=n})(t);let o=new Map;s.forEach((n,i)=>{let u=o.get(n.typeId);u?u.push(i):o.set(n.typeId,[i])});let r=new Set;return a.forEach(n=>{j(p,n,o,s,r)}),[...r].sort((n,i)=>n-i)};var R=t=>Math.log2(t+1)|0,ue=(t,a)=>(t+1>>a)-1;function G(t,a){let s=a.map(u=>t[u]),p=t.length-1,o=a.map(u=>p+u),r=[];if(o.length){let u=R(o.at(-1)),l=Math.pow(2,u)-1,y=o.findIndex(E=>E>=l);y>0&&(o.unshift(...o.splice(y)),s.unshift(...s.splice(y)))}let n=0,i=u=>{if(n===o.length){r.push(u);return}let l=o[n];if(l===u){++n;return}let y=R(u),E=R(l);if(u!==ue(l,E-y)){r.push(u);return}let f=2*u+1;i(f),i(f+1)};return i(0),{leaves:s,leafIdxs:o,proofIdxs:r}}var de=(t,a)=>{let s=K(t),p=new Map(s.lookup.map(m=>[m.id,m])),o=_(s,p),r=m=>{let{def:{tag:d,value:g}}=p.get(m);if(d==="primitive")return g.tag;if(d!=="composite"&&d!=="tuple"||g.length>1)throw new Error("The provided definition doesn't map to a primitive");return g.length===0?null:r(d==="tuple"?g[0]:g[0].type)},n=m=>{let{def:d}=p.get(m);if(d.tag==="primitive")return{tag:d.value.tag,value:void 0};if(d.tag==="compact"){let g=r(d.value),v=$[g];if(!v)throw new Error("Invalid primitive for Compact");return{tag:v,value:void 0}}return o.has(m)?{tag:"perId",value:o.get(m)}:{tag:"void",value:void 0}},i={version:s.extrinsic.version,addressTy:n(s.extrinsic.address),callTy:n(s.extrinsic.call),signatureTy:n(s.extrinsic.signature),signedExtensions:s.extrinsic.signedExtensions.map(m=>({identifier:m.identifier,includedInExtrinsic:n(m.type),includedInSignedData:n(m.additionalSigned)}))},u=z(p,o,n,r),l=u.map(k.enc),y,E=()=>{if(y)return y;if(!l.length)return y=[new Uint8Array(32).fill(0)];y=new Array(l.length*2-1);let m=l.length-1;for(let d=0;d<l.length;d++)y[m+d]=(0,h.Blake3256)(l[d]);for(let d=y.length-2;d>0;d-=2)y[(d-1)/2]=(0,h.Blake3256)(D([y[d],y[d+1]]));return y},f,J=()=>{if(f)return f;let d={tag:"V1",value:{typeInformationTreeRoot:E()[0],extrinsicMetadataHash:(0,h.Blake3256)(U.enc(i)),...a}};return f=(0,h.Blake3256)(F.enc(d))},q=m=>{let d=G(l,m),g=E(),v=d.proofIdxs.map(b=>g[b]);return D([h.compact.enc(d.leaves.length),...d.leaves,h.compact.enc(d.leafIdxs.length),...d.leafIdxs.map(b=>h.u32.enc(b)),h.compact.enc(v.length),...v,U.enc(i),I.enc(a)])};return{digest:J,getProofForExtrinsic:(m,d)=>{let[,{version:g,signed:v},b]=N(m);if(g!==i.version)throw new Error("Incorrect extrinsic version");let S=v?[i.addressTy,i.signatureTy,...i.signedExtensions.map(w=>w.includedInExtrinsic),i.callTy]:[i.callTy];return d&&(b=D([b,H(d)]),S.push(...i.signedExtensions.map(w=>w.includedInSignedData))),q(V(b,S,u))},getProofForExtrinsicParts:(m,d,g)=>{let v=D([m,d,g].map(H)),b=[i.callTy,...i.signedExtensions.map(S=>S.includedInExtrinsic),...i.signedExtensions.map(S=>S.includedInSignedData)];return q(V(v,b,u))}}};
+//# sourceMappingURL=index.js.map

package/dist/min/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/index.ts","../../src/main.ts","../../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"],"sourcesContent":["export * from \"./main\"\nexport {\n  proof,\n  Proof,\n  lookup,\n  Lookup,\n  lookupType,\n  LookupEntry,\n  hash,\n  extrinsicMetadata,\n  ExtrinsicMetadata,\n  TypeRef,\n  extraInfo,\n  ExtraInfo,\n} from \"./codecs\"\n","import {\n  Blake3256,\n  HexString,\n  compact,\n  u32,\n} from \"@polkadot-api/substrate-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, mergeUint8, toBytes } from \"./utils\"\nimport { decodeAndCollectKnownLeafs } from \"./decode-and-collect\"\nimport { getProofData } from \"./proof\"\n\nexport interface MetadataMerkleizer {\n  // it returns the digest value of the metadata (aka its merkleized root-hash)\n  digest: () => Uint8Array\n\n  // given an extrinsic, it returns an encoded `Proof`\n  getProofForExtrinsic: (\n    transaction: Uint8Array | HexString,\n    txAdditionalSigned?: Uint8Array | HexString,\n  ) => Uint8Array\n\n  // given the extrinsic parts, it returns an encoded `Proof`\n  getProofForExtrinsicParts: (\n    callData: Uint8Array | HexString,\n    includedInExtrinsic: Uint8Array | HexString,\n    includedInSignedData: Uint8Array | HexString,\n  ) => Uint8Array\n}\n\nexport const merkleizeMetadata = (\n  metadataBytes: Uint8Array | HexString,\n  info: ExtraInfo,\n): MetadataMerkleizer => {\n  const metadata = getMetadata(metadataBytes)\n\n  const definitions = new Map<number, LookupValue>(\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: metadata.extrinsic.version,\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<Uint8Array> | undefined\n  const getHashTree = (): Array<Uint8Array> => {\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 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    const typeRefs: Array<TypeRef> = [\n      extrinsic.callTy,\n      ...extrinsic.signedExtensions.map((x) => x.includedInExtrinsic),\n      ...extrinsic.signedExtensions.map((x) => x.includedInSignedData),\n    ]\n    return generateProof(decodeAndCollectKnownLeafs(bytes, typeRefs, lookup))\n  }\n\n  const getProofForExtrinsic = (\n    transaction: Uint8Array | HexString,\n    txAdditionalSigned?: Uint8Array | HexString,\n  ) => {\n    let [, { version, signed }, bytes] = extrinsicDec(transaction)\n\n    if (version !== extrinsic.version)\n      throw new Error(\"Incorrect extrinsic version\")\n\n    const typeRefs: TypeRef[] = 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  }\n}\n","import {\n  Bytes,\n  Codec,\n  CodecType,\n  Option,\n  ScaleEnum,\n  Struct,\n  Tuple,\n  V15,\n  Vector,\n  _void,\n  bool,\n  compact,\n  compactNumber,\n  enhanceDecoder,\n  str,\n  u16,\n  u32,\n  u8,\n} from \"@polkadot-api/substrate-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<typeof extraInfo>\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<typeof metadataDigest>\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<typeof scalePrimitive>\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<typeof typeRef>\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<typeof typeDef>\n\nexport const lookupType = Struct({\n  path: Vector(str),\n  typeDef: typeDef,\n  typeId: compactNumber,\n})\nexport type LookupEntry = CodecType<typeof lookupType>\nexport type Lookup = Array<LookupEntry>\nexport const lookup: Codec<Lookup> = 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<typeof extrinsicMetadata>\nexport type LookupValue = V15[\"lookup\"] extends Array<infer T> ? T : never\n\nconst versionDecoder = enhanceDecoder(u8[1], (value) => ({\n  version: value & ~(1 << 7),\n  signed: !!(value & (1 << 7)),\n}))\n\nexport const extrinsicDec = Tuple.dec(\n  compact[1],\n  versionDecoder,\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<typeof proof>\n","import { V15 } from \"@polkadot-api/substrate-bindings\"\nimport { LookupValue } from \"./codecs\"\n\nexport const getAccessibleTypes = (\n  metadata: V15,\n  definitions: Map<number, LookupValue>,\n): Map<number, number> => {\n  const types = new Set<number>()\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<number, LookupValue>,\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<number, LookupValue>,\n  accessibleTypes: Map<number, number>,\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  Option,\n  Bytes,\n  metadata,\n  compact,\n  Tuple,\n  V15,\n} from \"@polkadot-api/substrate-bindings\"\nimport { HexString } from \"@polkadot-api/substrate-bindings\"\n\nconst opaqueBytes = Bytes()\nconst optionOpaque = Option(opaqueBytes)\nconst opaqueOpaqueBytes = Tuple(compact, opaqueBytes)\n\nconst getAnyMetadata = (input: Uint8Array | HexString) => {\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\nexport const getMetadata = (input: Uint8Array | HexString): V15 => {\n  try {\n    const { metadata } = getAnyMetadata(input)\n    if (metadata.tag !== \"v15\") throw new Error(\"Wrong metadata version\")\n    return metadata.value\n  } catch (e) {\n    throw e || new Error(\"Unable to decode metadata\")\n  }\n}\n","import { type HexString } from \"@polkadot-api/substrate-bindings\"\nimport { fromHex } from \"@polkadot-api/utils\"\n\nexport const mergeUint8 = (inputs: Array<Uint8Array>): Uint8Array => {\n  const len = inputs.length\n  let totalLen = 0\n  for (let i = 0; i < len; i++) totalLen += inputs[i].byteLength\n  const result = new Uint8Array(totalLen)\n\n  for (let idx = 0, at = 0; idx < len; idx++) {\n    const current = inputs[idx]\n    result.set(current, at)\n    at += current.byteLength\n  }\n\n  return result\n}\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 \"@polkadot-api/substrate-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<number, Array<number>>,\n  lookup: Lookup,\n  collected: Set<number>,\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<TypeRef>,\n  lookup: Lookup,\n): Array<number> => {\n  let input = new Uint8Array()\n  createDecoder((_input) => {\n    input = _input\n  })(data)\n\n  const idToLookups = new Map<number, number[]>()\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<number>()\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<Uint8Array>,\n  knownLeavesIdxs: Array<number>,\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<number> = []\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"],"mappings":"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","names":["src_exports","__export","extraInfo","extrinsicMetadata","hash","lookup","lookupType","merkleizeMetadata","proof","__toCommonJS","import_substrate_bindings","import_substrate_bindings","extraInfoInner","extraInfo","hash","metadataDigest","scalePrimitive","typeRef","field","typeDef","lookupType","lookup","extrinsicMetadata","versionDecoder","value","extrinsicDec","proof","getAccessibleTypes","metadata","definitions","types","collectTypesFromId","id","tag","value","type","fields","additionalSigned","sortedTypes","a","b","idx","bitSequenceBytes","constructTypeDef","definitions","getTypeRef","getPrimitive","frameId","tag","value","f","v","primitive","numBytes","storeOrderPath","leastSignificantBitFirst","getLookup","accessibleTypes","typeTree","typeId","path","typeDef","a","b","import_substrate_bindings","opaqueBytes","optionOpaque","opaqueOpaqueBytes","getAnyMetadata","input","getMetadata","metadata","e","import_utils","mergeUint8","inputs","len","totalLen","i","result","idx","at","current","toBytes","input","compactTypeRefs","import_substrate_bindings","typeRefDecoders","innerDecodeAndCollect","input","typeRef","idToLookups","lookup","collected","handleTypeRef","lookupIdxs","currentIdx","current","selectedIdx","selected","collectedIdx","lookupIdx","x","ty","len","i","decodeAndCollectKnownLeafs","data","typeRefs","_input","idx","arr","result","a","b","getLevelFromIdx","idx","getAncestorIdx","from","nLevels","getProofData","leaves","knownLeavesIdxs","knownLeaves","startingIdx","leafIdxs","proofIdxs","splitPosition","splitIdx","x","targetIdx","traverse","nodeIdx","target","currentLevel","targetLevel","leftSon","merkleizeMetadata","metadataBytes","info","metadata","getMetadata","definitions","value","accessibleTypes","getAccessibleTypes","getPrimitive","frameId","tag","getTypeRef","def","primitive","compactTypeRefs","extrinsic","se","lookup","getLookup","lookupEncoded","lookupType","hashTree","getHashTree","leavesStartIdx","i","mergeUint8","digested","digest","extrinsicMetadata","metadataDigest","generateProof","knownIndexes","proofData","getProofData","proofs","idx","x","extraInfo","transaction","txAdditionalSigned","version","signed","bytes","extrinsicDec","typeRefs","toBytes","decodeAndCollectKnownLeafs","callData","includedInExtrinsic","includedInSignedData"]}

package/package.json

@@ -0,0 +1,47 @@
+{
+  "name": "@polkadot-api/merkleize-metadata",
+  "version": "1.0.0",
+  "author": "Carlo Sala (https://github.com/carlosala)",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/polkadot-api/polkadot-api.git"
+  },
+  "license": "MIT",
+  "sideEffects": false,
+  "exports": {
+    ".": {
+      "node": {
+        "production": {
+          "import": "./dist/index.mjs",
+          "require": "./dist/min/index.js",
+          "default": "./dist/index.js"
+        },
+        "import": "./dist/index.mjs",
+        "require": "./dist/index.js",
+        "default": "./dist/index.js"
+      },
+      "module": "./dist/index.mjs",
+      "import": "./dist/index.mjs",
+      "require": "./dist/index.js",
+      "default": "./dist/index.js"
+    },
+    "./package.json": "./package.json"
+  },
+  "main": "./dist/index.js",
+  "module": "./dist/index.mjs",
+  "browser": "./dist/index.mjs",
+  "types": "./dist/index.d.ts",
+  "files": [
+    "dist"
+  ],
+  "dependencies": {
+    "@polkadot-api/substrate-bindings": "0.5.0",
+    "@polkadot-api/utils": "0.1.0"
+  },
+  "scripts": {
+    "build": "tsc --noEmit && tsup-node src/index.ts --clean --sourcemap --platform neutral --target=es2020 --format esm,cjs --dts && tsup-node src/index.ts --clean --sourcemap --platform neutral --target=es2020 --format cjs --dts --minify --out-dir dist/min",
+    "test": "vitest",
+    "lint": "prettier --check README.md \"src/**/*.{js,jsx,ts,tsx,json,md}\"",
+    "format": "prettier --write README.md \"src/**/*.{js,jsx,ts,tsx,json,md}\""
+  }
+}