From f932d229126044c3f98c23675c09957c64248e24 Mon Sep 17 00:00:00 2001 From: Christophe Date: Tue, 24 Sep 2024 19:45:12 +0200 Subject: [PATCH] test: Add integration tests for arbOwner --- src/actions/arbOwner.integration.test.ts | 214 +++++++++++++++++++++++ 1 file changed, 214 insertions(+) create mode 100644 src/actions/arbOwner.integration.test.ts diff --git a/src/actions/arbOwner.integration.test.ts b/src/actions/arbOwner.integration.test.ts new file mode 100644 index 00000000..04fb028a --- /dev/null +++ b/src/actions/arbOwner.integration.test.ts @@ -0,0 +1,214 @@ +import { describe, it, expect } from 'vitest'; +import { getNitroTestnodePrivateKeyAccounts } from '../testHelpers'; +import { Address, createPublicClient, http, zeroAddress } from 'viem'; +import { nitroTestnodeL3 } from '../chains'; +import { generatePrivateKey, privateKeyToAccount } from 'viem/accounts'; +import { getAllChainOwners } from './getAllChainOwners'; +import { buildAddChainOwner } from './buildAddChainOwner'; +import { buildRemoveChainOwner } from './buildRemoveChainOwner'; +import { isChainOwner } from './isChainOwner'; +import { getInfraFeeAccount } from './getInfraFeeAccount'; +import { getNetworkFeeAccount } from './getNetworkFeeAccount'; +import { getScheduledUpgrade } from './getScheduledUpgrade'; +import { buildSetMaxTxGasLimit } from './buildSetMaxTxGasLimit'; +import { buildSetSpeedLimit } from './buildSetSpeedLimit'; +import { buildSetParentPricePerUnit } from './buildSetParentPricePerUnit'; +import { getParentBaseFeeEstimate } from './getParentBaseFeeEstimate'; +import { getGasAccountingParams } from './getGasAccountingParams'; +import { buildSetParentPricingRewardRate } from './buildSetParentPricingRewardRate'; +import { getParentRewardRate } from './getParentRewardRate'; +import { buildSetParentPricingRewardRecipient } from './buildSetParentPricingRewardRecipient'; +import { getParentRewardRecipient } from './getParentRewardRecipient'; + +const { l3RollupOwner } = getNitroTestnodePrivateKeyAccounts(); + +const client = createPublicClient({ + chain: nitroTestnodeL3, + transport: http(), +}); + +describe('chain owner management', () => { + it('buildAdd/RemoveChainOwner successfully add and remove chain owner', async () => { + const randomAddress = privateKeyToAccount(generatePrivateKey()).address; + expect(await getAllChainOwners(client)).toEqual([l3RollupOwner.address]); + expect(await isChainOwner(client, { address: randomAddress })).toBeFalsy(); + + const addTransactionRequest = await buildAddChainOwner(client, { + upgradeExecutor: false, + account: l3RollupOwner.address, + params: { + newOwner: randomAddress, + }, + }); + const addTxHash = await client.sendRawTransaction({ + serializedTransaction: await l3RollupOwner.signTransaction(addTransactionRequest), + }); + await client.waitForTransactionReceipt({ hash: addTxHash }); + + expect(await isChainOwner(client, { address: randomAddress })).toBeTruthy(); + expect(await getAllChainOwners(client)).toEqual([l3RollupOwner.address, randomAddress]); + + const removeTransactionRequest = await buildRemoveChainOwner(client, { + upgradeExecutor: false, + account: l3RollupOwner.address, + params: { + owner: randomAddress, + }, + }); + const removeTxHash = await client.sendRawTransaction({ + serializedTransaction: await l3RollupOwner.signTransaction(removeTransactionRequest), + }); + await client.waitForTransactionReceipt({ hash: removeTxHash }); + + expect(await getAllChainOwners(client)).toEqual([l3RollupOwner.address]); + expect(await isChainOwner(client, { address: randomAddress })).toBeFalsy(); + }); +}); + +describe('Fee account', () => { + it('getInfraFeeAccount returns the infra fee account', async () => { + const infraFeeAccount = await getInfraFeeAccount(client); + expect(infraFeeAccount).toBe(zeroAddress); + }); + + it('getNetworkFeeAccount returns the network fee account', async () => { + const networkFeeAccount = await getNetworkFeeAccount(client); + expect(networkFeeAccount).toBe(l3RollupOwner.address); + }); +}); + +describe('Fee management', () => { + it('buildSetMaxTxGasLimit successfully set max gas limit for transaction', async () => { + async function changeMaxTxGasLimit(limit: bigint) { + const transactionRequest = await buildSetMaxTxGasLimit(client, { + upgradeExecutor: false, + account: l3RollupOwner.address, + params: { + limit, + }, + }); + const txHash = await client.sendRawTransaction({ + serializedTransaction: await l3RollupOwner.signTransaction(transactionRequest), + }); + await client.waitForTransactionReceipt({ hash: txHash }); + } + // const { maxTxGasLimit } = await getGasAccountingParams(client); + // expect(maxTxGasLimit).toEqual(32000000n) + + await changeMaxTxGasLimit(64_000_000n); + + // const { maxTxGasLimit } = await getGasAccountingParams(client); + // expect(maxTxGasLimit).toEqual(64000000n) + + await changeMaxTxGasLimit(32_000_000n); + + // const { maxTxGasLimit } = await getGasAccountingParams(client); + // expect(maxTxGasLimit).toEqual(32000000n) + }); + + it('buildSetSpeedLimit successfully speed limit', async () => { + async function changeSpeedLimit(limit: bigint) { + const transactionRequest = await buildSetSpeedLimit(client, { + upgradeExecutor: false, + account: l3RollupOwner.address, + params: { + limit, + }, + }); + const txHash = await client.sendRawTransaction({ + serializedTransaction: await l3RollupOwner.signTransaction(transactionRequest), + }); + await client.waitForTransactionReceipt({ hash: txHash }); + } + expect((await getGasAccountingParams(client)).speedLimitPerSecond).toEqual(7_000_000n); + + await changeSpeedLimit(14_000_000n); + expect((await getGasAccountingParams(client)).speedLimitPerSecond).toEqual(14_000_000n); + + await changeSpeedLimit(7_000_000n); + expect((await getGasAccountingParams(client)).speedLimitPerSecond).toEqual(7_000_000n); + }); + + it('buildSetParentPricePerUnit successfully set parent price per unit', async () => { + async function changeParentPricePerUnit(pricePerUnit: bigint) { + const transactionRequest = await buildSetParentPricePerUnit(client, { + upgradeExecutor: false, + account: l3RollupOwner.address, + params: { + pricePerUnit, + }, + }); + const txHash = await client.sendRawTransaction({ + serializedTransaction: await l3RollupOwner.signTransaction(transactionRequest), + }); + await client.waitForTransactionReceipt({ hash: txHash }); + } + + const initialParentBaseFeeEstimate = await getParentBaseFeeEstimate(client); + + await changeParentPricePerUnit(100_000_000n); + expect(await getParentBaseFeeEstimate(client)).toEqual(100_000_000n); + + await changeParentPricePerUnit(initialParentBaseFeeEstimate); + expect(await getParentBaseFeeEstimate(client)).toEqual(initialParentBaseFeeEstimate); + }); + + it('buildSetParentPricingRewardRate successfully set parent pricing reward rate', async () => { + async function changeParentPriceRewardRate(weiPerUnit: bigint) { + const transactionRequest = await buildSetParentPricingRewardRate(client, { + upgradeExecutor: false, + account: l3RollupOwner.address, + params: { + weiPerUnit, + }, + }); + const txHash = await client.sendRawTransaction({ + serializedTransaction: await l3RollupOwner.signTransaction(transactionRequest), + }); + await client.waitForTransactionReceipt({ hash: txHash }); + } + + const initialParentPriceRewardRate = await getParentRewardRate(client); + + await changeParentPriceRewardRate(200_000_000n); + expect(await getParentRewardRate(client)).toEqual(200_000_000n); + + await changeParentPriceRewardRate(initialParentPriceRewardRate); + expect(await getParentRewardRate(client)).toEqual(initialParentPriceRewardRate); + }); + + it('buildSetParentPricingRewardRecipient successfully set parent pricing reward recipient', async () => { + async function changeParentPriceRewardRecipient(recipient: Address) { + const transactionRequest = await buildSetParentPricingRewardRecipient(client, { + upgradeExecutor: false, + account: l3RollupOwner.address, + params: { + recipient, + }, + }); + const txHash = await client.sendRawTransaction({ + serializedTransaction: await l3RollupOwner.signTransaction(transactionRequest), + }); + await client.waitForTransactionReceipt({ hash: txHash }); + } + + const initialParentPriceRewardRecipient = await getParentRewardRecipient(client); + expect(initialParentPriceRewardRecipient).toEqual(l3RollupOwner.address); + + const randomAddress = privateKeyToAccount(generatePrivateKey()).address; + await changeParentPriceRewardRecipient(randomAddress); + expect(await getParentRewardRecipient(client)).toEqual(randomAddress); + + await changeParentPriceRewardRecipient(initialParentPriceRewardRecipient); + expect(await getParentRewardRecipient(client)).toEqual(initialParentPriceRewardRecipient); + }); +}); + +describe('GetScheduledUpgrade', () => { + it('getScheduledUpgrade returns timestamp and version for next upgrade', async () => { + expect(await getScheduledUpgrade(client)).toEqual({ + arbosVersion: 0n, + scheduledForTimestamp: 0n, + }); + }); +});