Merge pull request #974 from ava-labs/raj/warp-l1-validator

feat: warp codec for l1 validator messages

Author: rajranjan0608

examples/warp/l1ValidatorWeightMessage.ts

@@ -0,0 +1,45 @@
+import { utils } from '../../src';
+import { pvmSerial } from '../../src/serializable';
+
+/**
+ * Structure of the message:
+ * WarpSignedMessage
+ *  - WarpUnsignedMessage
+ *    - NetworkId
+ *    - SourceChainId
+ *    - AddressedCallPayload
+ *      - SourceAddress
+ *      - L1ValidatorWeightMessage
+ *  - BitSet Signatures
+ */
+
+// Ref: See tx hash (on Fuji - PChain) zphUhqvXtj8dkYxg2BqCdTPDUPWBJUQkb1XTp38u8zDZ9VjMW
+const signedWarpMsgHex =
+  '0000000000056b804f574b890cf9e0cb0f0f68591a394bba1696cf62b4e576e793d8509cc88600000058000000000001000000140feedc0de0000000000000000000000000000000000000360000000000038ccf9ef520784d2fa5d97fbf098b8b4e82ff19408ec423c2970a522ab04b3a0400000000000000040000000000000029000000000000000106a8206d76cf3fa7d65fec8464b0311dce9283d05bcf0ca7987cdf03a3a2f764691e01df4f6aaa3ff6b52e5b92fd3291e519f3fb50bad5d9697a39e34e2c3e99ea585f0332e9d13b4b6db7ecc58eee44c7f96e64371b1eebaa6f7c45bbf0937e68';
+
+const warpManager = pvmSerial.warp.getWarpManager();
+
+const parsedWarpMsg = warpManager.unpack(
+  utils.hexToBuffer(signedWarpMsgHex),
+  pvmSerial.warp.WarpMessage,
+);
+
+console.log('Network ID:', parsedWarpMsg.unsignedMessage.networkId.value());
+console.log(
+  'Source Chain ID:',
+  parsedWarpMsg.unsignedMessage.sourceChainId.value(),
+);
+
+const addressedCall = warpManager.unpack(
+  parsedWarpMsg.unsignedMessage.payload.bytes,
+  pvmSerial.warp.AddressedCallPayloads.AddressedCall,
+);
+
+console.log('Source Address:', addressedCall.getSourceAddress());
+
+const l1VldrWeightMsg = warpManager.unpack(
+  addressedCall.payload.bytes,
+  pvmSerial.warp.AddressedCallPayloads.L1ValidatorWeightMessage,
+);
+
+console.log(l1VldrWeightMsg);

examples/warp/registerL1ValidatorMessage.ts

@@ -0,0 +1,45 @@
+import { utils } from '../../src';
+import { pvmSerial } from '../../src/serializable';
+
+/**
+ * Structure of the message:
+ * WarpSignedMessage
+ *  - WarpUnsignedMessage
+ *    - NetworkId
+ *    - SourceChainId
+ *    - AddressedCallPayload
+ *      - SourceAddress
+ *      - RegisterL1ValidatorMessage
+ *  - BitSet Signatures
+ */
+
+// Ref: See tx hash (on Fuji - PChain) qKx5qy1zriGsWGhnRfHibE9kuDSUMfQV7gPQVCQ8iBKT5ZriV
+const signedWarpMsgHex =
+  '0x0000000000057f78fe8ca06cefa186ef29c15231e45e1056cd8319ceca0695ca61099e610355000000d80000000000010000001433b9785e20ec582d5009965fb3346f1716e8a423000000b60000000000015e8b6e2e8155e93739f2fa6a7f8a32c6bb2e1dce2e471b56dcc60aac49bf34350000001447b37278e32917ffc6d2861b50dd9751b4016dd1b0d305fd70c376b0f5d4e6b9184728dcacb7390f477015690133a5632affab5701e9ebe61038d2e41373de53f4569fd60000000067d1ac310000000100000001380c1fb1db38f176b50e77eca240258e31a5b5e80000000100000001380c1fb1db38f176b50e77eca240258e31a5b5e80000000000004e200000000000000003c4411899be0450aee4dcc1be90a8802bdbd12821a5025a74cb094ff0033982e7f3951d6c4b882a6ce39bd2aa835b31accd09c60f26bc75308af4e05c4237df9b72b04c2697c5a0a7fb0f05f7b09358743a4a2df8cd4eda61f0dea0312a7014baa8a5c1';
+
+const warpManager = pvmSerial.warp.getWarpManager();
+
+const parsedWarpMsg = warpManager.unpack(
+  utils.hexToBuffer(signedWarpMsgHex),
+  pvmSerial.warp.WarpMessage,
+);
+
+console.log('Network ID:', parsedWarpMsg.unsignedMessage.networkId.value());
+console.log(
+  'Source Chain ID:',
+  parsedWarpMsg.unsignedMessage.sourceChainId.value(),
+);
+
+const addressedCall = warpManager.unpack(
+  parsedWarpMsg.unsignedMessage.payload.bytes,
+  pvmSerial.warp.AddressedCallPayloads.AddressedCall,
+);
+
+console.log('Source Address:', addressedCall.getSourceAddress());
+
+const registerL1ValidatorMsg = warpManager.unpack(
+  addressedCall.payload.bytes,
+  pvmSerial.warp.AddressedCallPayloads.RegisterL1ValidatorMessage,
+);
+
+console.log(registerL1ValidatorMsg);

src/fixtures/primitives.ts

@@ -1,6 +1,8 @@
+import { BlsPublicKey } from '../serializable/fxs/common/blsPublicKey';
 import { BlsSignature } from '../serializable/fxs/common/blsSignature';
 import {
   BigIntPr,
+  Bool,
   Byte,
   Bytes,
   Int,
@@ -19,6 +21,10 @@ export const intsBytes = () =>
 
 export const ints = () => [new Int(3), new Int(2), new Int(1)];
 
+export const boolBytes = (val = true) => new Uint8Array([val ? 0x01 : 0x00]);
+
+export const bool = (val = true) => new Bool(val);
+
 export const byteByte = () => new Uint8Array([0x01]);
 
 export const byte = () => new Byte(new Uint8Array([0x01]));
@@ -50,6 +56,9 @@ export const blsPublicKeyBytes = () =>
     0xde, 0xc9, 0x50, 0x40, 0x30, 0x9a, 0xd1, 0xf1, 0x58, 0x95, 0x30, 0x67,
   ]);
 
+export const blsPublicKey = () =>
+  BlsPublicKey.fromBytes(blsPublicKeyBytes())[0];
+
 export const blsSignatureBytes = () =>
   new Uint8Array([
     0x8b, 0x1d, 0x61, 0x33, 0xd1, 0x7e, 0x34, 0x83, 0x22, 0x0a, 0xd9, 0x60,

src/fixtures/warp.ts

@@ -1,18 +1,42 @@
+import { Int } from '../serializable/primitives';
 import {
   WarpMessage,
   WarpSignature,
   WarpUnsignedMessage,
 } from '../serializable/pvm/warp';
+import {
+  AddressedCall,
+  L1ValidatorWeightMessage,
+} from '../serializable/pvm/warp/addressedCall';
+import { L1ValidatorRegistrationMessage } from '../serializable/pvm/warp/addressedCall/messages/l1ValidatorRegistrationMessage';
+import { RegisterL1ValidatorMessage } from '../serializable/pvm/warp/addressedCall/messages/registerL1ValidatorMessage';
+import { SubnetToL1ConversionMessage } from '../serializable/pvm/warp/addressedCall/messages/subnetToL1ConversionMessage';
+import { ConversionData } from '../serializable/pvm/warp/addressedCall/utils/conversionData';
+import { ValidatorData } from '../serializable/pvm/warp/addressedCall/utils/validatorData';
 import { concatBytes } from '../utils';
-import { id, idBytes } from './common';
 import {
+  address,
+  addressBytes,
+  id,
+  idBytes,
+  nodeId,
+  nodeIdBytes,
+} from './common';
+import {
+  bigIntPr,
+  bigIntPrBytes,
+  blsPublicKey,
+  blsPublicKeyBytes,
   blsSignature,
   blsSignatureBytes,
+  bool,
+  boolBytes,
   bytes,
   bytesBytes,
   int,
   intBytes,
 } from './primitives';
+import { pChainOwner, pChainOwnerBytes } from './pvm';
 import { bytesForInt } from './utils/bytesFor';
 
 export const warpUnsignedMessage = () =>
@@ -31,3 +55,92 @@ export const warpMessage = () =>
 
 export const warpMessageBytes = () =>
   concatBytes(warpUnsignedMessageBytes(), bytesForInt(0), warpSignatureBytes());
+
+export const registerL1ValidatorMessage = () =>
+  new RegisterL1ValidatorMessage(
+    id(),
+    nodeId(),
+    blsPublicKey(),
+    bigIntPr(),
+    pChainOwner(),
+    pChainOwner(),
+    bigIntPr(),
+  );
+
+export const registerL1ValidatorMessageBytes = () =>
+  concatBytes(
+    new Int(1).toBytes(), // typeId
+    idBytes(),
+    bytesForInt(nodeIdBytes().length),
+    nodeIdBytes(),
+    blsPublicKeyBytes(),
+    bigIntPrBytes(),
+    pChainOwnerBytes(),
+    pChainOwnerBytes(),
+    bigIntPrBytes(),
+  );
+
+export const l1ValidatorWeightMessage = () =>
+  new L1ValidatorWeightMessage(id(), bigIntPr(), bigIntPr());
+
+export const l1ValidatorWeightMessageBytes = () =>
+  concatBytes(
+    new Int(3).toBytes(), // typeId
+    idBytes(),
+    bigIntPrBytes(),
+    bigIntPrBytes(),
+  );
+
+export const addressedCall = () => new AddressedCall(address(), bytes());
+
+export const addressedCallBytes = () =>
+  concatBytes(
+    new Int(1).toBytes(), // typeId
+    bytesForInt(addressBytes().length),
+    addressBytes(),
+    bytesBytes(),
+  );
+
+export const l1ValidatorRegistrationMessage = () =>
+  new L1ValidatorRegistrationMessage(id(), bool());
+
+export const l1ValidatorRegistrationMessageBytes = () =>
+  concatBytes(
+    new Int(2).toBytes(), // typeId
+    idBytes(),
+    boolBytes(),
+  );
+
+export const subnetToL1ConversionMessage = () =>
+  new SubnetToL1ConversionMessage(id());
+
+export const subnetToL1ConversionMessageBytes = () =>
+  concatBytes(
+    new Int(0).toBytes(), // typeId
+    idBytes(),
+  );
+
+export const validatorData = () =>
+  new ValidatorData(nodeId(), blsPublicKey(), bigIntPr());
+
+export const validatorDataBytes = () =>
+  concatBytes(
+    bytesForInt(nodeIdBytes().length),
+    nodeIdBytes(),
+    blsPublicKeyBytes(),
+    bigIntPrBytes(),
+  );
+
+export const conversionData = () =>
+  new ConversionData(id(), id(), address(), [validatorData()]);
+
+export const conversionDataBytes = () =>
+  concatBytes(
+    idBytes(),
+    idBytes(),
+    bytesForInt(addressBytes().length),
+    addressBytes(),
+    bytesForInt(validatorDataBytes().length + 4), // size of validators + length of numValidators
+    bytesForInt(1), // numValidators
+    validatorDataBytes(),
+  );

src/serializable/constants.ts

@@ -21,6 +21,7 @@ export enum TypeSymbols {
   Address = 'common.Address',
   NodeId = 'common.NodeId',
   BlsSignature = 'common.BlsSignature',
+  BlsPublicKey = 'common.BlsPublicKey',
 
   // PRIMITIVES
   Int = 'primitives.Int',
@@ -29,7 +30,7 @@ export enum TypeSymbols {
   Byte = 'primitives.Byte',
   Bytes = 'primitives.Bytes',
   Short = 'primitives.Short',
-
+  Bool = 'primitives.Bool',
   // SECP256k1FX
   Input = 'secp256k1fx.Input',
   TransferInput = 'secp256k1fx.TransferInput',
@@ -100,4 +101,13 @@ export enum TypeSymbols {
   WarpMessage = 'warp.Message',
   WarpUnsignedMessage = 'warp.UnsignedMessage',
   WarpSignature = 'warp.Signature',
+
+  // Warp AddressedCall Payloads
+  AddressedCall = 'warp.AddressedCall',
+  RegisterL1ValidatorMessage = 'warp.RegisterL1ValidatorMessage',
+  L1ValidatorWeightMessage = 'warp.L1ValidatorWeightMessage',
+  SubnetToL1ConversionMessage = 'warp.SubnetToL1ConversionMessage',
+  L1ValidatorRegistrationMessage = 'warp.L1ValidatorRegistrationMessage',
+  ValidatorData = 'warp.ValidatorData',
+  ConversionData = 'warp.ConversionData',
 }

src/serializable/fxs/common/blsPublicKey.test.ts

@@ -0,0 +1,10 @@
+import { blsPublicKey, blsPublicKeyBytes } from '../../../fixtures/primitives';
+import { testSerialization } from '../../../fixtures/utils/serializable';
+import { BlsPublicKey } from './blsPublicKey';
+
+testSerialization(
+  'BlsPublicKey',
+  BlsPublicKey,
+  blsPublicKey,
+  blsPublicKeyBytes,
+);

src/serializable/fxs/common/blsPublicKey.ts

@@ -0,0 +1,49 @@
+import type { PublicKey } from '../../../crypto/bls';
+import {
+  PUBLIC_KEY_LENGTH,
+  publicKeyFromBytes,
+  publicKeyToBytes,
+} from '../../../crypto/bls';
+import { hexToBuffer } from '../../../utils/buffer';
+import { serializable } from '../../common/types';
+import { TypeSymbols } from '../../constants';
+import { Primitives } from '../../primitives/primatives';
+
+@serializable()
+export class BlsPublicKey extends Primitives {
+  _type = TypeSymbols.BlsPublicKey;
+
+  constructor(public readonly publicKey: PublicKey) {
+    super();
+  }
+
+  static fromPublicKeyBytes(publicKeyBytes: Uint8Array): BlsPublicKey {
+    return new BlsPublicKey(publicKeyFromBytes(publicKeyBytes));
+  }
+
+  static fromBytes(
+    bytes: Uint8Array,
+  ): [blsPublicKey: BlsPublicKey, rest: Uint8Array] {
+    const blsPublicKeyBytes = bytes.slice(0, PUBLIC_KEY_LENGTH);
+    const publicKey = publicKeyFromBytes(blsPublicKeyBytes);
+    const rest = bytes.slice(PUBLIC_KEY_LENGTH);
+
+    return [new BlsPublicKey(publicKey), rest];
+  }
+
+  static fromHex(hex: string): BlsPublicKey {
+    return new BlsPublicKey(publicKeyFromBytes(hexToBuffer(hex)));
+  }
+
+  toBytes() {
+    return publicKeyToBytes(this.publicKey);
+  }
+
+  toString() {
+    return this.publicKey.toHex();
+  }
+
+  toJSON() {
+    return this.toString();
+  }
+}

src/serializable/fxs/common/index.ts

@@ -1,6 +1,7 @@
 import { Address } from './address';
 import { BlsSignature } from './blsSignature';
+import { BlsPublicKey } from './blsPublicKey';
 import { Id } from './id';
 import { NodeId } from './nodeId';
 
-export { Address, BlsSignature, Id, NodeId };
+export { Address, BlsSignature, BlsPublicKey, Id, NodeId };

src/serializable/primitives/boolean.ts

@@ -0,0 +1,36 @@
+import { bufferToBool, hexToBuffer, padLeft } from '../../utils/buffer';
+import { serializable } from '../common/types';
+import { Primitives } from './primatives';
+import { TypeSymbols } from '../constants';
+
+/**
+ * Number of bytes per bool.
+ */
+export const BOOL_LEN = 1;
+
+@serializable()
+export class Bool extends Primitives {
+  _type = TypeSymbols.Bool;
+  constructor(private readonly bool: boolean) {
+    super();
+  }
+
+  static fromBytes(buf: Uint8Array): [Bool, Uint8Array] {
+    return [
+      new Bool(bufferToBool(buf.slice(0, BOOL_LEN))),
+      buf.slice(BOOL_LEN),
+    ];
+  }
+
+  toJSON() {
+    return this.bool.toString();
+  }
+
+  toBytes() {
+    return padLeft(hexToBuffer(this.bool ? '1' : '0'), BOOL_LEN);
+  }
+
+  value() {
+    return this.bool;
+  }
+}