chore(papi): commit the sources behind the four polkadot-api packages (#15)

* chore(papi): commit the sources behind the four polkadot-api packages

papi-utils, bizinikiwi-bindings, metadata-builders and merkleize-metadata
held only dist/ builds, and no repository held their source. Every
source map in dist/ embeds the TypeScript it was compiled from; that is
now committed as src/ (59 files), and it matches upstream polkadot-api
(MIT) exactly once @polkadot-api/* imports are renamed:

  papi-utils           @polkadot-api/utils 0.2.0
  bizinikiwi-bindings  @polkadot-api/substrate-bindings 0.16.6
  metadata-builders    @polkadot-api/metadata-builders 0.13.0-0.13.2
  merkleize-metadata   @polkadot-api/merkleize-metadata 1.1.21-1.1.23

scripts/check-papi-sources.mjs, run in the lint job, fails unless the
source embedded in dist/ is exactly the committed src/. tsconfig.json
excludes these src/ trees; ESLint already skipped the packages. Each
README now states the upstream package and version.

* chore(papi): keep the upstream sources in upstream-src/

The pezkuwi-dev build treats any package with a src/ directory as its
own: it requires our license header on every file and builds it. These
are upstream files that must stay byte-identical to the source embedded
in dist/, so they live in upstream-src/ instead, which neither the build
nor the root tsconfig picks up.

packages/merkleize-metadata/upstream-src/codecs.ts

@@ -0,0 +1,152 @@
+import {
+  Bytes,
+  Codec,
+  CodecType,
+  Option,
+  ScaleEnum,
+  Struct,
+  Tuple,
+  V14Lookup,
+  Vector,
+  _void,
+  bool,
+  compact,
+  compactNumber,
+  extrinsicFormat,
+  str,
+  u16,
+  u32,
+  u8,
+} from "@pezkuwi/bizinikiwi-bindings"
+
+const extraInfoInner = {
+  specVersion: u32,
+  specName: str,
+  base58Prefix: u16,
+  decimals: u8,
+  tokenSymbol: str,
+}
+export const extraInfo = Struct(extraInfoInner)
+export type ExtraInfo = CodecType<typeof extraInfo>
+
+export const hash = Bytes(32)
+export const metadataDigest = ScaleEnum({
+  V0: _void,
+  V1: Struct({
+    typeInformationTreeRoot: hash,
+    extrinsicMetadataHash: hash,
+    ...extraInfoInner,
+  }),
+})
+export type MetadataDigest = CodecType<typeof metadataDigest>
+
+export const scalePrimitive = ScaleEnum({
+  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,
+})
+export type ScalePrimitive = CodecType<typeof scalePrimitive>
+
+export const typeRef = ScaleEnum({
+  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,
+  compactU8: _void,
+  compactU16: _void,
+  compactU32: _void,
+  compactU64: _void,
+  compactU128: _void,
+  compactU256: _void,
+  void: _void,
+  perId: compactNumber,
+})
+export type TypeRef = CodecType<typeof typeRef>
+
+const field = Struct({
+  name: Option(str),
+  ty: typeRef,
+  typeName: Option(str),
+})
+export const typeDef = ScaleEnum({
+  composite: Vector(field),
+  enumeration: Struct({
+    name: str,
+    fields: Vector(field),
+    index: compactNumber,
+  }),
+  sequence: typeRef,
+  array: Struct({
+    len: u32,
+    typeParam: typeRef,
+  }),
+  tuple: Vector(typeRef),
+  bitSequence: Struct({
+    numBytes: u8,
+    leastSignificantBitFirst: bool,
+  }),
+})
+export type TypeDef = CodecType<typeof typeDef>
+
+export const lookupType = Struct({
+  path: Vector(str),
+  typeDef: typeDef,
+  typeId: compactNumber,
+})
+export type LookupEntry = CodecType<typeof lookupType>
+export type Lookup = Array<LookupEntry>
+export const lookup: Codec<Lookup> = Vector(lookupType)
+
+export const extrinsicMetadata = Struct({
+  version: u8,
+  addressTy: typeRef,
+  callTy: typeRef,
+  signatureTy: typeRef,
+  signedExtensions: Vector(
+    Struct({
+      identifier: str,
+      includedInExtrinsic: typeRef,
+      includedInSignedData: typeRef,
+    }),
+  ),
+})
+export type ExtrinsicMetadata = CodecType<typeof extrinsicMetadata>
+export type LookupValue = V14Lookup[number]
+
+export const extrinsicDec = Tuple.dec(
+  compact[1],
+  extrinsicFormat[1],
+  Bytes(Infinity)[1],
+)
+
+export const proof = Struct({
+  leaves: lookup,
+  leafIdxs: Vector(u32),
+  proofs: Vector(hash),
+  extrinsic: extrinsicMetadata,
+  info: extraInfo,
+})
+export type Proof = CodecType<typeof proof>