@pezkuwi/types 16.5.8 → 16.5.9

package/build-deno/extrinsic/ExtrinsicEra.ts

@@ -1,296 +0,0 @@
-
-import type { AnyU8a, Registry } from 'https://deno.land/x/pezkuwi/types-codec/types/index.ts';
-import type { BN } from 'https://deno.land/x/pezkuwi/util/mod.ts';
-import type { IExtrinsicEra, INumber } from '../types/index.ts';
-
-import { Enum, Raw, Tuple, U64 } from 'https://deno.land/x/pezkuwi/types-codec/mod.ts';
-import { bnToBn, formatNumber, hexToU8a, isHex, isObject, isU8a, u8aToBn, u8aToU8a } from 'https://deno.land/x/pezkuwi/util/mod.ts';
-
-import { IMMORTAL_ERA } from './constants.ts';
-
-type MortalEraValue = [INumber, INumber];
-
-interface MortalMethod {
-  current: number;
-  period: number;
-}
-
-interface MortalEnumDef {
-  MortalEra: string;
-}
-
-interface ImmortalEnumDef {
-  ImmortalEra: string;
-}
-
-function getTrailingZeros (period: number): number {
-  const binary = period.toString(2);
-  let index = 0;
-
-  while (binary[binary.length - 1 - index] === '0') {
-    index++;
-  }
-
-  return index;
-}
-
-/** @internal */
-function decodeMortalEra (registry: Registry, value?: MortalMethod | Uint8Array | number[] | string): MortalEraValue {
-  if (isU8a(value) || isHex(value) || Array.isArray(value)) {
-    return decodeMortalU8a(registry, u8aToU8a(value));
-  } else if (!value) {
-    return [new U64(registry), new U64(registry)];
-  } else if (isObject(value)) {
-    return decodeMortalObject(registry, value);
-  }
-
-  throw new Error('Invalid data passed to Mortal era');
-}
-
-/** @internal */
-function decodeMortalObject (registry: Registry, value: MortalMethod): MortalEraValue {
-  const { current, period } = value;
-  let calPeriod = Math.pow(2, Math.ceil(Math.log2(period)));
-
-  calPeriod = Math.min(Math.max(calPeriod, 4), 1 << 16);
-
-  const phase = current % calPeriod;
-  const quantizeFactor = Math.max(calPeriod >> 12, 1);
-  const quantizedPhase = phase / quantizeFactor * quantizeFactor;
-
-  return [new U64(registry, calPeriod), new U64(registry, quantizedPhase)];
-}
-
-/** @internal */
-function decodeMortalU8a (registry: Registry, value: Uint8Array): MortalEraValue {
-  if (value.length === 0) {
-    return [new U64(registry), new U64(registry)];
-  }
-
-  const first = u8aToBn(value.subarray(0, 1)).toNumber();
-  const second = u8aToBn(value.subarray(1, 2)).toNumber();
-  const encoded: number = first + (second << 8);
-  const period = 2 << (encoded % (1 << 4));
-  const quantizeFactor = Math.max(period >> 12, 1);
-  const phase = (encoded >> 4) * quantizeFactor;
-
-  if (period < 4 || phase >= period) {
-    throw new Error('Invalid data passed to Mortal era');
-  }
-
-  return [new U64(registry, period), new U64(registry, phase)];
-}
-
-/** @internal */
-function decodeExtrinsicEra (value: IExtrinsicEra | MortalMethod | MortalEnumDef | ImmortalEnumDef | Uint8Array | string = new Uint8Array()): Uint8Array | Object | undefined {
-  if (isU8a(value)) {
-    return (!value.length || value[0] === 0)
-      ? new Uint8Array([0])
-      : new Uint8Array([1, value[0], value[1]]);
-  } else if (!value) {
-    return new Uint8Array([0]);
-  } else if (value instanceof GenericExtrinsicEra) {
-    return decodeExtrinsicEra(value.toU8a());
-  } else if (isHex(value)) {
-    return decodeExtrinsicEra(hexToU8a(value));
-  } else if (isObject(value)) {
-    const entries = Object.entries(value as MortalEnumDef).map(([k, v]): [string, any] => [k.toLowerCase(), v]);
-    const mortal = entries.find(([k]) => k.toLowerCase() === 'mortalera');
-    const immortal = entries.find(([k]) => k.toLowerCase() === 'immortalera');
-
-    // this is to de-serialize from JSON
-    return mortal
-      ? { MortalEra: mortal[1] as string }
-      : immortal
-        ? { ImmortalEra: immortal[1] as string }
-        : { MortalEra: value };
-  }
-
-  throw new Error('Invalid data passed to Era');
-}
-
-/**
- * @name ImmortalEra
- * @description
- * The ImmortalEra for an extrinsic
- */
-export class ImmortalEra extends Raw {
-  constructor (registry: Registry, _value?: AnyU8a) {
-    // For immortals, we always provide the known value (i.e. treated as a
-    // constant no matter how it is constructed - it is a fixed structure)
-    super(registry, IMMORTAL_ERA);
-  }
-}
-
-/**
- * @name MortalEra
- * @description
- * The MortalEra for an extrinsic, indicating period and phase
- */
-export class MortalEra extends Tuple {
-  constructor (registry: Registry, value?: MortalMethod | Uint8Array | number[] | string) {
-    super(registry, {
-      period: U64,
-      phase: U64
-    }, decodeMortalEra(registry, value));
-  }
-
-  /**
-   * @description Encoded length for mortals occupy 2 bytes, different from the actual Tuple since it is encoded. This is a shortcut fro `toU8a().length`
-   */
-  public override get encodedLength (): number {
-    return 2 | 0;
-  }
-
-  /**
-   * @description The period of this Mortal wraps as a [[U64]]
-   */
-  public get period (): INumber {
-    return this[0] as INumber;
-  }
-
-  /**
-   * @description The phase of this Mortal wraps as a [[U64]]
-   */
-  public get phase (): INumber {
-    return this[1] as INumber;
-  }
-
-  /**
-   * @description Converts the Object to to a human-friendly JSON, with additional fields, expansion and formatting of information
-   */
-  public override toHuman (): any {
-    return {
-      period: formatNumber(this.period),
-      phase: formatNumber(this.phase)
-    };
-  }
-
-  /**
-   * @description Returns a JSON representation of the actual value
-   */
-  public override toJSON (): any {
-    return this.toHex();
-  }
-
-  /**
-   * @description Encodes the value as a Uint8Array as per the parity-codec specifications
-   * @param isBare true when the value has none of the type-specific prefixes (internal)
-   * Period and phase are encoded:
-   *   - The period of validity from the block hash found in the signing material.
-   *   - The phase in the period that this transaction's lifetime begins (and, importantly,
-   *     implies which block hash is included in the signature material). If the `period` is
-   *     greater than 1 << 12, then it will be a factor of the times greater than 1<<12 that
-   *     `period` is.
-   */
-  public override toU8a (_isBare?: boolean): Uint8Array {
-    const period = this.period.toNumber();
-    const encoded = Math.min(
-      15,
-      Math.max(1, getTrailingZeros(period) - 1)
-    ) + (
-      (
-        this.phase.toNumber() / Math.max(period >> 12, 1)
-      ) << 4
-    );
-
-    return new Uint8Array([
-      encoded & 0xff,
-      encoded >> 8
-    ]);
-  }
-
-  /**
-   * @description Get the block number of the start of the era whose properties this object describes that `current` belongs to.
-   */
-  public birth (current: BN | bigint | number | string): number {
-    const phase = this.phase.toNumber();
-    const period = this.period.toNumber();
-
-    // FIXME No toNumber() here
-    return (
-      ~~(
-        (
-          Math.max(bnToBn(current).toNumber(), phase) - phase
-        ) / period
-      ) * period
-    ) + phase;
-  }
-
-  /**
-   * @description Get the block number of the first block at which the era has ended.
-   */
-  public death (current: BN | bigint | number | string): number {
-    // FIXME No toNumber() here
-    return this.birth(current) + this.period.toNumber();
-  }
-}
-
-/**
- * @name GenericExtrinsicEra
- * @description
- * The era for an extrinsic, indicating either a mortal or immortal extrinsic
- */
-export class GenericExtrinsicEra extends Enum implements IExtrinsicEra {
-  constructor (registry: Registry, value?: unknown) {
-    super(registry, {
-      ImmortalEra,
-      MortalEra
-    }, decodeExtrinsicEra(value as string));
-  }
-
-  /**
-   * @description Override the encoded length method
-   */
-  public override get encodedLength (): number {
-    return this.isImmortalEra
-      ? this.asImmortalEra.encodedLength
-      : this.asMortalEra.encodedLength;
-  }
-
-  /**
-   * @description Returns the item as a [[ImmortalEra]]
-   */
-  public get asImmortalEra (): ImmortalEra {
-    if (!this.isImmortalEra) {
-      throw new Error(`Cannot convert '${this.type}' via asImmortalEra`);
-    }
-
-    return this.inner as ImmortalEra;
-  }
-
-  /**
-   * @description Returns the item as a [[MortalEra]]
-   */
-  public get asMortalEra (): MortalEra {
-    if (!this.isMortalEra) {
-      throw new Error(`Cannot convert '${this.type}' via asMortalEra`);
-    }
-
-    return this.inner as MortalEra;
-  }
-
-  /**
-   * @description `true` if Immortal
-   */
-  public get isImmortalEra (): boolean {
-    return this.index === 0;
-  }
-
-  /**
-   * @description `true` if Mortal
-   */
-  public get isMortalEra (): boolean {
-    return this.index > 0;
-  }
-
-  /**
-   * @description Encodes the value as a Uint8Array as per the parity-codec specifications
-   * @param isBare true when the value has none of the type-specific prefixes (internal)
-   */
-  public override toU8a (isBare?: boolean): Uint8Array {
-    return this.isMortalEra
-      ? this.asMortalEra.toU8a(isBare)
-      : this.asImmortalEra.toU8a(isBare);
-  }
-}

package/build-deno/extrinsic/ExtrinsicPayload.ts

@@ -1,220 +0,0 @@
-
-import type { Bytes } from 'https://deno.land/x/pezkuwi/types-codec/mod.ts';
-import type { AnyJson, BareOpts, Registry } from 'https://deno.land/x/pezkuwi/types-codec/types/index.ts';
-import type { HexString } from 'https://deno.land/x/pezkuwi/util/types.ts';
-import type { BlockHash } from '../interfaces/chain/index.ts';
-import type { ExtrinsicPayloadV5 } from '../interfaces/extrinsics/index.ts';
-import type { Hash, MultiLocation } from '../interfaces/types.ts';
-import type { ExtrinsicPayloadValue, ICompact, IKeyringPair, INumber, IOption } from '../types/index.ts';
-import type { GenericExtrinsicEra } from './ExtrinsicEra.ts';
-import type { Preamble } from './types.ts';
-
-import { AbstractBase } from 'https://deno.land/x/pezkuwi/types-codec/mod.ts';
-import { hexToU8a, isHex, u8aToHex } from 'https://deno.land/x/pezkuwi/util/mod.ts';
-
-import { DEFAULT_PREAMBLE, LATEST_EXTRINSIC_VERSION } from './constants.ts';
-
-interface ExtrinsicPayloadOptions {
-  version?: number;
-  preamble?: Preamble;
-}
-
-type ExtrinsicPayloadVx = ExtrinsicPayloadV5;
-
-const VERSIONS = [
-  'ExtrinsicPayloadUnknown', // v0 is unknown
-  'ExtrinsicPayloadUnknown',
-  'ExtrinsicPayloadUnknown',
-  'ExtrinsicPayloadUnknown',
-  'ExtrinsicPayloadV4',
-  'ExtrinsicPayloadV5'
-];
-
-const PREAMBLES = {
-  bare: 'ExtrinsicPayloadV5',
-  // Not supported yet
-  general: 'ExtrinsicPayloadV5'
-};
-
-/**
- * HACK: In order to change the assetId from `number | object` to HexString (While maintaining the true type ie Option<TAssetConversion>),
- * to allow for easier generalization of the SignerPayloadJSON interface the below check is necessary. The ExtrinsicPayloadV4 class does not like
- * a value passed in as an Option, and can't decode it properly. Therefore, we ensure to convert the following below, and then pass the option as a unwrapped
- * JSON value.
- *
- * ref: https://github.com/pezkuwichain/pezkuwi-api/pull/5968
- * ref: https://github.com/pezkuwichain/pezkuwi-api/pull/5967
- */
-export function decodeAssetId (registry: Registry, payload?: ExtrinsicPayloadValue | Uint8Array | HexString) {
-  const maybeAsset = (payload as ExtrinsicPayloadValue)?.assetId;
-
-  if (maybeAsset && isHex(maybeAsset)) {
-    const assetId = registry.createType('TAssetConversion', hexToU8a(maybeAsset));
-
-    // we only want to adjust the payload if the hex passed has the option
-    if (maybeAsset === '0x00' || maybeAsset === '0x01' + assetId.toHex().slice(2)) {
-      return {
-        ...(payload as ExtrinsicPayloadValue),
-        assetId: assetId.toJSON()
-      };
-    }
-  }
-
-  return payload;
-}
-
-/** @internal */
-function decodeExtrinsicPayload (registry: Registry, value?: GenericExtrinsicPayload | ExtrinsicPayloadValue | Uint8Array | string, version = LATEST_EXTRINSIC_VERSION, preamble: Preamble = DEFAULT_PREAMBLE): ExtrinsicPayloadVx {
-  if (value instanceof GenericExtrinsicPayload) {
-    return value.unwrap();
-  }
-
-  const extVersion = version === 5 ? PREAMBLES[preamble] : VERSIONS[version] || VERSIONS[0];
-  const payload = decodeAssetId(registry, value as ExtrinsicPayloadValue);
-
-  return registry.createTypeUnsafe(extVersion, [payload, { version }]);
-}
-
-/**
- * @name GenericExtrinsicPayload
- * @description
- * A signing payload for an [[Extrinsic]]. For the final encoding, it is variable length based
- * on the contents included
- */
-export class GenericExtrinsicPayload extends AbstractBase<ExtrinsicPayloadVx> {
-  constructor (registry: Registry, value?: Partial<ExtrinsicPayloadValue> | Uint8Array | string, { preamble, version }: ExtrinsicPayloadOptions = {}) {
-    super(registry, decodeExtrinsicPayload(registry, value as ExtrinsicPayloadValue, version, preamble));
-  }
-
-  /**
-   * @description The block [[BlockHash]] the signature applies to (mortal/immortal)
-   */
-  public get blockHash (): BlockHash {
-    return this.inner.blockHash;
-  }
-
-  /**
-   * @description The [[ExtrinsicEra]]
-   */
-  public get era (): GenericExtrinsicEra {
-    return this.inner.era;
-  }
-
-  /**
-   * @description The genesis block [[BlockHash]] the signature applies to
-   */
-  public get genesisHash (): BlockHash {
-    // NOTE only v3+
-    return this.inner.genesisHash || this.registry.createTypeUnsafe('Hash', []);
-  }
-
-  /**
-   * @description The [[Bytes]] contained in the payload
-   */
-  public get method (): Bytes {
-    return this.inner.method;
-  }
-
-  /**
-   * @description The [[Index]]
-   */
-  public get nonce (): ICompact<INumber> {
-    return this.inner.nonce;
-  }
-
-  /**
-   * @description The specVersion as a [[u32]] for this payload
-   */
-  public get specVersion (): INumber {
-    // NOTE only v3+
-    return this.inner.specVersion || this.registry.createTypeUnsafe('u32', []);
-  }
-
-  /**
-   * @description The [[Balance]]
-   */
-  public get tip (): ICompact<INumber> {
-    // NOTE from v2+
-    return this.inner.tip || this.registry.createTypeUnsafe('Compact<Balance>', []);
-  }
-
-  /**
-   * @description The transaction version as a [[u32]] for this payload
-   */
-  public get transactionVersion (): INumber {
-    // NOTE only v4+
-    return this.inner.transactionVersion || this.registry.createTypeUnsafe('u32', []);
-  }
-
-  /**
-   * @description The (optional) asset id as a [[u32]] or [[MultiLocation]] for this payload
-   */
-  public get assetId (): IOption<INumber | MultiLocation> {
-    return this.inner.assetId;
-  }
-
-  /**
-   * @description The (optional) [[Hash]] of the genesis metadata for this payload
-   */
-  public get metadataHash (): IOption<Hash> {
-    return this.inner.metadataHash;
-  }
-
-  /**
-   * @description Compares the value of the input to see if there is a match
-   */
-  public override eq (other?: unknown): boolean {
-    return this.inner.eq(other);
-  }
-
-  /**
-   * @description Sign the payload with the keypair
-   */
-  public sign (signerPair: IKeyringPair): { signature: HexString } {
-    const signature = this.inner.sign(signerPair);
-
-    // This is extensible, so we could quite readily extend to send back extra
-    // information, such as for instance the payload, i.e. `payload: this.toHex()`
-    // For the case here we sign via the extrinsic, we ignore the return, so generally
-    // this is applicable for external signing
-    return {
-      signature: u8aToHex(signature)
-    };
-  }
-
-  /**
-   * @description Converts the Object to to a human-friendly JSON, with additional fields, expansion and formatting of information
-   */
-  public override toHuman (isExtended?: boolean, disableAscii?: boolean): AnyJson {
-    return this.inner.toHuman(isExtended, disableAscii);
-  }
-
-  /**
-   * @description Converts the Object to JSON, typically used for RPC transfers
-   */
-  public override toJSON (): any {
-    return this.toHex();
-  }
-
-  /**
-   * @description Returns the base runtime type name for this instance
-   */
-  public toRawType (): string {
-    return 'ExtrinsicPayload';
-  }
-
-  /**
-   * @description Returns the string representation of the value
-   */
-  public override toString (): string {
-    return this.toHex();
-  }
-
-  /**
-   * @description Returns a serialized u8a form
-   */
-  public override toU8a (isBare?: BareOpts): Uint8Array {
-    // call our parent, with only the method stripped
-    return super.toU8a(isBare ? { method: true } : false);
-  }
-}

package/build-deno/extrinsic/ExtrinsicPayloadUnknown.ts

@@ -1,18 +0,0 @@
-
-import type { Registry } from 'https://deno.land/x/pezkuwi/types-codec/types/index.ts';
-import type { ExtrinsicPayloadOptions } from './types.ts';
-
-import { Struct } from 'https://deno.land/x/pezkuwi/types-codec/mod.ts';
-
-/**
- * @name GenericExtrinsicPayloadUnknown
- * @description
- * A default handler for payloads where the version is not known (default throw)
- */
-export class GenericExtrinsicPayloadUnknown extends Struct {
-  constructor (registry: Registry, _value?: unknown, { version = 0 }: Partial<ExtrinsicPayloadOptions> = {}) {
-    super(registry, {});
-
-    throw new Error(`Unsupported extrinsic payload version ${version}`);
-  }
-}

package/build-deno/extrinsic/ExtrinsicUnknown.ts

@@ -1,20 +0,0 @@
-
-import type { Registry } from 'https://deno.land/x/pezkuwi/types-codec/types/index.ts';
-import type { ExtrinsicOptions } from './types.ts';
-
-import { Struct } from 'https://deno.land/x/pezkuwi/types-codec/mod.ts';
-
-import { UNMASK_VERSION } from './constants.ts';
-
-/**
- * @name GenericExtrinsicUnknown
- * @description
- * A default handler for extrinsics where the version is not known (default throw)
- */
-export class GenericExtrinsicUnknown extends Struct {
-  constructor (registry: Registry, _value?: unknown, { isSigned = false, version = 0 }: Partial<ExtrinsicOptions> = {}) {
-    super(registry, {});
-
-    throw new Error(`Unsupported ${isSigned ? '' : 'un'}signed extrinsic version ${version & UNMASK_VERSION}`);
-  }
-}