@pezkuwi/types 16.5.5 → 16.5.8

package/build-tsc-esm/generic/ConsensusEngineId.js

@@ -0,0 +1,100 @@
+import { U8aFixed } from '@pezkuwi/types-codec';
+import { BN, bnToU8a, isNumber, stringToU8a, u8aToHex, u8aToString } from '@pezkuwi/util';
+export const CID_AURA = /*#__PURE__*/ stringToU8a('aura');
+export const CID_BABE = /*#__PURE__*/ stringToU8a('BABE');
+export const CID_GRPA = /*#__PURE__*/ stringToU8a('FRNK');
+export const CID_POW = /*#__PURE__*/ stringToU8a('pow_');
+export const CID_NMBS = /*#__PURE__*/ stringToU8a('nmbs');
+function getAuraAuthor(registry, bytes, sessionValidators) {
+    return sessionValidators[registry.createTypeUnsafe('RawAuraPreDigest', [bytes.toU8a(true)])
+        .slotNumber
+        .mod(new BN(sessionValidators.length))
+        .toNumber()];
+}
+function getBabeAuthor(registry, bytes, sessionValidators) {
+    const digest = registry.createTypeUnsafe('RawBabePreDigestCompat', [bytes.toU8a(true)]);
+    return sessionValidators[digest.value.toNumber()];
+}
+function getBytesAsAuthor(registry, bytes) {
+    return registry.createTypeUnsafe('AccountId', [bytes]);
+}
+/**
+ * @name GenericConsensusEngineId
+ * @description
+ * A 4-byte identifier identifying the engine
+ */
+export class GenericConsensusEngineId extends U8aFixed {
+    constructor(registry, value) {
+        super(registry, isNumber(value)
+            ? bnToU8a(value, { isLe: false })
+            : value, 32);
+    }
+    /**
+     * @description `true` if the engine matches aura
+     */
+    get isAura() {
+        return this.eq(CID_AURA);
+    }
+    /**
+     * @description `true` is the engine matches babe
+     */
+    get isBabe() {
+        return this.eq(CID_BABE);
+    }
+    /**
+     * @description `true` is the engine matches grandpa
+     */
+    get isGrandpa() {
+        return this.eq(CID_GRPA);
+    }
+    /**
+     * @description `true` is the engine matches pow
+     */
+    get isPow() {
+        return this.eq(CID_POW);
+    }
+    /**
+     * @description `true` is the engine matches nimbus
+     */
+    get isNimbus() {
+        return this.eq(CID_NMBS);
+    }
+    /**
+     * @description From the input bytes, decode into an author
+     */
+    extractAuthor(bytes, sessionValidators) {
+        if (sessionValidators?.length) {
+            if (this.isAura) {
+                return getAuraAuthor(this.registry, bytes, sessionValidators);
+            }
+            else if (this.isBabe) {
+                return getBabeAuthor(this.registry, bytes, sessionValidators);
+            }
+        }
+        // For pow & Nimbus, the bytes are the actual author
+        if (this.isPow || this.isNimbus) {
+            return getBytesAsAuthor(this.registry, bytes);
+        }
+        return undefined;
+    }
+    /**
+     * @description Converts the Object to to a human-friendly JSON, with additional fields, expansion and formatting of information
+     */
+    toHuman() {
+        return this.toString();
+    }
+    /**
+     * @description Returns the base runtime type name for this instance
+     */
+    toRawType() {
+        return 'ConsensusEngineId';
+    }
+    /**
+     * @description Override the default toString to return a 4-byte string
+     */
+    toString() {
+        return this.isAscii
+            ? u8aToString(this)
+            : u8aToHex(this);
+    }
+}

package/build-tsc-esm/generic/Event.js

@@ -0,0 +1,151 @@
+import { Null, Struct, Tuple } from '@pezkuwi/types-codec';
+import { objectProperties, objectSpread } from '@pezkuwi/util';
+/** @internal */
+function decodeEvent(registry, value) {
+    if (!value?.length) {
+        return { DataType: Null };
+    }
+    const index = value.subarray(0, 2);
+    return {
+        DataType: registry.findMetaEvent(index),
+        value: {
+            data: value.subarray(2),
+            index
+        }
+    };
+}
+/**
+ * @name GenericEventData
+ * @description
+ * Wrapper for the actual data that forms part of an [[Event]]
+ */
+export class GenericEventData extends Tuple {
+    #meta;
+    #method;
+    #names = null;
+    #section;
+    #typeDef;
+    constructor(registry, value, meta, section = '<unknown>', method = '<unknown>') {
+        const fields = meta?.fields || [];
+        super(registry, fields.map(({ type }) => registry.createLookupType(type)), value);
+        this.#meta = meta;
+        this.#method = method;
+        this.#section = section;
+        this.#typeDef = fields.map(({ type }) => registry.lookup.getTypeDef(type));
+        const names = fields
+            .map(({ name }) => registry.lookup.sanitizeField(name)[0])
+            .filter((n) => !!n);
+        if (names.length === fields.length) {
+            this.#names = names;
+            objectProperties(this, names, (_, i) => this[i]);
+        }
+    }
+    /**
+     * @description The wrapped [[EventMetadata]]
+     */
+    get meta() {
+        return this.#meta;
+    }
+    /**
+     * @description The method as a string
+     */
+    get method() {
+        return this.#method;
+    }
+    /**
+     * @description The field names (as available)
+     */
+    get names() {
+        return this.#names;
+    }
+    /**
+     * @description The section as a string
+     */
+    get section() {
+        return this.#section;
+    }
+    /**
+     * @description The [[TypeDef]] for this event
+     */
+    get typeDef() {
+        return this.#typeDef;
+    }
+    /**
+     * @description Converts the Object to to a human-friendly JSON, with additional fields, expansion and formatting of information
+     */
+    toHuman(isExtended, disableAscii) {
+        if (this.#names !== null) {
+            const json = {};
+            for (let i = 0, count = this.#names.length; i < count; i++) {
+                json[this.#names[i]] = this[i].toHuman(isExtended, disableAscii);
+            }
+            return json;
+        }
+        return super.toHuman(isExtended);
+    }
+}
+/**
+ * @name GenericEvent
+ * @description
+ * A representation of a system event. These are generated via the [[Metadata]] interfaces and
+ * specific to a specific Bizinikiwi runtime
+ */
+export class GenericEvent extends Struct {
+    // Currently we _only_ decode from Uint8Array, since we expect it to
+    // be used via EventRecord
+    constructor(registry, _value) {
+        const { DataType, value } = decodeEvent(registry, _value);
+        super(registry, {
+            index: 'EventId',
+            // eslint-disable-next-line sort-keys
+            data: DataType
+        }, value);
+    }
+    /**
+     * @description The wrapped [[EventData]]
+     */
+    get data() {
+        return this.getT('data');
+    }
+    /**
+     * @description The [[EventId]], identifying the raw event
+     */
+    get index() {
+        return this.getT('index');
+    }
+    /**
+     * @description The [[EventMetadata]] with the documentation
+     */
+    get meta() {
+        return this.data.meta;
+    }
+    /**
+     * @description The method string identifying the event
+     */
+    get method() {
+        return this.data.method;
+    }
+    /**
+     * @description The section string identifying the event
+     */
+    get section() {
+        return this.data.section;
+    }
+    /**
+     * @description The [[TypeDef]] for the event
+     */
+    get typeDef() {
+        return this.data.typeDef;
+    }
+    /**
+     * @description Converts the Object to to a human-friendly JSON, with additional fields, expansion and formatting of information
+     */
+    toHuman(isExpanded, disableAscii) {
+        return objectSpread({
+            method: this.method,
+            section: this.section
+        }, isExpanded
+            ? { docs: this.meta.docs.map((d) => d.toString()) }
+            : null, super.toHuman(isExpanded, disableAscii));
+    }
+}

package/build-tsc-esm/generic/LookupSource.js

@@ -0,0 +1,108 @@
+import { AbstractBase } from '@pezkuwi/types-codec';
+import { isBigInt, isBn, isHex, isNumber, isU8a, u8aConcat, u8aToBn, u8aToHex, u8aToU8a } from '@pezkuwi/util';
+import { decodeAddress } from '@pezkuwi/util-crypto';
+import { GenericAccountId } from './AccountId.js';
+import { GenericAccountIndex } from './AccountIndex.js';
+export const ACCOUNT_ID_PREFIX = new Uint8Array([0xff]);
+/** @internal */
+function decodeString(registry, value) {
+    const decoded = decodeAddress(value);
+    return decoded.length === 32
+        ? registry.createTypeUnsafe('AccountId', [decoded])
+        : registry.createTypeUnsafe('AccountIndex', [u8aToBn(decoded)]);
+}
+/** @internal */
+function decodeU8a(registry, value) {
+    // This allows us to instantiate an address with a raw publicKey. Do this first before
+    // we checking the first byte, otherwise we may split an already-existent valid address
+    if (value.length === 32) {
+        return registry.createTypeUnsafe('AccountId', [value]);
+    }
+    else if (value[0] === 0xff) {
+        return registry.createTypeUnsafe('AccountId', [value.subarray(1)]);
+    }
+    const [offset, length] = GenericAccountIndex.readLength(value);
+    return registry.createTypeUnsafe('AccountIndex', [u8aToBn(value.subarray(offset, offset + length))]);
+}
+/** @internal */
+function decodeAddressOrIndex(registry, value) {
+    return value instanceof GenericLookupSource
+        ? value.inner
+        : value instanceof GenericAccountId || value instanceof GenericAccountIndex
+            ? value
+            : isBn(value) || isNumber(value) || isBigInt(value)
+                ? registry.createTypeUnsafe('AccountIndex', [value])
+                : Array.isArray(value) || isHex(value) || isU8a(value)
+                    ? decodeU8a(registry, u8aToU8a(value))
+                    : decodeString(registry, value);
+}
+/**
+ * @name LookupSource
+ * @description
+ * A wrapper around an AccountId and/or AccountIndex that is encoded with a prefix.
+ * Since we are dealing with underlying publicKeys (or shorter encoded addresses),
+ * we extend from Base with an AccountId/AccountIndex wrapper. Basically the Address
+ * is encoded as `[ <prefix-byte>, ...publicKey/...bytes ]` as per spec
+ */
+export class GenericLookupSource extends AbstractBase {
+    constructor(registry, value = new Uint8Array()) {
+        super(registry, decodeAddressOrIndex(registry, value));
+    }
+    /**
+     * @description The length of the value when encoded as a Uint8Array
+     */
+    get encodedLength() {
+        const rawLength = this._rawLength;
+        return rawLength + (
+        // for 1 byte AccountIndexes, we are not adding a specific prefix
+        rawLength > 1
+            ? 1
+            : 0);
+    }
+    /**
+     * @description The length of the raw value, either AccountIndex or AccountId
+     */
+    get _rawLength() {
+        return this.inner instanceof GenericAccountIndex
+            ? GenericAccountIndex.calcLength(this.inner)
+            : this.inner.encodedLength;
+    }
+    /**
+     * @description Returns a breakdown of the hex encoding for this Codec
+     */
+    inspect() {
+        const value = this.inner.toU8a().subarray(0, this._rawLength);
+        return {
+            outer: [
+                new Uint8Array(this.inner instanceof GenericAccountIndex
+                    ? GenericAccountIndex.writeLength(value)
+                    : ACCOUNT_ID_PREFIX),
+                value
+            ]
+        };
+    }
+    /**
+     * @description Returns a hex string representation of the value
+     */
+    toHex() {
+        return u8aToHex(this.toU8a());
+    }
+    /**
+     * @description Returns the base runtime type name for this instance
+     */
+    toRawType() {
+        return 'Address';
+    }
+    /**
+     * @description Encodes the value as a Uint8Array as per the SCALE specifications
+     * @param isBare true when the value has none of the type-specific prefixes (internal)
+     */
+    toU8a(isBare) {
+        const encoded = this.inner.toU8a().subarray(0, this._rawLength);
+        return isBare
+            ? encoded
+            : u8aConcat(this.inner instanceof GenericAccountIndex
+                ? GenericAccountIndex.writeLength(encoded)
+                : ACCOUNT_ID_PREFIX, encoded);
+    }
+}

package/build-tsc-esm/generic/MultiAddress.js

@@ -0,0 +1,65 @@
+import { Enum } from '@pezkuwi/types-codec';
+import { isBn, isNumber, isString, isU8a } from '@pezkuwi/util';
+import { decodeAddress } from '@pezkuwi/util-crypto';
+import { GenericAccountId } from './AccountId.js';
+import { GenericAccountIndex } from './AccountIndex.js';
+function decodeU8a(registry, u8a) {
+    if ([0, 32].includes(u8a.length)) {
+        return { Id: u8a };
+    }
+    else if (u8a.length === 20) {
+        return { Address20: u8a };
+    }
+    else if (u8a.length <= 8) {
+        return { Index: registry.createTypeUnsafe('AccountIndex', [u8a]).toNumber() };
+    }
+    return u8a;
+}
+function decodeMultiAny(registry, value) {
+    if (value instanceof GenericAccountId) {
+        return { Id: value };
+    }
+    else if (isU8a(value)) {
+        // NOTE This is after the AccountId check (which is U8a)
+        return decodeU8a(registry, value);
+    }
+    else if (value instanceof GenericMultiAddress) {
+        return value;
+    }
+    else if (value instanceof GenericAccountIndex || isBn(value) || isNumber(value)) {
+        return { Index: isNumber(value) ? value : value.toNumber() };
+    }
+    else if (isString(value)) {
+        return decodeU8a(registry, decodeAddress(value.toString()));
+    }
+    return value;
+}
+export class GenericMultiAddress extends Enum {
+    constructor(registry, value) {
+        super(registry, {
+            Id: 'AccountId',
+            Index: 'Compact<AccountIndex>',
+            Raw: 'Bytes',
+            // eslint-disable-next-line sort-keys
+            Address32: 'H256',
+            // eslint-disable-next-line sort-keys
+            Address20: 'H160'
+        }, decodeMultiAny(registry, value));
+    }
+    /**
+     * @description Returns a breakdown of the hex encoding for this Codec
+     */
+    inspect() {
+        const { inner, outer = [] } = this.inner.inspect();
+        return {
+            inner,
+            outer: [new Uint8Array([this.index]), ...outer]
+        };
+    }
+    /**
+     * @description Returns the string representation of the value
+     */
+    toString() {
+        return this.value.toString();
+    }
+}

package/build-tsc-esm/generic/Vote.js

@@ -0,0 +1,100 @@
+import { Bool, U8aFixed } from '@pezkuwi/types-codec';
+import { isBoolean, isNumber, isU8a, isUndefined } from '@pezkuwi/util';
+const AYE_BITS = 0b10000000;
+const NAY_BITS = 0b00000000;
+const CON_MASK = 0b01111111;
+const DEF_CONV = 0b00000000; // the default conviction, None
+/** @internal */
+function decodeVoteBool(value) {
+    return value
+        ? new Uint8Array([AYE_BITS | DEF_CONV])
+        : new Uint8Array([NAY_BITS]);
+}
+/** @internal */
+function decodeVoteU8a(value) {
+    return value.length
+        ? value.subarray(0, 1)
+        : new Uint8Array([NAY_BITS]);
+}
+/** @internal */
+function decodeVoteType(registry, value) {
+    return new Uint8Array([
+        (new Bool(registry, value.aye).isTrue
+            ? AYE_BITS
+            : NAY_BITS) |
+            registry.createTypeUnsafe('Conviction', [value.conviction || DEF_CONV]).index
+    ]);
+}
+/** @internal */
+function decodeVote(registry, value) {
+    if (isU8a(value)) {
+        return decodeVoteU8a(value);
+    }
+    else if (isUndefined(value) || value instanceof Boolean || isBoolean(value)) {
+        return decodeVoteBool(new Bool(registry, value).isTrue);
+    }
+    else if (isNumber(value)) {
+        return decodeVoteBool(value < 0);
+    }
+    return decodeVoteType(registry, value);
+}
+/**
+ * @name GenericVote
+ * @description
+ * A number of lock periods, plus a vote, one way or the other.
+ */
+export class GenericVote extends U8aFixed {
+    #aye;
+    #conviction;
+    constructor(registry, value) {
+        // decoded is just 1 byte
+        // Aye: Most Significant Bit
+        // Conviction: 0000 - 0101
+        const decoded = decodeVote(registry, value);
+        super(registry, decoded, 8);
+        this.#aye = (decoded[0] & AYE_BITS) === AYE_BITS;
+        this.#conviction = this.registry.createTypeUnsafe('Conviction', [decoded[0] & CON_MASK]);
+    }
+    /**
+     * @description returns a V2 conviction
+     */
+    get conviction() {
+        return this.#conviction;
+    }
+    /**
+     * @description true if the wrapped value is a positive vote
+     */
+    get isAye() {
+        return this.#aye;
+    }
+    /**
+     * @description true if the wrapped value is a negative vote
+     */
+    get isNay() {
+        return !this.isAye;
+    }
+    /**
+     * @description Converts the Object to to a human-friendly JSON, with additional fields, expansion and formatting of information
+     */
+    toHuman(isExpanded) {
+        return {
+            conviction: this.conviction.toHuman(isExpanded),
+            vote: this.isAye ? 'Aye' : 'Nay'
+        };
+    }
+    /**
+     * @description Converts the value in a best-fit primitive form
+     */
+    toPrimitive() {
+        return {
+            aye: this.isAye,
+            conviction: this.conviction.toPrimitive()
+        };
+    }
+    /**
+     * @description Returns the base runtime type name for this instance
+     */
+    toRawType() {
+        return 'Vote';
+    }
+}

package/build-tsc-esm/generic/index.js

@@ -0,0 +1,11 @@
+export { GenericAccountId, GenericAccountId as GenericAccountId32, GenericAccountId33 } from './AccountId.js';
+export { GenericAccountIndex } from './AccountIndex.js';
+export { GenericBlock } from './Block.js';
+export { GenericCall } from './Call.js';
+export { GenericChainProperties } from './ChainProperties.js';
+export { GenericConsensusEngineId } from './ConsensusEngineId.js';
+export { GenericEvent, GenericEventData } from './Event.js';
+export { GenericLookupSource } from './LookupSource.js';
+export { GenericMultiAddress as GenericAddress, GenericMultiAddress } from './MultiAddress.js';
+export { GenericVote } from './Vote.js';
+export * from '../ethereum/index.js';

package/build-tsc-esm/index.js

@@ -0,0 +1,2 @@
+import './packageDetect.js';
+export * from './bundle.js';

package/build-tsc-esm/index.types.js

@@ -0,0 +1,3 @@
+export * from './extrinsic/index.js';
+export * from './generic/index.js';
+export * from './primitive/index.js';

package/build-tsc-esm/interfaces/alias.js

@@ -0,0 +1,109 @@
+const typesAlias = {
+    assets: {
+        Approval: 'AssetApproval',
+        ApprovalKey: 'AssetApprovalKey',
+        Balance: 'TAssetBalance',
+        DestroyWitness: 'AssetDestroyWitness'
+    },
+    babe: {
+        EquivocationProof: 'BabeEquivocationProof'
+    },
+    balances: {
+        Status: 'BalanceStatus'
+    },
+    beefy: {
+        AuthorityId: 'BeefyId'
+    },
+    contracts: {
+        StorageKey: 'ContractStorageKey'
+    },
+    electionProviderMultiPhase: {
+        Phase: 'ElectionPhase'
+    },
+    ethereum: {
+        Block: 'EthBlock',
+        Header: 'EthHeader',
+        Receipt: 'EthReceipt',
+        Transaction: 'EthTransaction',
+        TransactionStatus: 'EthTransactionStatus'
+    },
+    evm: {
+        Account: 'EvmAccount',
+        Log: 'EvmLog',
+        Vicinity: 'EvmVicinity'
+    },
+    grandpa: {
+        Equivocation: 'GrandpaEquivocation',
+        EquivocationProof: 'GrandpaEquivocationProof'
+    },
+    identity: {
+        Judgement: 'IdentityJudgement'
+    },
+    inclusion: {
+        ValidatorIndex: 'ParaValidatorIndex'
+    },
+    paraDisputes: {
+        ValidatorIndex: 'ParaValidatorIndex'
+    },
+    paraInclusion: {
+        ValidatorIndex: 'ParaValidatorIndex'
+    },
+    paraScheduler: {
+        ValidatorIndex: 'ParaValidatorIndex'
+    },
+    paraShared: {
+        ValidatorIndex: 'ParaValidatorIndex'
+    },
+    teyrchains: {
+        Id: 'ParaId'
+    },
+    parasDisputes: {
+        ValidatorIndex: 'ParaValidatorIndex'
+    },
+    parasInclusion: {
+        ValidatorIndex: 'ParaValidatorIndex'
+    },
+    parasScheduler: {
+        ValidatorIndex: 'ParaValidatorIndex'
+    },
+    parasShared: {
+        ValidatorIndex: 'ParaValidatorIndex'
+    },
+    proposeTeyrchain: {
+        Proposal: 'TeyrchainProposal'
+    },
+    proxy: {
+        Announcement: 'ProxyAnnouncement'
+    },
+    scheduler: {
+        ValidatorIndex: 'ParaValidatorIndex'
+    },
+    shared: {
+        ValidatorIndex: 'ParaValidatorIndex'
+    },
+    society: {
+        Judgement: 'SocietyJudgement',
+        Vote: 'SocietyVote'
+    },
+    staking: {
+        Compact: 'CompactAssignments'
+    },
+    treasury: {
+        Proposal: 'TreasuryProposal'
+    },
+    xcm: {
+        AssetId: 'XcmAssetId'
+    },
+    xcmPezpallet: {
+        AssetId: 'XcmAssetId'
+    }
+};
+/**
+ * @description Get types for specific modules (metadata override)
+ */
+export function getAliasTypes({ knownTypes }, section) {
+    return {
+        ...(typesAlias[section] ?? {}),
+        ...(knownTypes.typesAlias?.[section] ?? {})
+    };
+}

package/build-tsc-esm/interfaces/assetConversion/definitions.js

@@ -0,0 +1,8 @@
+import { runtime } from './runtime.js';
+export default {
+    rpc: {},
+    runtime,
+    types: {
+        TAssetConversion: 'Option<MultiLocation>'
+    }
+};

package/build-tsc-esm/interfaces/assetConversion/index.js

@@ -0,0 +1,2 @@
+/* eslint-disable */
+export * from './types.js';