@pezkuwi/types 16.5.5

package/src/ethereum/AccountId.spec.ts

@@ -0,0 +1,86 @@
+// Copyright 2017-2025 @polkadot/types authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+/// <reference types="@pezkuwi/dev-test/globals.d.ts" />
+
+/* eslint-disable @typescript-eslint/no-unsafe-member-access */
+
+import type { GenericEthereumAccountId as AccountId } from './AccountId.js';
+
+import { Raw } from '@pezkuwi/types-codec';
+
+import { TypeRegistry } from '../create/index.js';
+
+describe('EthereumAccountId', (): void => {
+  const registry = new TypeRegistry();
+
+  describe('defaults', (): void => {
+    const id = registry.createType('EthereumAccountId');
+
+    it('has a 20-byte length', (): void => {
+      expect(id).toHaveLength(20);
+    });
+
+    it('is empty by default', (): void => {
+      expect(id.isEmpty).toBe(true);
+    });
+
+    it('equals the empty address', (): void => {
+      expect(id.eq('0x0000000000000000000000000000000000000000')).toBe(true);
+    });
+  });
+
+  describe('decoding', (): void => {
+    const testDecode = (type: string, input: Uint8Array | string | AccountId, expected: string): void =>
+      it(`can decode from ${type}`, (): void => {
+        const a = registry.createType('EthereumAccountId', input);
+
+        expect(a.toString()).toBe(expected);
+      });
+
+    testDecode(
+      'AccountId',
+      registry.createType('EthereumAccountId', '0x4119b2e6c3Cb618F4f0B93ac77f9BeeC7FF02887'),
+      '0x4119b2e6c3Cb618F4f0B93ac77f9BeeC7FF02887'
+    );
+    testDecode('hex', '0x4119b2e6c3cb618f4f0B93ac77f9Beec7ff02887', '0x4119b2e6c3Cb618F4f0B93ac77f9BeeC7FF02887');
+    testDecode(
+      'Raw',
+      new Raw(registry, [
+        1, 2, 3, 4, 5, 6, 7, 8, 1, 2,
+        1, 2, 3, 4, 5, 6, 7, 8, 1, 2
+      ]),
+      '0x0102030405060708010201020304050607080102'
+    );
+    testDecode(
+      'Uint8Array',
+      Uint8Array.from([
+        1, 2, 3, 4, 5, 6, 7, 8, 1, 2,
+        1, 2, 3, 4, 5, 6, 7, 8, 1, 2
+      ]),
+      '0x0102030405060708010201020304050607080102'
+    );
+  });
+
+  describe('encoding', (): void => {
+    const testEncode = (to: 'toHex' | 'toJSON' | 'toString' | 'toU8a', expected: Uint8Array | string, input = '0x4119b2e6c3Cb618F4f0B93ac77f9BeeC7FF02887'): void =>
+      it(`can encode ${to}`, (): void => {
+        const a = registry.createType('EthereumAccountId', input);
+
+        expect(a[to]()).toEqual(expected);
+      });
+
+    testEncode('toHex', '0x4119b2e6c3cb618f4f0b93ac77f9beec7ff02887');
+    testEncode('toJSON', '0x4119b2e6c3Cb618F4f0B93ac77f9BeeC7FF02887');
+    testEncode('toString', '0x4119b2e6c3Cb618F4f0B93ac77f9BeeC7FF02887');
+    testEncode('toString', '0x0000000000000000000000000000000000000000', '0x0000000000000000000000000000000000000000');
+    testEncode('toU8a', Uint8Array.from([
+      0x41, 0x19, 0xb2, 0xe6, 0xc3, 0xcb, 0x61, 0x8f, 0x4f, 0x0b,
+      0x93, 0xac, 0x77, 0xf9, 0xbe, 0xec, 0x7f, 0xf0, 0x28, 0x87
+    ]));
+
+    it('decodes to a non-empty value', (): void => {
+      expect(registry.createType('EthereumAccountId', '0x4119b2e6c3Cb618F4f0B93ac77f9BeeC7FF02887').isEmpty).toBe(false);
+    });
+  });
+});

package/src/ethereum/AccountId.ts

@@ -0,0 +1,76 @@
+// Copyright 2017-2025 @polkadot/types authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+import type { AnyString, AnyU8a, Registry } from '@pezkuwi/types-codec/types';
+
+import { U8aFixed } from '@pezkuwi/types-codec';
+import { hexToU8a, isHex, isString, isU8a, u8aToU8a } from '@pezkuwi/util';
+import { ethereumEncode, isEthereumAddress } from '@pezkuwi/util-crypto';
+
+/** @internal */
+function decodeAccountId (value: AnyU8a | AnyString): AnyU8a {
+  if (isU8a(value) || Array.isArray(value)) {
+    return u8aToU8a(value);
+  } else if (isHex(value) || isEthereumAddress(value.toString())) {
+    return hexToU8a(value.toString());
+  } else if (isString(value)) {
+    return u8aToU8a(value);
+  }
+
+  return value;
+}
+
+/**
+ * @name GenericEthereumAccountId
+ * @description
+ * A wrapper around an Ethereum-compatible AccountId. Since we are dealing with
+ * underlying addresses (20 bytes in length), we extend from U8aFixed which is
+ * just a Uint8Array wrapper with a fixed length.
+ */
+export class GenericEthereumAccountId extends U8aFixed {
+  constructor (registry: Registry, value: AnyU8a = new Uint8Array()) {
+    super(registry, decodeAccountId(value), 160);
+  }
+
+  /**
+   * @description Compares the value of the input to see if there is a match
+   */
+  public override eq (other?: unknown): boolean {
+    return !!other && super.eq(decodeAccountId(other as AnyU8a));
+  }
+
+  /**
+   * @description Converts the Object to to a human-friendly JSON, with additional fields, expansion and formatting of information
+   */
+  public override toHuman (): string {
+    return this.toJSON();
+  }
+
+  /**
+   * @description Converts the Object to JSON, typically used for RPC transfers
+   */
+  public override toJSON (): string {
+    return this.toString();
+  }
+
+  /**
+   * @description Converts the value in a best-fit primitive form
+   */
+  public override toPrimitive (): string {
+    return this.toJSON();
+  }
+
+  /**
+   * @description Returns the string representation of the value
+   */
+  public override toString (): string {
+    return ethereumEncode(this);
+  }
+
+  /**
+   * @description Returns the base runtime type name for this instance
+   */
+  public override toRawType (): string {
+    return 'AccountId';
+  }
+}

package/src/ethereum/LookupSource.spec.ts

@@ -0,0 +1,107 @@
+// Copyright 2017-2025 @polkadot/types authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+/// <reference types="@pezkuwi/dev-test/globals.d.ts" />
+
+import type { GenericAccountIndex as AccountIndex } from '../generic/index.js';
+import type { GenericEthereumAccountId as AccountId, GenericEthereumLookupSource as Address } from './index.js';
+
+import { TypeRegistry } from '../create/index.js';
+
+describe('EthereumLookupSource', (): void => {
+  const registry = new TypeRegistry();
+
+  const testDecode = (type: string, input: Address | AccountId | AccountIndex | number[] | Uint8Array, expected: string): void =>
+    it(`can decode from ${type}`, (): void => {
+      const a = registry.createType('EthereumLookupSource', input);
+
+      expect(a.toString()).toBe(expected);
+    });
+
+  describe('decoding', (): void => {
+    testDecode(
+      'Address',
+      registry.createType('EthereumLookupSource', '0x00a329c0648769a73afac7f9381e08fb43dbea72'),
+      '0x00a329c0648769A73afAc7F9381E08FB43dBEA72'
+    );
+    testDecode(
+      'AccountId',
+      registry.createType('EthereumAccountId', '0x4119b2e6c3Cb618F4f0B93ac77f9BeeC7FF02887'),
+      '0x4119b2e6c3Cb618F4f0B93ac77f9BeeC7FF02887'
+    );
+    testDecode(
+      'AccountIndex (mixed prefixes)',
+      registry.createType('EthereumLookupSource', '118r'),
+      // NOTE Expected address here is encoded with prefix 42, input above with 1
+      '25GUyv'
+    );
+    testDecode(
+      'AccountIndex (hex)',
+      registry.createType('AccountIndex', '0x0100'),
+      '25GUyv'
+    );
+    testDecode(
+      'Uint8Array (with prefix 255)',
+      Uint8Array.from([
+        255,
+        0x41, 0x19, 0xb2, 0xe6, 0xc3, 0xcb, 0x61, 0x8f, 0x4f, 0x0b,
+        0x93, 0xac, 0x77, 0xf9, 0xbe, 0xec, 0x7f, 0xf0, 0x28, 0x87
+      ]),
+      '0x4119b2e6c3Cb618F4f0B93ac77f9BeeC7FF02887'
+    );
+    testDecode(
+      'Uint8Array (with prefix 1 byte)',
+      Uint8Array.from([1]),
+      'F7NZ'
+    );
+    testDecode(
+      'Uint8Array (with prefix 2 bytes)',
+      Uint8Array.from([0xfc, 0, 1]),
+      '25GUyv'
+    );
+    testDecode(
+      'Uint8Array (with prefix 4 bytes)',
+      Uint8Array.from([0xfd, 17, 18, 19, 20]),
+      'Mwz15xP2'
+    );
+  });
+
+  describe('encoding', (): void => {
+    const testEncode = (to: 'toHex' | 'toString' | 'toU8a', expected: string | Uint8Array): void =>
+      it(`can encode ${to}`, (): void => {
+        const a = registry.createType('EthereumLookupSource', '0x4119b2e6c3Cb618F4f0B93ac77f9BeeC7FF02887');
+
+        expect(a[to]()).toEqual(expected);
+      });
+
+    testEncode(
+      'toHex',
+      '0xff4119b2e6c3cb618f4f0b93ac77f9beec7ff02887'
+    );
+    testEncode(
+      'toString',
+      '0x4119b2e6c3Cb618F4f0B93ac77f9BeeC7FF02887'
+    );
+    testEncode(
+      'toU8a',
+      Uint8Array.from([
+        255,
+        0x41, 0x19, 0xb2, 0xe6, 0xc3, 0xcb, 0x61, 0x8f, 0x4f, 0x0b,
+        0x93, 0xac, 0x77, 0xf9, 0xbe, 0xec, 0x7f, 0xf0, 0x28, 0x87
+      ])
+    );
+  });
+
+  describe('utility', (): void => {
+    it('equals on AccountId', (): void => {
+      const addr = '0x4119b2e6c3Cb618F4f0B93ac77f9BeeC7FF02887';
+
+      expect(registry.createType('EthereumLookupSource', addr).eq(addr)).toBe(true);
+    });
+
+    it('equals on AccountIndex', (): void => {
+      // see the test below - these are equivalent (with different prefix encoding)
+      expect(registry.createType('EthereumLookupSource', '118r').eq('25GUyv')).toBe(true);
+    });
+  });
+});

package/src/ethereum/LookupSource.ts

@@ -0,0 +1,122 @@
+// Copyright 2017-2025 @polkadot/types authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+import type { Registry } from '@pezkuwi/types-codec/types';
+import type { BN } from '@pezkuwi/util';
+import type { HexString } from '@pezkuwi/util/types';
+
+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 { GenericAccountIndex } from '../generic/AccountIndex.js';
+import { GenericEthereumAccountId } from './AccountId.js';
+
+// eslint-disable-next-line no-use-before-define
+type AnyAddress = bigint | BN | GenericEthereumLookupSource | GenericEthereumAccountId | GenericAccountIndex | number[] | Uint8Array | number | string;
+
+export const ACCOUNT_ID_PREFIX = new Uint8Array([0xff]);
+
+/** @internal */
+function decodeString (registry: Registry, value: string): GenericEthereumAccountId | GenericAccountIndex {
+  const decoded = decodeAddress(value);
+
+  return decoded.length === 20
+    ? registry.createTypeUnsafe('EthereumAccountId', [decoded])
+    : registry.createTypeUnsafe('AccountIndex', [u8aToBn(decoded)]);
+}
+
+/** @internal */
+function decodeU8a (registry: Registry, value: Uint8Array): GenericEthereumAccountId | GenericAccountIndex {
+  // 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 === 20) {
+    return registry.createTypeUnsafe('EthereumAccountId', [value]);
+  } else if (value[0] === 0xff) {
+    return registry.createTypeUnsafe('EthereumAccountId', [value.subarray(1)]);
+  }
+
+  const [offset, length] = GenericAccountIndex.readLength(value);
+
+  return registry.createTypeUnsafe('AccountIndex', [u8aToBn(value.subarray(offset, offset + length))]);
+}
+
+function decodeAddressOrIndex (registry: Registry, value: AnyAddress): GenericEthereumAccountId | GenericAccountIndex {
+  return value instanceof GenericEthereumLookupSource
+    ? value.inner
+    : value instanceof GenericEthereumAccountId || value instanceof GenericAccountIndex
+      ? value
+      : isU8a(value) || Array.isArray(value) || isHex(value)
+        ? decodeU8a(registry, u8aToU8a(value))
+        : isBn(value) || isNumber(value) || isBigInt(value)
+          ? registry.createTypeUnsafe('AccountIndex', [value])
+          : decodeString(registry, value);
+}
+
+/**
+ * @name GenericEthereumLookupSource
+ * @description
+ * A wrapper around an EthereumAccountId 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 GenericEthereumLookupSource extends AbstractBase<GenericEthereumAccountId | GenericAccountIndex> {
+  constructor (registry: Registry, value: AnyAddress = new Uint8Array()) {
+    super(registry, decodeAddressOrIndex(registry, value));
+  }
+
+  /**
+   * @description The length of the value when encoded as a Uint8Array
+   */
+  public override get encodedLength (): number {
+    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
+   */
+  protected get _rawLength (): number {
+    return this.inner instanceof GenericAccountIndex
+      ? GenericAccountIndex.calcLength(this.inner)
+      : this.inner.encodedLength;
+  }
+
+  /**
+   * @description Returns a hex string representation of the value
+   */
+  public override toHex (): HexString {
+    return u8aToHex(this.toU8a());
+  }
+
+  /**
+   * @description Returns the base runtime type name for this instance
+   */
+  public override toRawType (): string {
+    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)
+   */
+  public override toU8a (isBare?: boolean): Uint8Array {
+    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/src/ethereum/index.ts

@@ -0,0 +1,5 @@
+// Copyright 2017-2025 @polkadot/types authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+export { GenericEthereumAccountId } from './AccountId.js';
+export { GenericEthereumLookupSource } from './LookupSource.js';

package/src/extrinsic/Extrinsic.spec.ts

@@ -0,0 +1,111 @@
+// Copyright 2017-2025 @polkadot/types authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+/// <reference types="@pezkuwi/dev-test/globals.d.ts" />
+
+import rpcMetadata from '@pezkuwi/types-support/metadata/static-substrate';
+
+import { TypeRegistry } from '../create/index.js';
+import { Metadata } from '../metadata/index.js';
+import { fallbackExtensions } from './signedExtensions/index.js';
+import { GenericExtrinsic as Extrinsic } from './index.js';
+
+const registry = new TypeRegistry();
+const metadata = new Metadata(registry, rpcMetadata);
+
+registry.setMetadata(metadata);
+
+describe('Extrinsic', (): void => {
+  describe('V4', (): void => {
+    it('decodes an actual transaction', (): void => {
+      registry.setSignedExtensions(fallbackExtensions);
+
+      const extrinsic = new Extrinsic(
+        registry,
+        '0x' +
+        '5d02' + // length
+        '84' + // V4, signing bit set
+        '00' + // MultiAddress, AccountId of sender follows
+        'fcc4910cb536b4333db4bccb40e2cf6427b4766518e754b91e70c97e4a87dbb3' + // sender
+        '00' + // multisig, type ed25519
+        'd99ffe3e610ad234e1414bda5831395a6df9098bf80b01561ce89a5065ae89d5' + // sig first 32
+        'c10e1619c6c99131b0bea4fb73ef04d07c07770e2ae9df5c325c331769ccb300' + // sig last 32
+        'a90b' + // mortal era
+        '1101' + // nonce, compact 68
+        '0700ac23fc06' + // tip, 0.03 KSM
+        '0600' + // balances.transferAllowDeath (on Kusama this was 0400, changed here to match metadata)
+        '00' + // MultiAddress, AccountId of recipient follows
+        '495e1e506f266418af07fa0c5c108dd436f2faa59fe7d9e54403779f5bbd7718' + // recipient
+        '0bc01eb1fc185f' // value, 104.560 KSM
+      );
+
+      expect(extrinsic.era.toHuman()).toEqual({ MortalEra: { period: '1,024', phase: '186' } });
+      expect(extrinsic.nonce.toNumber()).toEqual(68);
+      expect(extrinsic.tip.toHuman()).toEqual('30.0000 mUnit');
+      expect(extrinsic.callIndex).toEqual(new Uint8Array([6, 0]));
+      expect(extrinsic.args[0].toHex()).toEqual('0x00495e1e506f266418af07fa0c5c108dd436f2faa59fe7d9e54403779f5bbd7718');
+      expect(extrinsic.args[1].toHuman()).toEqual('104,560,923,320,000'); // ('104.5609 Unit');
+      expect(extrinsic.toPrimitive()).toEqual({ method: { args: { dest: { id: '5DiuK2zR4asj2CEh77SKtUgTswTLkD8eiAKrByg5G3wL5w9b' }, value: 104560923320000 }, callIndex: '0x0600' }, signature: { era: { mortalEra: [1024, 186] }, nonce: 68, signature: { ed25519: '0xd99ffe3e610ad234e1414bda5831395a6df9098bf80b01561ce89a5065ae89d5c10e1619c6c99131b0bea4fb73ef04d07c07770e2ae9df5c325c331769ccb300' }, signer: { id: '5Hn8KKEp8qruCGWaN9MEsjTs4FXB4wv9xn7g1RWkNeKKNXCr' }, tip: 30000000000 } });
+    });
+  });
+
+  describe('V5', () => {
+    // Ensure it does not have its registry modified by the fallback extensions.
+    const registry = new TypeRegistry();
+    const metadata = new Metadata(registry, rpcMetadata);
+
+    registry.setMetadata(metadata);
+
+    describe('SignedExtrinsic', () => {
+      it('Should error with a signed extrinsic, when the version is passed in', () => {
+        expect(() => new Extrinsic(
+          registry,
+          '0x51028500d43593c715fdd31c61141abd04a99fd6822c8558854ccde39a5684e7a56da27d011e0b7d9438899333c50121f8e10144952d51c3bb8d0ea11dd1f24940d8ff615ad351d95ed9f41f078748ed7cf182864a20b38eebfaef6629433365eb90c0148c007502000000000603008eaf04151687736326c9fea17e25fc5287613693c912909cb226aa4794f26a480b00a0724e1809',
+          { version: 5 }
+        )).toThrow('Signed Extrinsics are currently only available for ExtrinsicV4');
+      });
+
+      it('Should error when the version and preamble is not passed in, and its a signed extrinsic', () => {
+        expect(() => new Extrinsic(
+          registry,
+          '0x51028500d43593c715fdd31c61141abd04a99fd6822c8558854ccde39a5684e7a56da27d011e0b7d9438899333c50121f8e10144952d51c3bb8d0ea11dd1f24940d8ff615ad351d95ed9f41f078748ed7cf182864a20b38eebfaef6629433365eb90c0148c007502000000000603008eaf04151687736326c9fea17e25fc5287613693c912909cb226aa4794f26a480b00a0724e1809'
+        )).toThrow('Signed Extrinsics are currently only available for ExtrinsicV4');
+      });
+    });
+
+    describe('GeneralExtrinsic', () => {
+      it('Should work when the version and preamble is passed in', () => {
+        const extrinsic = new Extrinsic(
+          registry,
+          '0xc44500650000000000060000d43593c715fdd31c61141abd04a99fd6822c8558854ccde39a5684e7a56da27d0700e40b5402',
+          { preamble: 'general', version: 5 }
+        );
+
+        expect(extrinsic.version).toEqual(69);
+        // expect(extrinsic.transactionExtensionVersion.toNumber()).toEqual(0);
+        expect(extrinsic.method.toHuman()).toEqual({ args: { dest: { Id: '5GrwvaEF5zXb26Fz9rcQpDWS57CtERHpNehXCPcNoHGKutQY' }, value: '10,000,000,000' }, method: 'transferAllowDeath', section: 'balances' });
+        expect(extrinsic.era.toHuman()).toEqual({ MortalEra: { period: '64', phase: '6' } });
+        expect(extrinsic.tip.toNumber()).toEqual(0);
+        expect(extrinsic.mode.toNumber()).toEqual(0);
+        expect(extrinsic.assetId.toHuman()).toEqual(null);
+        expect(extrinsic.nonce.toNumber()).toEqual(0);
+      });
+
+      it('Should work when there is no version and preamble is passed in', () => {
+        const extrinsic = new Extrinsic(
+          registry,
+          '0xc44500650000000000060000d43593c715fdd31c61141abd04a99fd6822c8558854ccde39a5684e7a56da27d0700e40b5402'
+        );
+
+        expect(extrinsic.version).toEqual(69);
+        // expect(extrinsic.transactionExtensionVersion.toNumber()).toEqual(0);
+        expect(extrinsic.method.toHuman()).toEqual({ args: { dest: { Id: '5GrwvaEF5zXb26Fz9rcQpDWS57CtERHpNehXCPcNoHGKutQY' }, value: '10,000,000,000' }, method: 'transferAllowDeath', section: 'balances' });
+        expect(extrinsic.era.toHuman()).toEqual({ MortalEra: { period: '64', phase: '6' } });
+        expect(extrinsic.tip.toNumber()).toEqual(0);
+        expect(extrinsic.mode.toNumber()).toEqual(0);
+        expect(extrinsic.assetId.toHuman()).toEqual(null);
+        expect(extrinsic.nonce.toNumber()).toEqual(0);
+      });
+    });
+  });
+});