feat: p-chain dynamic fees

.vscode/extensions.json

@@ -0,0 +1,3 @@
+{
+  "recommendations": ["streetsidesoftware.code-spell-checker"]
+}

.vscode/settings.json

@@ -1,3 +1,4 @@
 {
+  "typescript.preferences.importModuleSpecifier": "relative",
   "typescript.tsdk": "node_modules/typescript/lib"
-}
+}

cspell.json

@@ -0,0 +1,23 @@
+{
+  "$schema": "https://raw.githubusercontent.com/streetsidesoftware/cspell/main/cspell.schema.json",
+  "version": "0.2",
+  "dictionaries": [
+    "companies",
+    "css",
+    "en_us",
+    "en-gb",
+    "fullstack",
+    "html",
+    "lorem-ipsum",
+    "node",
+    "npm",
+    "softwareTerms",
+    "sql",
+    "typescript"
+  ],
+  "ignorePaths": ["node_modules", "__generated__", "build", "dist", "out"],
+  "ignoreRegExpList": ["/.*[0-9].*/"],
+  "language": "en",
+  "minWordLength": 5,
+  "words": ["amounter", "avalabs", "locktime", "stakeable", "unstakeable", "utxo", "utxos"]
+}

examples/p-chain/etna/base.ts

@@ -0,0 +1,42 @@
+import { TransferableOutput, addTxSignatures, pvm, utils } from '../../../src';
+import { getEnvVars } from '../../utils/getEnvVars';
+import { getEtnaContextFromURI } from './utils/etna-context';
+
+/**
+ * The amount of AVAX to send to self.
+ */
+const SEND_AVAX_AMOUNT: number = 0.001;
+
+const main = async () => {
+  const { AVAX_PUBLIC_URL, P_CHAIN_ADDRESS, PRIVATE_KEY } = getEnvVars();
+
+  const pvmApi = new pvm.PVMApi(AVAX_PUBLIC_URL);
+
+  const context = await getEtnaContextFromURI(AVAX_PUBLIC_URL);
+
+  const { utxos } = await pvmApi.getUTXOs({ addresses: [P_CHAIN_ADDRESS] });
+
+  const tx = pvm.e.newBaseTx(
+    {
+      fromAddressesBytes: [utils.bech32ToBytes(P_CHAIN_ADDRESS)],
+      outputs: [
+        TransferableOutput.fromNative(
+          context.avaxAssetID,
+          BigInt(SEND_AVAX_AMOUNT * 1e9),
+          [utils.bech32ToBytes(P_CHAIN_ADDRESS)],
+        ),
+      ],
+      utxos,
+    },
+    context,
+  );
+
+  await addTxSignatures({
+    unsignedTx: tx,
+    privateKeys: [utils.hexToBuffer(PRIVATE_KEY)],
+  });
+
+  return pvmApi.issueSignedTx(tx.getSignedTx());
+};
+
+main().then(console.log);

examples/p-chain/etna/delegate.ts

@@ -0,0 +1,50 @@
+import { addTxSignatures, networkIDs, pvm, utils } from '../../../src';
+import { getEnvVars } from '../../utils/getEnvVars';
+import { getEtnaContextFromURI } from './utils/etna-context';
+
+const AMOUNT_TO_DELEGATE_AVAX: number = 1;
+const DAYS_TO_DELEGATE: number = 14;
+
+const main = async () => {
+  const { AVAX_PUBLIC_URL, P_CHAIN_ADDRESS, PRIVATE_KEY } = getEnvVars();
+
+  const pvmApi = new pvm.PVMApi(AVAX_PUBLIC_URL);
+
+  const context = await getEtnaContextFromURI(AVAX_PUBLIC_URL);
+
+  const { utxos } = await pvmApi.getUTXOs({ addresses: [P_CHAIN_ADDRESS] });
+
+  const startTime = await pvmApi.getTimestamp();
+  const startDate = new Date(startTime.timestamp);
+  const start: bigint = BigInt(startDate.getTime() / 1_000);
+
+  const endTime = new Date(startTime.timestamp);
+  endTime.setDate(endTime.getDate() + DAYS_TO_DELEGATE);
+  const end: bigint = BigInt(endTime.getTime() / 1_000);
+
+  // TODO: Get this from an argument.
+  const nodeId = 'NodeID-MqgFXT8JhorbEW2LpTDGePBBhv55SSp3M';
+
+  const tx = pvm.e.newAddPermissionlessDelegatorTx(
+    {
+      end,
+      fromAddressesBytes: [utils.bech32ToBytes(P_CHAIN_ADDRESS)],
+      nodeId,
+      rewardAddresses: [utils.bech32ToBytes(P_CHAIN_ADDRESS)],
+      start,
+      subnetId: networkIDs.PrimaryNetworkID.toString(),
+      utxos,
+      weight: BigInt(AMOUNT_TO_DELEGATE_AVAX * 1e9),
+    },
+    context,
+  );
+
+  await addTxSignatures({
+    unsignedTx: tx,
+    privateKeys: [utils.hexToBuffer(PRIVATE_KEY)],
+  });
+
+  return pvmApi.issueSignedTx(tx.getSignedTx());
+};
+
+main().then(console.log);

examples/p-chain/etna/export.ts

@@ -0,0 +1,43 @@
+import { TransferableOutput, addTxSignatures, pvm, utils } from '../../../src';
+import { getEnvVars } from '../../utils/getEnvVars';
+import { getEtnaContextFromURI } from './utils/etna-context';
+
+const AMOUNT_TO_EXPORT_AVAX: number = 0.001;
+
+const main = async () => {
+  const { AVAX_PUBLIC_URL, P_CHAIN_ADDRESS, PRIVATE_KEY, X_CHAIN_ADDRESS } =
+    getEnvVars();
+
+  const context = await getEtnaContextFromURI(AVAX_PUBLIC_URL);
+
+  const pvmApi = new pvm.PVMApi(AVAX_PUBLIC_URL);
+
+  const { utxos } = await pvmApi.getUTXOs({
+    addresses: [P_CHAIN_ADDRESS],
+  });
+
+  const exportTx = pvm.e.newExportTx(
+    {
+      destinationChainId: context.xBlockchainID,
+      fromAddressesBytes: [utils.bech32ToBytes(P_CHAIN_ADDRESS)],
+      outputs: [
+        TransferableOutput.fromNative(
+          context.avaxAssetID,
+          BigInt(AMOUNT_TO_EXPORT_AVAX * 1e9),
+          [utils.bech32ToBytes(X_CHAIN_ADDRESS)],
+        ),
+      ],
+      utxos,
+    },
+    context,
+  );
+
+  await addTxSignatures({
+    unsignedTx: exportTx,
+    privateKeys: [utils.hexToBuffer(PRIVATE_KEY)],
+  });
+
+  return pvmApi.issueSignedTx(exportTx.getSignedTx());
+};
+
+main().then(console.log);

examples/p-chain/etna/import.ts

@@ -0,0 +1,36 @@
+import { addTxSignatures, pvm, utils } from '../../../src';
+import { getEnvVars } from '../../utils/getEnvVars';
+import { getEtnaContextFromURI } from './utils/etna-context';
+
+const main = async () => {
+  const { AVAX_PUBLIC_URL, P_CHAIN_ADDRESS, PRIVATE_KEY, X_CHAIN_ADDRESS } =
+    getEnvVars();
+
+  const context = await getEtnaContextFromURI(AVAX_PUBLIC_URL);
+
+  const pvmApi = new pvm.PVMApi(AVAX_PUBLIC_URL);
+
+  const { utxos } = await pvmApi.getUTXOs({
+    sourceChain: 'X',
+    addresses: [P_CHAIN_ADDRESS],
+  });
+
+  const importTx = pvm.e.newImportTx(
+    {
+      fromAddressesBytes: [utils.bech32ToBytes(X_CHAIN_ADDRESS)],
+      sourceChainId: context.xBlockchainID,
+      toAddresses: [utils.bech32ToBytes(P_CHAIN_ADDRESS)],
+      utxos,
+    },
+    context,
+  );
+
+  await addTxSignatures({
+    unsignedTx: importTx,
+    privateKeys: [utils.hexToBuffer(PRIVATE_KEY)],
+  });
+
+  return pvmApi.issueSignedTx(importTx.getSignedTx());
+};
+
+main().then(console.log);

examples/p-chain/etna/utils/etna-context.ts

@@ -0,0 +1,16 @@
+import { Context } from '../../../../src';
+
+/**
+ * Gets the context from URI and then modifies the context
+ * to be used for testing example Etna transactions until Etna is enabled.
+ */
+export const getEtnaContextFromURI = async (
+  uri: string,
+): Promise<Context.Context> => {
+  const context = await Context.getContextFromURI(uri);
+
+  return {
+    ...context,
+    gasPrice: 10_000n,
+  };
+};

examples/p-chain/etna/utils/random-node-id.ts

@@ -0,0 +1,10 @@
+import { base58check } from '../../../../src/utils';
+
+export const getRandomNodeId = (): string => {
+  const buffer = new Uint8Array(20);
+  const randomBuffer = crypto.getRandomValues(buffer);
+
+  const nodeId = `NodeID-${base58check.encode(randomBuffer)}`;
+
+  return nodeId;
+};

examples/p-chain/etna/validate.ts

@@ -0,0 +1,64 @@
+import { addTxSignatures, networkIDs, pvm, utils } from '../../../src';
+import { getEnvVars } from '../../utils/getEnvVars';
+import { getEtnaContextFromURI } from './utils/etna-context';
+import { getRandomNodeId } from './utils/random-node-id';
+
+const AMOUNT_TO_VALIDATE_AVAX: number = 1;
+const DAYS_TO_VALIDATE: number = 21;
+
+const nodeId = getRandomNodeId();
+
+const main = async () => {
+  const { AVAX_PUBLIC_URL, P_CHAIN_ADDRESS, PRIVATE_KEY } = getEnvVars();
+
+  const pvmApi = new pvm.PVMApi(AVAX_PUBLIC_URL);
+
+  const context = await getEtnaContextFromURI(AVAX_PUBLIC_URL);
+
+  const { utxos } = await pvmApi.getUTXOs({ addresses: [P_CHAIN_ADDRESS] });
+
+  const startTime = await pvmApi.getTimestamp();
+  const startDate = new Date(startTime.timestamp);
+  const start: bigint = BigInt(startDate.getTime() / 1_000);
+
+  const endTime = new Date(startTime.timestamp);
+  endTime.setDate(endTime.getDate() + DAYS_TO_VALIDATE);
+  const end: bigint = BigInt(endTime.getTime() / 1_000);
+
+  const publicKey = utils.hexToBuffer(
+    '0x8f95423f7142d00a48e1014a3de8d28907d420dc33b3052a6dee03a3f2941a393c2351e354704ca66a3fc29870282e15',
+  );
+
+  const signature = utils.hexToBuffer(
+    '0x86a3ab4c45cfe31cae34c1d06f212434ac71b1be6cfe046c80c162e057614a94a5bc9f1ded1a7029deb0ba4ca7c9b71411e293438691be79c2dbf19d1ca7c3eadb9c756246fc5de5b7b89511c7d7302ae051d9e03d7991138299b5ed6a570a98',
+  );
+
+  const tx = pvm.e.newAddPermissionlessValidatorTx(
+    {
+      end,
+      delegatorRewardsOwner: [utils.bech32ToBytes(P_CHAIN_ADDRESS)],
+      fromAddressesBytes: [utils.bech32ToBytes(P_CHAIN_ADDRESS)],
+      nodeId,
+      publicKey,
+      rewardAddresses: [utils.bech32ToBytes(P_CHAIN_ADDRESS)],
+      shares: 20 * 1e4,
+      signature,
+      start,
+      subnetId: networkIDs.PrimaryNetworkID.toString(),
+      utxos,
+      weight: BigInt(AMOUNT_TO_VALIDATE_AVAX * 1e9),
+    },
+    context,
+  );
+
+  await addTxSignatures({
+    unsignedTx: tx,
+    privateKeys: [utils.hexToBuffer(PRIVATE_KEY)],
+  });
+
+  return pvmApi.issueSignedTx(tx.getSignedTx());
+};
+
+main()
+  .then(console.log)
+  .then(() => console.log('Validate node ID:', nodeId));

examples/utils/getEnvVars.ts

@@ -0,0 +1,17 @@
+const AVAX_PUBLIC_URL = process.env['AVAX_PUBLIC_URL'];
+const P_CHAIN_ADDRESS = process.env['P_CHAIN_ADDRESS'];
+const PRIVATE_KEY = process.env['PRIVATE_KEY'];
+const X_CHAIN_ADDRESS = process.env['X_CHAIN_ADDRESS'];
+
+export const getEnvVars = () => {
+  if (!(AVAX_PUBLIC_URL && P_CHAIN_ADDRESS && PRIVATE_KEY && X_CHAIN_ADDRESS)) {
+    throw new Error('Missing environment variable(s).');
+  }
+
+  return {
+    AVAX_PUBLIC_URL,
+    P_CHAIN_ADDRESS,
+    PRIVATE_KEY,
+    X_CHAIN_ADDRESS,
+  };
+};

jest.config.ts

@@ -15,4 +15,7 @@ module.exports = {
   testEnvironment: 'node',
   coverageProvider: 'v8',
   extensionsToTreatAsEsm: ['.ts'],
+  // Experimental to fix issues with BigInt serialization
+  // See: https://jestjs.io/docs/configuration#workerthreads
+  workerThreads: true,
 };

src/crypto/secp256k1.ts

@@ -4,6 +4,8 @@ import * as secp from '@noble/secp256k1';
 import { Address } from 'micro-eth-signer';
 import { concatBytes, hexToBuffer } from '../utils/buffer';
 
+export const SIGNATURE_LENGTH = 65;
+
 export function randomPrivateKey() {
   return secp.utils.randomPrivateKey();
 }

src/fixtures/context.ts

@@ -1,3 +1,4 @@
+import { createDimensions } from '../vms/common/fees/dimensions';
 import type { Context } from '../vms/context';
 
 export const testContext: Context = {
@@ -16,4 +17,8 @@ export const testContext: Context = {
   addSubnetDelegatorFee: 1000000n,
   networkID: 1,
   hrp: 'avax',
+
+  // TODO: Adjust these based on what we want for the tests.
+  gasPrice: 1n,
+  complexityWeights: createDimensions(1, 1, 1, 1),
 };

src/fixtures/transactions.ts

@@ -14,9 +14,10 @@ import {
 } from '../serializable/fxs/secp256k1';
 import { BigIntPr, Int, Bytes } from '../serializable/primitives';
 import { StakeableLockIn, StakeableLockOut } from '../serializable/pvm';
-import { hexToBuffer } from '../utils';
+import { hexToBuffer, unpackWithManager } from '../utils';
 import { testContext } from './context';
 import { stringToBytes } from '@scure/base';
+import type { VM } from '../serializable';
 
 export const cAddressForTest = '0xfd4DFC8f567caD8a275989982c5f8f1fC82B7563';
 export const privateKeyForTest =
@@ -190,3 +191,9 @@ export const getOutputForTest = () =>
     new BigIntPr(BigInt(0.1 * 1e9)),
     Id.fromString(testContext.avaxAssetID),
   );
+
+export const txHexToTransaction = (vm: VM, txHex: string) => {
+  const txBytes = hexToBuffer(txHex);
+
+  return unpackWithManager(vm, txBytes);
+};

src/serializable/avax/avaxTx.ts

@@ -5,7 +5,7 @@ import type { TransferableInput } from './transferableInput';
 export abstract class AvaxTx extends Transaction {
   abstract baseTx?: BaseTx;
 
-  getInputs(): TransferableInput[] {
+  getInputs(): readonly TransferableInput[] {
     return this.baseTx?.inputs ?? [];
   }
   getBlockchainId() {