@pezkuwi/types 16.5.5

package/src/generic/Vote.spec.ts

@@ -0,0 +1,167 @@
+// Copyright 2017-2025 @polkadot/types authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+/// <reference types="@pezkuwi/dev-test/globals.d.ts" />
+
+import { TypeRegistry } from '../create/index.js';
+import { GenericVote } from './index.js';
+
+describe('GenericVote', (): void => {
+  const registry = new TypeRegistry();
+
+  describe('construction', (): void => {
+    it('constructs via boolean true', (): void => {
+      expect(new GenericVote(registry, true).toU8a()).toEqual(new Uint8Array([128]));
+      expect(new GenericVote(registry, true).isAye).toBe(true);
+      expect(new GenericVote(registry, true).isNay).toBe(false);
+    });
+
+    it('constructs via boolean false', (): void => {
+      expect(new GenericVote(registry, false).toU8a()).toEqual(new Uint8Array([0]));
+      expect(new GenericVote(registry, false).isNay).toBe(true);
+      expect(new GenericVote(registry, false).isAye).toBe(false);
+    });
+
+    it('constructs via undefined', (): void => {
+      expect(new GenericVote(registry).isNay).toBe(true);
+    });
+
+    it('has isYay for positive', (): void => {
+      // eslint-disable-next-line no-new-wrappers
+      expect(new GenericVote(registry, true).isAye).toBe(true);
+    });
+
+    it('has isNay for negative', (): void => {
+      // eslint-disable-next-line no-new-wrappers
+      expect(new GenericVote(registry, false).isNay).toBe(true);
+    });
+
+    it('is Aye for negative numbers', (): void => {
+      expect(new GenericVote(registry, -128).isAye).toBe(true);
+    });
+
+    it('is Nay for positive numbers', (): void => {
+      expect(new GenericVote(registry, 127).isNay).toBe(true);
+    });
+
+    it('is Nay for 0', (): void => {
+      expect(new GenericVote(registry, 0).isNay).toBe(true);
+    });
+
+    it('constructs via empty', (): void => {
+      expect(new GenericVote(registry).isNay).toBe(true);
+    });
+
+    it('constructs via Uint8Array (empty)', (): void => {
+      expect(new GenericVote(registry, new Uint8Array()).isNay).toBe(true);
+    });
+
+    it('constructs via Uint8Array (nay)', (): void => {
+      expect(new GenericVote(registry, new Uint8Array([1])).isNay).toBe(true);
+    });
+
+    it('constructs via Uint8Array (aye)', (): void => {
+      const test = new GenericVote(registry, new Uint8Array([0b10000010]));
+
+      expect(test.isNay).toBe(false);
+      expect(test.conviction.toString()).toEqual('Locked2x');
+    });
+  });
+
+  describe('Vote with conviction', (): void => {
+    it('constructs Vote with raw boolean', (): void => {
+      const vote = new GenericVote(registry, {
+        aye: true,
+        conviction: 'Locked1x'
+      });
+
+      expect(
+        vote.toU8a()
+      ).toEqual(new Uint8Array([0b10000001]));
+      expect(
+        vote.toPrimitive()
+      ).toEqual({
+        aye: true,
+        conviction: 'Locked1x'
+      });
+    });
+
+    it('constructs with Vote aye is false, conviction is None', (): void => {
+      expect(
+        new GenericVote(registry, {
+          aye: false,
+          conviction: 'None'
+        }).toU8a()
+      ).toEqual(new Uint8Array([0b00000000]));
+    });
+
+    it('constructs with Vote aye is true, conviction is Locked4x', (): void => {
+      expect(
+        new GenericVote(registry, {
+          aye: true,
+          conviction: 'Locked4x'
+        }).toU8a()
+      ).toEqual(new Uint8Array([0b10000100]));
+    });
+  });
+
+  describe('getters', (): void => {
+    it('Conviction getter works', (): void => {
+      expect(
+        new GenericVote(registry, {
+          aye: true,
+          conviction: 'Locked2x'
+        }).conviction.toString()
+      ).toEqual('Locked2x');
+    });
+
+    it('Conviction getter works with raw boolean and string conviction', (): void => {
+      expect(
+        new GenericVote(registry, {
+          aye: true,
+          conviction: 'Locked2x'
+        }).conviction.toString()
+      ).toEqual('Locked2x');
+    });
+
+    it('Conviction getter works with raw boolean and conviction index', (): void => {
+      expect(
+        new GenericVote(registry, {
+          aye: true,
+          conviction: 2
+        }).conviction.toString()
+      ).toEqual('Locked2x');
+    });
+
+    it('Conviction getter works with raw boolean and no conviction', (): void => {
+      const test = new GenericVote(registry, { aye: true });
+
+      expect(test.isAye).toEqual(true);
+      expect(test.conviction.toString()).toEqual('None');
+    });
+
+    it('isAye getter works', (): void => {
+      expect(
+        new GenericVote(registry, {
+          aye: true,
+          conviction: 'None'
+        }).isAye)
+        .toEqual(true);
+    });
+
+    it('isNay getter works', (): void => {
+      expect(
+        new GenericVote(registry, {
+          aye: true,
+          conviction: 'None'
+        }).isNay)
+        .toEqual(false);
+    });
+  });
+
+  describe('utils', (): void => {
+    it('has a sane toRawType', (): void => {
+      expect(new GenericVote(registry).toRawType()).toEqual('Vote');
+    });
+  });
+});

package/src/generic/Vote.ts

@@ -0,0 +1,133 @@
+// Copyright 2017-2025 @polkadot/types authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+import type { AnyJson, Registry } from '@pezkuwi/types-codec/types';
+import type { AllConvictions } from '../interfaces/democracy/definitions.js';
+import type { Conviction } from '../interfaces/democracy/index.js';
+import type { ArrayElementType } from '../types/index.js';
+
+import { Bool, U8aFixed } from '@pezkuwi/types-codec';
+import { isBoolean, isNumber, isU8a, isUndefined } from '@pezkuwi/util';
+
+interface VoteType {
+  aye: boolean;
+  conviction?: number | ArrayElementType<typeof AllConvictions>;
+}
+
+// eslint-disable-next-line @typescript-eslint/ban-types
+type InputTypes = boolean | number | Boolean | Uint8Array | VoteType;
+
+// For votes, the topmost bit indicated aye/nay, the lower bits indicate the conviction
+const AYE_BITS = 0b10000000;
+const NAY_BITS = 0b00000000;
+const CON_MASK = 0b01111111;
+const DEF_CONV = 0b00000000; // the default conviction, None
+
+/** @internal */
+function decodeVoteBool (value: boolean): Uint8Array {
+  return value
+    ? new Uint8Array([AYE_BITS | DEF_CONV])
+    : new Uint8Array([NAY_BITS]);
+}
+
+/** @internal */
+function decodeVoteU8a (value: Uint8Array): Uint8Array {
+  return value.length
+    ? value.subarray(0, 1)
+    : new Uint8Array([NAY_BITS]);
+}
+
+/** @internal */
+function decodeVoteType (registry: Registry, value: VoteType): Uint8Array {
+  return new Uint8Array([
+    (
+      new Bool(registry, value.aye).isTrue
+        ? AYE_BITS
+        : NAY_BITS
+    ) |
+    registry.createTypeUnsafe<Conviction>('Conviction', [value.conviction || DEF_CONV]).index
+  ]);
+}
+
+/** @internal */
+function decodeVote (registry: Registry, value?: InputTypes): Uint8Array {
+  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: boolean;
+  #conviction: Conviction;
+
+  constructor (registry: Registry, value?: InputTypes) {
+    // 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
+   */
+  public get conviction (): Conviction {
+    return this.#conviction;
+  }
+
+  /**
+   * @description true if the wrapped value is a positive vote
+   */
+  public get isAye (): boolean {
+    return this.#aye;
+  }
+
+  /**
+   * @description true if the wrapped value is a negative vote
+   */
+  public get isNay (): boolean {
+    return !this.isAye;
+  }
+
+  /**
+   * @description Converts the Object to to a human-friendly JSON, with additional fields, expansion and formatting of information
+   */
+  public override toHuman (isExpanded?: boolean): AnyJson {
+    return {
+      conviction: this.conviction.toHuman(isExpanded),
+      vote: this.isAye ? 'Aye' : 'Nay'
+    };
+  }
+
+  /**
+   * @description Converts the value in a best-fit primitive form
+   */
+  public override toPrimitive (): any {
+    return {
+      aye: this.isAye,
+      conviction: this.conviction.toPrimitive()
+    };
+  }
+
+  /**
+   * @description Returns the base runtime type name for this instance
+   */
+  public override toRawType (): string {
+    return 'Vote';
+  }
+}

package/src/generic/index.ts

@@ -0,0 +1,17 @@
+// Copyright 2017-2025 @polkadot/types authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+// all named
+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';
+
+// all starred
+export * from '../ethereum/index.js';

package/src/index.spec.ts

@@ -0,0 +1,78 @@
+// Copyright 2017-2025 @polkadot/types authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+import type { Codec } from './types/index.js';
+
+import metadataStatic from '@pezkuwi/types-support/metadata/static-substrate';
+
+import { TypeRegistry } from './create/index.js';
+import * as definitions from './interfaces/definitions.js';
+import { Metadata } from './metadata/index.js';
+import * as exported from './index.types.js';
+
+// NOTE This is not a shortcut to implementing types incorrectly. This is here
+// specifically for the types that _should_ throw in the constrtuctor, i.e
+// `usize` is not allowed (runtime incompat) and `origin` is not passed through
+// to any calls. All other types _must_ pass and allow for empty defaults
+const UNCONSTRUCTABLE = [
+  'ExtrinsicPayloadUnknown', 'GenericExtrinsicPayloadUnknown',
+  'ExtrinsicUnknown', 'GenericExtrinsicUnknown',
+  'DoNotConstruct',
+  'MetadataAll',
+  'Origin',
+  'isize',
+  'usize'
+].map((v): string => v.toLowerCase());
+
+const registry = new TypeRegistry();
+const metadata = new Metadata(registry, metadataStatic);
+
+registry.setMetadata(metadata);
+
+function testTypes (type: string, typeNames: string[]): void {
+  describe(`${type}`, (): void => {
+    describe(`${type}:: default creation`, (): void => {
+      typeNames.forEach((name): void => {
+        it(`creates an empty ${name}`, (): void => {
+          const constructFn = (): Codec =>
+            registry.createType(name);
+
+          if (UNCONSTRUCTABLE.includes(name.toLowerCase())) {
+            // eslint-disable-next-line jest/no-conditional-expect
+            expect(constructFn).toThrow();
+          } else {
+            // eslint-disable-next-line jest/no-conditional-expect
+            expect(constructFn).not.toThrow();
+          }
+        });
+      });
+    });
+
+    describe(`${type}:: default creation (empty bytes)`, (): void => {
+      typeNames.forEach((name): void => {
+        it(`creates an empty ${name} (from empty bytes)`, (): void => {
+          const constructFn = (): Codec =>
+            registry.createType(name, registry.createType('Bytes'));
+
+          if (UNCONSTRUCTABLE.includes(name.toLowerCase())) {
+            // eslint-disable-next-line jest/no-conditional-expect
+            expect(constructFn).toThrow();
+          } else {
+            // eslint-disable-next-line jest/no-conditional-expect
+            expect(constructFn).not.toThrow();
+          }
+        });
+      });
+    });
+  });
+}
+
+describe('type creation', (): void => {
+  testTypes('exported', Object.keys(exported));
+
+  Object
+    .entries(definitions)
+    .forEach(([name, { types }]): void =>
+      testTypes(`${name} (injected)`, Object.keys(types))
+    );
+});

package/src/index.ts

@@ -0,0 +1,6 @@
+// Copyright 2017-2025 @polkadot/types authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+import './packageDetect.js';
+
+export * from './bundle.js';

package/src/index.types.ts

@@ -0,0 +1,6 @@
+// Copyright 2017-2025 @polkadot/types authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+export * from './extrinsic/index.js';
+export * from './generic/index.js';
+export * from './primitive/index.js';

package/src/interfaces/alias.spec.ts

@@ -0,0 +1,50 @@
+// Copyright 2017-2025 @polkadot/types-known authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+/// <reference types="@pezkuwi/dev-test/globals.d.ts" />
+
+import { TypeRegistry } from '../create/registry.js';
+import { getAliasTypes } from './alias.js';
+
+const registry = new TypeRegistry();
+
+registry.setKnownTypes({
+  typesAlias: {
+    identity: {
+      Id: 'IdentityId'
+    },
+    testModule: {
+      Proposal: 'TestProposal'
+    },
+    treasury: {
+      Proposal: 'TreasuryProposals2'
+    }
+  }
+});
+
+describe('getModuleTypes', (): void => {
+  it('collects the pre-defined types for contracts', (): void => {
+    expect(getAliasTypes(registry, 'contracts')).toEqual({
+      StorageKey: 'ContractStorageKey'
+    });
+  });
+
+  it('collects the user-defined types for testModule', (): void => {
+    expect(getAliasTypes(registry, 'testModule')).toEqual({
+      Proposal: 'TestProposal'
+    });
+  });
+
+  it('overrides pre-defined with user-defined for treasury', (): void => {
+    expect(getAliasTypes(registry, 'treasury')).toEqual({
+      Proposal: 'TreasuryProposals2'
+    });
+  });
+
+  it('merges pre-defined and user-defined for identity', (): void => {
+    expect(getAliasTypes(registry, 'identity')).toEqual({
+      Id: 'IdentityId',
+      Judgement: 'IdentityJudgement'
+    });
+  });
+});

package/src/interfaces/alias.ts

@@ -0,0 +1,116 @@
+// Copyright 2017-2025 @polkadot/types-known authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+import type { OverrideModuleType, Registry } from '../types/index.js';
+
+// type overrides for modules (where duplication between modules exist)
+const typesAlias: Record<string, OverrideModuleType> = {
+  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'
+  },
+  parachains: {
+    Id: 'ParaId'
+  },
+  parasDisputes: {
+    ValidatorIndex: 'ParaValidatorIndex'
+  },
+  parasInclusion: {
+    ValidatorIndex: 'ParaValidatorIndex'
+  },
+  parasScheduler: {
+    ValidatorIndex: 'ParaValidatorIndex'
+  },
+  parasShared: {
+    ValidatorIndex: 'ParaValidatorIndex'
+  },
+  proposeParachain: {
+    Proposal: 'ParachainProposal'
+  },
+  proxy: {
+    Announcement: 'ProxyAnnouncement'
+  },
+  scheduler: {
+    ValidatorIndex: 'ParaValidatorIndex'
+  },
+  shared: {
+    ValidatorIndex: 'ParaValidatorIndex'
+  },
+  society: {
+    Judgement: 'SocietyJudgement',
+    Vote: 'SocietyVote'
+  },
+  staking: {
+    Compact: 'CompactAssignments'
+  },
+  treasury: {
+    Proposal: 'TreasuryProposal'
+  },
+  xcm: {
+    AssetId: 'XcmAssetId'
+  },
+  xcmPallet: {
+    AssetId: 'XcmAssetId'
+  }
+};
+
+/**
+ * @description Get types for specific modules (metadata override)
+ */
+export function getAliasTypes ({ knownTypes }: Registry, section: string): OverrideModuleType {
+  return {
+    ...(typesAlias[section] ?? {}),
+    ...(knownTypes.typesAlias?.[section] ?? {})
+  };
+}

package/src/interfaces/assetConversion/definitions.ts

@@ -0,0 +1,17 @@
+// Copyright 2017-2025 @polkadot/types authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+// order important in structs... :)
+/* eslint-disable sort-keys */
+
+import type { Definitions } from '../../types/index.js';
+
+import { runtime } from './runtime.js';
+
+export default {
+  rpc: {},
+  runtime,
+  types: {
+    TAssetConversion: 'Option<MultiLocation>'
+  }
+} as Definitions;

package/src/interfaces/assetConversion/index.ts

@@ -0,0 +1,4 @@
+// Auto-generated via `yarn polkadot-types-from-defs`, do not edit
+/* eslint-disable */
+
+export * from './types.js';

package/src/interfaces/assetConversion/runtime.ts

@@ -0,0 +1,72 @@
+// Copyright 2017-2025 @polkadot/types authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+import type { DefinitionsCall } from '../../types/index.js';
+
+export const runtime: DefinitionsCall = {
+  AssetConversionApi: [
+    {
+      methods: {
+        get_reserves: {
+          description: 'Get pool reserves',
+          params: [
+            {
+              name: 'asset1',
+              type: 'StagingXcmV3MultiLocation'
+            },
+            {
+              name: 'asset2',
+              type: 'StagingXcmV3MultiLocation'
+            }
+          ],
+          type: 'Option<(Balance,Balance)>'
+        },
+        quote_price_exact_tokens_for_tokens: {
+          description: 'Quote price: exact tokens for tokens',
+          params: [
+            {
+              name: 'asset1',
+              type: 'StagingXcmV3MultiLocation'
+            },
+            {
+              name: 'asset2',
+              type: 'StagingXcmV3MultiLocation'
+            },
+            {
+              name: 'amount',
+              type: 'u128'
+            },
+            {
+              name: 'include_fee',
+              type: 'bool'
+            }
+          ],
+          type: 'Option<(Balance)>'
+        },
+        quote_price_tokens_for_exact_tokens: {
+          description: 'Quote price: tokens for exact tokens',
+          params: [
+            {
+              name: 'asset1',
+              type: 'StagingXcmV3MultiLocation'
+            },
+            {
+              name: 'asset2',
+              type: 'StagingXcmV3MultiLocation'
+            },
+            {
+              name: 'amount',
+              type: 'u128'
+            },
+            {
+              name: 'include_fee',
+              type: 'bool'
+            }
+          ],
+          type: 'Option<(Balance)>'
+        }
+      },
+      version: 1
+    }
+  ]
+};

package/src/interfaces/assetConversion/types.ts

@@ -0,0 +1,10 @@
+// Auto-generated via `yarn polkadot-types-from-defs`, do not edit
+/* eslint-disable */
+
+import type { Option } from '@pezkuwi/types-codec';
+import type { MultiLocation } from '@pezkuwi/types/interfaces/xcm';
+
+/** @name TAssetConversion */
+export interface TAssetConversion extends Option<MultiLocation> {}
+
+export type PHANTOM_ASSETCONVERSION = 'assetConversion';