@pezkuwi/types 16.5.5

package/src/extrinsic/v5/ExtrinsicSignature.ts

@@ -0,0 +1,200 @@
+// Copyright 2017-2025 @polkadot/types authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+import type { MultiLocation } from '@pezkuwi/types/interfaces';
+import type { HexString } from '@pezkuwi/util/types';
+import type { EcdsaSignature, Ed25519Signature, ExtrinsicEra, ExtrinsicSignature, Sr25519Signature } from '../../interfaces/extrinsics/index.js';
+import type { Address, Call, Hash } from '../../interfaces/runtime/index.js';
+import type { ExtrinsicPayloadValue, ICompact, IExtrinsicSignature, IKeyringPair, INumber, IOption, Registry, SignatureOptions } from '../../types/index.js';
+import type { ExtrinsicSignatureOptions } from '../types.js';
+
+import { Struct } from '@pezkuwi/types-codec';
+import { objectProperties, objectSpread } from '@pezkuwi/util';
+
+import { EMPTY_U8A, IMMORTAL_ERA } from '../constants.js';
+import { GenericExtrinsicPayloadV5 } from './ExtrinsicPayload.js';
+
+/**
+ * @name GenericExtrinsicSignatureV5
+ * @description
+ * A container for the [[Signature]] associated with a specific [[Extrinsic]]
+ */
+export class GenericExtrinsicSignatureV5 extends Struct implements IExtrinsicSignature {
+  #signKeys: string[];
+
+  constructor (registry: Registry, value?: GenericExtrinsicSignatureV5 | Uint8Array, { isSigned }: ExtrinsicSignatureOptions = {}) {
+    const signTypes = registry.getSignedExtensionTypes();
+
+    super(
+      registry,
+      objectSpread(
+        // eslint-disable-next-line sort-keys
+        { signer: 'Address', signature: 'ExtrinsicSignature', transactionExtensionVersion: 'u8' },
+        signTypes
+      ),
+      GenericExtrinsicSignatureV5.decodeExtrinsicSignature(value, isSigned)
+    );
+
+    this.#signKeys = Object.keys(signTypes);
+
+    objectProperties(this, this.#signKeys, (k) => this.get(k));
+  }
+
+  /** @internal */
+  public static decodeExtrinsicSignature (value?: GenericExtrinsicSignatureV5 | Uint8Array, isSigned = false): GenericExtrinsicSignatureV5 | Uint8Array {
+    if (!value) {
+      return EMPTY_U8A;
+    } else if (value instanceof GenericExtrinsicSignatureV5) {
+      return value;
+    }
+
+    return isSigned
+      ? value
+      : EMPTY_U8A;
+  }
+
+  /**
+   * @description The length of the value when encoded as a Uint8Array
+   */
+  public override get encodedLength (): number {
+    return this.isSigned
+      ? super.encodedLength
+      : 0;
+  }
+
+  /**
+   * @description `true` if the signature is valid
+   */
+  public get isSigned (): boolean {
+    return !this.signature.isEmpty;
+  }
+
+  /**
+   * @description The [[ExtrinsicEra]] (mortal or immortal) this signature applies to
+   */
+  public get era (): ExtrinsicEra {
+    return this.getT('era');
+  }
+
+  /**
+   * @description The [[Index]] for the signature
+   */
+  public get nonce (): ICompact<INumber> {
+    return this.getT('nonce');
+  }
+
+  /**
+   * @description The actual [[EcdsaSignature]], [[Ed25519Signature]] or [[Sr25519Signature]]
+   */
+  public get signature (): EcdsaSignature | Ed25519Signature | Sr25519Signature {
+    // the second case here is when we don't have an enum signature, treat as raw
+    return (this.multiSignature.value || this.multiSignature) as Sr25519Signature;
+  }
+
+  /**
+   * @description The raw [[ExtrinsicSignature]]
+   */
+  public get multiSignature (): ExtrinsicSignature {
+    return this.getT('signature');
+  }
+
+  /**
+   * @description The [[Address]] that signed
+   */
+  public get signer (): Address {
+    return this.getT('signer');
+  }
+
+  /**
+   * @description The [[Balance]] tip
+   */
+  public get tip (): ICompact<INumber> {
+    return this.getT('tip');
+  }
+
+  /**
+   * @description The [[u32]] or [[MultiLocation]] assetId
+   */
+  public get assetId (): IOption<INumber | MultiLocation> {
+    return this.getT('assetId');
+  }
+
+  /**
+   * @description the [[u32]] mode
+   */
+  public get mode (): INumber {
+    return this.getT('mode');
+  }
+
+  /**
+   * @description The (optional)  [[Hash]] for the metadata proof
+   */
+  public get metadataHash (): IOption<Hash> {
+    return this.getT('metadataHash');
+  }
+
+  /**
+   * @description The [[u8]] for the TransactionExtension version
+   */
+  public get transactionExtensionVersion (): INumber {
+    return this.getT('transactionExtensionVersion');
+  }
+
+  /**
+   * [Disabled for ExtrinsicV5]
+   */
+  protected _injectSignature (_signer: Address, _signature: ExtrinsicSignature, _payload: GenericExtrinsicPayloadV5): IExtrinsicSignature {
+    throw new Error('Extrinsic: ExtrinsicV5 does not include signing support');
+  }
+
+  /**
+   * @description Adds a raw signature
+   *
+   * [Disabled for ExtrinsicV5]
+   */
+  public addSignature (_signer: Address | Uint8Array | string, _signature: Uint8Array | HexString, _payload: ExtrinsicPayloadValue | Uint8Array | HexString): IExtrinsicSignature {
+    throw new Error('Extrinsic: ExtrinsicV5 does not include signing support');
+  }
+
+  /**
+   * @description Creates a payload from the supplied options
+   */
+  public createPayload (method: Call, options: SignatureOptions): GenericExtrinsicPayloadV5 {
+    const { era, runtimeVersion: { specVersion, transactionVersion } } = options;
+
+    return new GenericExtrinsicPayloadV5(this.registry, objectSpread<ExtrinsicPayloadValue>({}, options, {
+      era: era || IMMORTAL_ERA,
+      method: method.toHex(),
+      specVersion,
+      transactionVersion
+    }));
+  }
+
+  /**
+   * @description Generate a payload and applies the signature from a keypair
+   *
+   * [Disabled for ExtrinsicV5]
+   */
+  public sign (_method: Call, _account: IKeyringPair, _options: SignatureOptions): IExtrinsicSignature {
+    throw new Error('Extrinsic: ExtrinsicV5 does not include signing support');
+  }
+
+  /**
+   * @description Generate a payload and applies a fake signature
+   *
+   * [Disabled for ExtrinsicV5]
+   */
+  public signFake (_method: Call, _address: Address | Uint8Array | string, _options: SignatureOptions): IExtrinsicSignature {
+    throw new Error('Extrinsic: ExtrinsicV5 does not include signing support');
+  }
+
+  /**
+   * @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 {
+    return this.isSigned
+      ? super.toU8a(isBare)
+      : EMPTY_U8A;
+  }
+}

package/src/extrinsic/v5/GeneralExtrinsic.spec.ts

@@ -0,0 +1,47 @@
+// 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 { GeneralExtrinsic } from './GeneralExtrinsic.js';
+
+const registry = new TypeRegistry();
+const metadata = new Metadata(registry, rpcMetadata);
+
+registry.setMetadata(metadata);
+
+describe('GeneralExt', (): void => {
+  const extrinsic = '0xc44500650000000000060000d43593c715fdd31c61141abd04a99fd6822c8558854ccde39a5684e7a56da27d0700e40b5402';
+
+  it('Can decode a general extrinsic', (): void => {
+    const genExt = new GeneralExtrinsic(registry, extrinsic);
+
+    expect(genExt.version).toEqual(5);
+    expect(genExt.transactionExtensionVersion.toNumber()).toEqual(0);
+    expect(genExt.method.toHuman()).toEqual({ args: { dest: { Id: '5GrwvaEF5zXb26Fz9rcQpDWS57CtERHpNehXCPcNoHGKutQY' }, value: '10,000,000,000' }, method: 'transferAllowDeath', section: 'balances' });
+    expect(genExt.era.toHuman()).toEqual({ MortalEra: { period: '64', phase: '6' } });
+    expect(genExt.tip.toNumber()).toEqual(0);
+    expect(genExt.mode.toNumber()).toEqual(0);
+    expect(genExt.assetId.toHuman()).toEqual(null);
+    expect(genExt.nonce.toNumber()).toEqual(0);
+  });
+
+  it('Can encode a general extrinsic', (): void => {
+    const payload = {
+      era: '0x6500',
+      method: '0x060000d43593c715fdd31c61141abd04a99fd6822c8558854ccde39a5684e7a56da27d0700e40b5402',
+      nonce: '0x00000000',
+      tip: '0x00000000000000000000000000000000',
+      transactionVersion: '0x00000002'
+    };
+    const genExt = new GeneralExtrinsic(registry, {
+      payload
+    });
+
+    expect(genExt.toHex()).toEqual(extrinsic);
+  });
+});

package/src/extrinsic/v5/GeneralExtrinsic.ts

@@ -0,0 +1,208 @@
+// Copyright 2017-2025 @polkadot/types authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+import type { Call, ExtrinsicEra, Hash, MultiLocation } from '@pezkuwi/types/interfaces';
+import type { AnyNumber, AnyU8a, ICompact, IExtrinsicEra, INumber, IOption, Registry } from '@pezkuwi/types/types';
+import type { AnyTuple, IMethod } from '@pezkuwi/types-codec/types';
+import type { HexString } from '@pezkuwi/util/types';
+
+import { Struct } from '@pezkuwi/types-codec';
+import { compactAddLength, compactFromU8a, isHex, isObject, isU8a, objectSpread, u8aConcat, u8aToHex, u8aToU8a } from '@pezkuwi/util';
+
+import { EMPTY_U8A, UNMASK_VERSION } from '../constants.js';
+
+interface TransactionExtensionValues {
+  era: AnyU8a | IExtrinsicEra;
+  nonce: AnyNumber;
+  tip: AnyNumber;
+  transactionVersion: AnyNumber;
+  assetId?: HexString;
+  mode?: AnyNumber;
+  metadataHash?: AnyU8a;
+}
+
+interface GeneralExtrinsicPayloadValues extends TransactionExtensionValues {
+  method: AnyU8a | IMethod<AnyTuple>;
+}
+
+interface GeneralExtrinsicValue {
+  payload?: GeneralExtrinsicPayloadValues;
+  transactionExtensionVersion?: number;
+}
+
+function decodeU8a (u8a: Uint8Array) {
+  if (!u8a.length) {
+    return new Uint8Array();
+  }
+
+  const [offset, length] = compactFromU8a(u8a);
+  const total = offset + length.toNumber();
+
+  if (total > u8a.length) {
+    throw new Error(`Extrinsic: length less than remainder, expected at least ${total}, found ${u8a.length}`);
+  }
+
+  const data = u8a.subarray(offset, total);
+
+  // 69 denotes 0b01000101 which is the version and preamble for this Extrinsic
+  if (data[0] !== 69) {
+    throw new Error(`Extrinsic: incorrect version for General Transactions, expected 5, found ${data[0] & UNMASK_VERSION}`);
+  }
+
+  return data.subarray(1);
+}
+
+export class GeneralExtrinsic extends Struct {
+  #version: number;
+  #preamble: number;
+
+  constructor (registry: Registry, value?: GeneralExtrinsicValue | Uint8Array | HexString, opt?: { version: number }) {
+    const extTypes = registry.getSignedExtensionTypes();
+
+    super(registry, objectSpread(
+      {
+        transactionExtensionVersion: 'u8'
+      },
+      extTypes,
+      {
+        method: 'Call'
+      }
+    ), GeneralExtrinsic.decodeExtrinsic(registry, value));
+
+    this.#version = opt?.version || 0b00000101;
+    this.#preamble = 0b01000000;
+  }
+
+  public static decodeExtrinsic (registry: Registry, value?: GeneralExtrinsicValue | Uint8Array | HexString) {
+    if (!value) {
+      return EMPTY_U8A;
+    } else if (value instanceof GeneralExtrinsic) {
+      return value;
+    } else if (isU8a(value) || Array.isArray(value) || isHex(value)) {
+      return decodeU8a(u8aToU8a(value));
+    } else if (isObject(value)) {
+      const { payload, transactionExtensionVersion } = value;
+
+      return objectSpread(payload || {}, {
+        transactionExtensionVersion: transactionExtensionVersion || registry.getTransactionExtensionVersion()
+      });
+    }
+
+    return {};
+  }
+
+  /**
+   * @description The length of the value when encoded as a Uint8Array
+   */
+  public override get encodedLength (): number {
+    return super.encodedLength;
+  }
+
+  /**
+   * @description The [[ExtrinsicEra]]
+   */
+  public get era (): ExtrinsicEra {
+    return this.getT('era');
+  }
+
+  /**
+   * @description The [[Index]]
+   */
+  public get nonce (): ICompact<INumber> {
+    return this.getT('nonce');
+  }
+
+  /**
+   * @description The tip [[Balance]]
+   */
+  public get tip (): ICompact<INumber> {
+    return this.getT('tip');
+  }
+
+  /**
+   * @description The (optional) asset id for this signature for chains that support transaction fees in assets
+   */
+  public get assetId (): IOption<INumber | MultiLocation> {
+    return this.getT('assetId');
+  }
+
+  /**
+   * @description The mode used for the CheckMetadataHash TransactionExtension
+   */
+  public get mode (): INumber {
+    return this.getT('mode');
+  }
+
+  /**
+   * @description The (optional) [[Hash]] for the metadata proof
+   */
+  public get metadataHash (): IOption<Hash> {
+    return this.getT('metadataHash');
+  }
+
+  /**
+   * @description The version of the TransactionExtensions used in this extrinsic
+   */
+  public get transactionExtensionVersion (): INumber {
+    return this.getT('transactionExtensionVersion');
+  }
+
+  /**
+   * @description The [[Call]] this extrinsic wraps
+   */
+  public get method (): Call {
+    return this.getT('method');
+  }
+
+  /**
+   * @description The extrinsic's version
+   */
+  public get version () {
+    return this.#version;
+  }
+
+  /**
+   * @description The [[Preamble]] for the extrinsic
+   */
+  public get preamble () {
+    return this.#preamble;
+  }
+
+  public override toHex (isBare?: boolean): HexString {
+    return u8aToHex(this.toU8a(isBare));
+  }
+
+  public override toU8a (isBare?: boolean): Uint8Array {
+    return isBare
+      ? this.encode()
+      : compactAddLength(this.encode());
+  }
+
+  public override toRawType () {
+    return 'GeneralExt';
+  }
+
+  /**
+   *
+   * @description Returns an encoded GeneralExtrinsic
+   */
+  public encode () {
+    return u8aConcat(new Uint8Array([this.version | this.preamble]), super.toU8a());
+  }
+
+  public signFake () {
+    throw new Error('Extrinsic: Type GeneralExtrinsic does not have signFake implemented');
+  }
+
+  public addSignature () {
+    throw new Error('Extrinsic: Type GeneralExtrinsic does not have addSignature implemented');
+  }
+
+  public sign () {
+    throw new Error('Extrinsic: Type GeneralExtrinsic does not have sign implemented');
+  }
+
+  public signature () {
+    throw new Error('Extrinsic: Type GeneralExtrinsic does not have the signature getter');
+  }
+}

package/src/extrinsic/v5/index.ts

@@ -0,0 +1,7 @@
+// Copyright 2017-2025 @polkadot/types authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+export { GenericExtrinsicV5 } from './Extrinsic.js';
+export { GenericExtrinsicPayloadV5 } from './ExtrinsicPayload.js';
+export { GenericExtrinsicSignatureV5 } from './ExtrinsicSignature.js';
+export { GeneralExtrinsic } from './GeneralExtrinsic.js';

package/src/generic/AccountId.spec.ts

@@ -0,0 +1,179 @@
+// 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 { Raw } from '@pezkuwi/types-codec';
+import jsonVec from '@pezkuwi/types-support/json/AccountIdVec.001.json' assert { type: 'json' };
+
+import { TypeRegistry } from '../create/index.js';
+
+describe('AccountId', (): void => {
+  const registry = new TypeRegistry();
+
+  describe('defaults', (): void => {
+    const id = registry.createType('AccountId');
+
+    it('has a 32-byte length', (): void => {
+      expect(id).toHaveLength(32);
+    });
+
+    it('is empty by default', (): void => {
+      expect(id.isEmpty).toBe(true);
+    });
+
+    it('equals the empty address', (): void => {
+      expect(id.eq('5C4hrfjw9DjXZTzV3MwzrrAr9P1MJhSrvWGWqi1eSuyUpnhM')).toBe(true);
+    });
+
+    it('allows decoding from null', (): void => {
+      expect(
+        registry
+          .createType('AccountId', null)
+          .eq('5C4hrfjw9DjXZTzV3MwzrrAr9P1MJhSrvWGWqi1eSuyUpnhM')
+      ).toBe(true);
+    });
+  });
+
+  describe('decoding', (): void => {
+    const testDecode = (type: string, input: Uint8Array | string, expected: string, createType = 'AccountId'): void =>
+      it(`can decode from ${type}`, (): void => {
+        expect(
+          registry
+            .createType(createType, input)
+            .toString()
+        ).toBe(expected);
+      });
+
+    it('fails with non-32-byte lengths', (): void => {
+      expect(
+        () => registry.createType('AccountId', '0x1234')
+      ).toThrow(/Invalid AccountId provided, expected 32 bytes/);
+    });
+
+    it('correctly encodes for AccountId32', (): void => {
+      const s = '5CHCWUYMmDGeJjiuaQ1LnrsAWacDhiTAV6vCfytSxoqBdCCb';
+      const h = '0x0987654309876543098765430987654309876543098765430987654309876543';
+      const a = registry.createType('AccountId32', s);
+
+      expect(a).toHaveLength(32);
+      expect(a.toHex()).toEqual(h);
+      expect(a.toString()).toEqual(s);
+      expect(registry.createType('AccountId32', h).toString()).toEqual(s);
+    });
+
+    it('correctly encodes for AccountId33', (): void => {
+      const s = 'KWnVo6ZQe9A3fHZy4QYWMR6QyZLT4hxUs37pX465bKhfsMobh';
+      const h = '0x098765430987654309876543098765430987654309876543098765430987654309';
+      const a = registry.createType('AccountId33', s);
+
+      expect(a).toHaveLength(33);
+      expect(a.toHex()).toEqual(h);
+      expect(a.toString()).toEqual(s);
+      expect(registry.createType('AccountId33', h).toString()).toEqual(s);
+    });
+
+    testDecode(
+      'AccountId',
+      registry.createType('AccountId', '0x0102030405060708010203040506070801020304050607080102030405060708'),
+      '5C62W7ELLAAfix9LYrcx5smtcffbhvThkM5x7xfMeYXCtGwF'
+    );
+    testDecode(
+      'AccountId33',
+      registry.createType('AccountId33', '0x098765430987654309876543098765430987654309876543098765430987654309'),
+      'KWnVo6ZQe9A3fHZy4QYWMR6QyZLT4hxUs37pX465bKhfsMobh',
+      'AccountId33'
+    );
+    testDecode('hex', '0x0102030405060708010203040506070801020304050607080102030405060708', '5C62W7ELLAAfix9LYrcx5smtcffbhvThkM5x7xfMeYXCtGwF');
+    testDecode('string', '5C62W7ELLAAfix9LYrcx5smtcffbhvThkM5x7xfMeYXCtGwF', '5C62W7ELLAAfix9LYrcx5smtcffbhvThkM5x7xfMeYXCtGwF');
+    testDecode(
+      'Raw',
+      new Raw(registry, [
+        1, 2, 3, 4, 5, 6, 7, 8, 1, 2, 3, 4, 5, 6, 7, 8,
+        1, 2, 3, 4, 5, 6, 7, 8, 1, 2, 3, 4, 5, 6, 7, 8
+      ]),
+      '5C62W7ELLAAfix9LYrcx5smtcffbhvThkM5x7xfMeYXCtGwF'
+    );
+    testDecode(
+      'Uint8Array',
+      Uint8Array.from([
+        1, 2, 3, 4, 5, 6, 7, 8, 1, 2, 3, 4, 5, 6, 7, 8,
+        1, 2, 3, 4, 5, 6, 7, 8, 1, 2, 3, 4, 5, 6, 7, 8
+      ]),
+      '5C62W7ELLAAfix9LYrcx5smtcffbhvThkM5x7xfMeYXCtGwF'
+    );
+  });
+
+  describe('encoding', (): void => {
+    const testEncode = (to: 'toHex' | 'toJSON' | 'toString' | 'toU8a', expected: Uint8Array | string, input = '5C62W7ELLAAfix9LYrcx5smtcffbhvThkM5x7xfMeYXCtGwF'): void =>
+      it(`can encode ${to}`, (): void => {
+        expect(
+          registry.createType('AccountId', input)[to]()
+        ).toEqual(expected);
+      });
+
+    testEncode('toHex', '0x0102030405060708010203040506070801020304050607080102030405060708');
+    testEncode('toJSON', '5C62W7ELLAAfix9LYrcx5smtcffbhvThkM5x7xfMeYXCtGwF');
+    testEncode('toString', '5C62W7ELLAAfix9LYrcx5smtcffbhvThkM5x7xfMeYXCtGwF');
+    testEncode('toString', '5C4hrfjw9DjXZTzV3MwzrrAr9P1MJhSrvWGWqi1eSuyUpnhM', '0x0000000000000000000000000000000000000000000000000000000000000000');
+    testEncode('toU8a', Uint8Array.from([
+      1, 2, 3, 4, 5, 6, 7, 8, 1, 2, 3, 4, 5, 6, 7, 8,
+      1, 2, 3, 4, 5, 6, 7, 8, 1, 2, 3, 4, 5, 6, 7, 8
+    ]));
+
+    it('decodes to a non-empty value', (): void => {
+      expect(
+        registry
+          .createType('AccountId', 'FVU8T5yaAssHAUwo3PnKso7fqNthEqJZGCZgJZSR9cKjWAf')
+          .isEmpty
+      ).toBe(false);
+    });
+
+    it('encodes a 2-byte key correctly', (): void => {
+      const registry = new TypeRegistry();
+
+      registry.setChainProperties(
+        registry.createType('ChainProperties', {
+          ss58Format: 252
+        })
+      );
+
+      expect(
+        registry
+          .createType('AccountId', '0x5c64f1151f0ce4358c27238fb20c88e7c899825436f565410724c8c2c5add869')
+          .toString()
+      ).toEqual('xw5g1Eec8LT99pZLZMaTWwrwvNtfM6vrSuZeVbtEszCDUwByg');
+    });
+  });
+
+  describe('storage decoding', (): void => {
+    it('has the correct entries', (): void => {
+      const registry = new TypeRegistry();
+
+      registry.setChainProperties(
+        registry.createType('ChainProperties', {
+          ss58Format: 2
+        })
+      );
+
+      const data = registry.createType('StorageData', jsonVec.params.result.changes[0][1]);
+
+      expect(
+        registry
+          .createType('Vec<AccountId>', data)
+          .map((accountId) => accountId.toString())
+      ).toEqual([
+        'FXmrFbdg2VdG1NttGTx1S6Czbv2SQ7PaD2PfryGBWWgt52i',
+        'ELSnAoxwXaRP5i4RPjs6m1K3AGVCfXpt8GjTcrgtxvrAuZv',
+        'EaoT1Mn6H3N9Ui3WdiLGTdKgjGChbrpLfnNV5zSLJLhZvgj',
+        'FVU8T5yaAssHAUwo3PnKso7fqNthEqJZGCZgJZSR9cKjWAf',
+        'GCgYfZti2kHwWoixFJ9toWZPZrcesc8CZDAoBGhiUNKvTQM',
+        'DMYFwYVNgLqpiD73eoLEMLnzszXyEnvhxL1bPGhSGXKV8kS',
+        'CfdSPZKSb529oMZ9HeFw6p9fhiGS6i45FEgFaJazhmBzsxZ',
+        'DNaSBo4xxQMjwbhAZwSzaK8taaBTKVXtnNygqYUpXS4FMwN'
+      ]);
+    });
+  });
+});