@aztec/end-to-end 0.0.1-commit.d3ec352c → 0.0.1-commit.e6bd8901

package/src/fixtures/web3signer.ts

@@ -1,4 +1,4 @@
-import { randomBytes } from '@aztec/foundation/crypto';
+import { randomBytes } from '@aztec/foundation/crypto/random';
 import { retryUntil } from '@aztec/foundation/retry';
 import { sleep } from '@aztec/foundation/sleep';
 import { RemoteSigner } from '@aztec/node-keystore';

package/src/fixtures/with_telemetry_utils.ts

@@ -7,12 +7,12 @@ import {
 } from '@aztec/telemetry-client';
 import { OTelPinoStream } from '@aztec/telemetry-client/otel-pino-stream';
 
-export function getEndToEndTestTelemetryClient(metricsPort?: number): TelemetryClient {
+export async function getEndToEndTestTelemetryClient(metricsPort?: number): Promise<TelemetryClient> {
   if (metricsPort) {
     const otelStream = new OTelPinoStream({ levels });
     registerLoggingStream(otelStream);
   }
-  return initTelemetryClient(getEndToEndTestTelemetryConfig(metricsPort));
+  return await initTelemetryClient(getEndToEndTestTelemetryConfig(metricsPort));
 }
 
 /**

package/src/quality_of_service/{alert_checker.ts → grafana_client.ts}

@@ -25,7 +25,7 @@ const DEFAULT_CONFIG: AlertCheckerConfig = {
   grafanaCredentials: 'admin:admin',
 };
 
-export class AlertChecker {
+export class GrafanaClient {
   private config: AlertCheckerConfig;
   private logger: Logger;
 

package/src/quality_of_service/prometheus_client.ts

@@ -0,0 +1,113 @@
+export type PromteheusClientOptions = {
+  server: URL;
+};
+
+export class PrometheusClient {
+  constructor(
+    private config: PromteheusClientOptions,
+    private httpClient: typeof fetch = fetch,
+  ) {}
+
+  public async querySingleValue(query: string, time = new Date()): Promise<number> {
+    const resp = await this.queryRaw(query, time);
+    if (resp.status === 'success') {
+      if (resp.data.resultType === 'vector') {
+        if (resp.data.result.length === 0) {
+          return 0;
+        }
+        const [_, value] = resp.data.result[0].value;
+        return parseFloat(value);
+      }
+    }
+
+    throw new TypeError('Unsupported response body', { cause: JSON.stringify(resp) });
+  }
+
+  public queryRaw(query: string, time = new Date()): Promise<PrometheusResponse> {
+    const searchParams = new URLSearchParams();
+    searchParams.set('query', query);
+    searchParams.set('time', String(Math.trunc(time.getTime() / 1000)));
+    searchParams.set('limit', '10');
+
+    return this.callPrometheus('query', searchParams);
+  }
+
+  public queryRangeRaw(
+    query: string,
+    step: PrometheusDuration,
+    start: Date,
+    end = new Date(),
+  ): Promise<PrometheusResponse> {
+    const searchParams = new URLSearchParams();
+    searchParams.set('query', query);
+    searchParams.set('step', step);
+    searchParams.set('start', String(Math.trunc(start.getTime() / 1000)));
+    searchParams.set('end', String(Math.trunc(end.getTime() / 1000)));
+    searchParams.set('limit', '10');
+
+    return this.callPrometheus('query_range', searchParams);
+  }
+
+  private async callPrometheus(api: string, searchParams: URLSearchParams): Promise<PrometheusResponse> {
+    const url = new URL('api/v1/' + api, this.config.server);
+    for (const [name, value] of searchParams) {
+      url.searchParams.append(name, value);
+    }
+
+    const resp = await this.httpClient(url, { method: 'GET' });
+    if (!resp.ok || resp.status !== 200) {
+      throw new Error('Invalid HTTP response from Prometheus', {
+        cause: {
+          url,
+          status: resp.status,
+          statusText: resp.statusText,
+        },
+      });
+    }
+
+    const body = await resp.json();
+    if ('status' in body && (body.status === 'error' || body.status === 'success')) {
+      return body;
+    }
+
+    throw new Error('Invalid response from Prometheus', {
+      cause: {
+        url,
+        body,
+      },
+    });
+  }
+}
+
+export type PrometheusDuration = `${number}s` | `${number}m` | `${number}h`;
+
+export type PrometheusData =
+  | {
+      resultType: 'vector';
+      result: Array<{
+        metric: unknown;
+        value: [unixTimestamp: number, value: string];
+      }>;
+    }
+  | {
+      resultType: 'matrix';
+      result: Array<{
+        metric: unknown;
+        values: [unixTimestamp: number, value: string];
+      }>;
+    }
+  | {
+      resultType: 'scalar' | 'string';
+      result: unknown;
+    };
+
+export type PrometheusResponse =
+  | {
+      status: 'error';
+      errorType: string;
+      error: string;
+    }
+  | {
+      status: 'success';
+      data: PrometheusData;
+    };

package/src/shared/cross_chain_test_harness.ts

@@ -13,10 +13,11 @@ import type { AztecNode } from '@aztec/aztec.js/node';
 import type { SiblingPath } from '@aztec/aztec.js/trees';
 import type { TxReceipt } from '@aztec/aztec.js/tx';
 import type { Wallet } from '@aztec/aztec.js/wallet';
-import { type ExtendedViemWalletClient, type L1ContractAddresses, deployL1Contract } from '@aztec/ethereum';
-import { BlockNumber } from '@aztec/foundation/branded-types';
+import { deployL1Contract } from '@aztec/ethereum/deploy-l1-contract';
+import type { L1ContractAddresses } from '@aztec/ethereum/l1-contract-addresses';
+import type { ExtendedViemWalletClient } from '@aztec/ethereum/types';
+import { EpochNumber } from '@aztec/foundation/branded-types';
 import { retryUntil } from '@aztec/foundation/retry';
-import type { FieldsOf } from '@aztec/foundation/types';
 import { TestERC20Abi, TokenPortalAbi, TokenPortalBytecode } from '@aztec/l1-artifacts';
 import { TokenContract } from '@aztec/noir-contracts.js/Token';
 import { TokenBridgeContract } from '@aztec/noir-contracts.js/TokenBridge';
@@ -72,14 +73,10 @@ export async function deployAndInitializeTokenAndBridgeContracts(
   });
 
   // deploy l2 token
-  const token = await TokenContract.deploy(wallet, owner, 'TokenName', 'TokenSymbol', 18)
-    .send({ from: owner })
-    .deployed();
+  const token = await TokenContract.deploy(wallet, owner, 'TokenName', 'TokenSymbol', 18).send({ from: owner });
 
   // deploy l2 token bridge and attach to the portal
-  const bridge = await TokenBridgeContract.deploy(wallet, token.address, tokenPortalAddress)
-    .send({ from: owner })
-    .deployed();
+  const bridge = await TokenBridgeContract.deploy(wallet, token.address, tokenPortalAddress).send({ from: owner });
 
   if ((await token.methods.get_admin().simulate({ from: owner })) !== owner.toBigInt()) {
     throw new Error(`Token admin is not ${owner}`);
@@ -90,7 +87,7 @@ export async function deployAndInitializeTokenAndBridgeContracts(
   }
 
   // make the bridge a minter on the token:
-  await token.methods.set_minter(bridge.address, true).send({ from: owner }).wait();
+  await token.methods.set_minter(bridge.address, true).send({ from: owner });
   if ((await token.methods.is_minter(bridge.address).simulate({ from: owner })) === 1n) {
     throw new Error(`Bridge is not a minter`);
   }
@@ -233,7 +230,7 @@ export class CrossChainTestHarness {
 
   async mintTokensPublicOnL2(amount: bigint) {
     this.logger.info('Minting tokens on L2 publicly');
-    await this.l2Token.methods.mint_to_public(this.ownerAddress, amount).send({ from: this.ownerAddress }).wait();
+    await this.l2Token.methods.mint_to_public(this.ownerAddress, amount).send({ from: this.ownerAddress });
   }
 
   async mintTokensPrivateOnL2(amount: bigint) {
@@ -244,8 +241,7 @@ export class CrossChainTestHarness {
     // send a transfer tx to force through rollup with the message included
     await this.l2Token.methods
       .transfer_in_public(this.ownerAddress, receiverAddress, transferAmount, 0)
-      .send({ from: this.ownerAddress })
-      .wait();
+      .send({ from: this.ownerAddress });
   }
 
   async consumeMessageOnAztecAndMintPrivately(
@@ -255,8 +251,7 @@ export class CrossChainTestHarness {
     const { recipient, claimAmount, claimSecret: secretForL2MessageConsumption, messageLeafIndex } = claim;
     await this.l2Bridge.methods
       .claim_private(recipient, claimAmount, secretForL2MessageConsumption, messageLeafIndex)
-      .send({ from: this.ownerAddress })
-      .wait();
+      .send({ from: this.ownerAddress });
   }
 
   async consumeMessageOnAztecAndMintPublicly(
@@ -266,28 +261,25 @@ export class CrossChainTestHarness {
     const { claimAmount, claimSecret, messageLeafIndex } = claim;
     await this.l2Bridge.methods
       .claim_public(this.ownerAddress, claimAmount, claimSecret, messageLeafIndex)
-      .send({ from: this.ownerAddress })
-      .wait();
+      .send({ from: this.ownerAddress });
   }
 
   async withdrawPrivateFromAztecToL1(
     withdrawAmount: bigint,
     authwitNonce: Fr = Fr.ZERO,
     authWitness: AuthWitness,
-  ): Promise<FieldsOf<TxReceipt>> {
+  ): Promise<TxReceipt> {
     const withdrawReceipt = await this.l2Bridge.methods
       .exit_to_l1_private(this.l2Token.address, this.ethAccount, withdrawAmount, EthAddress.ZERO, authwitNonce)
-      .send({ authWitnesses: [authWitness], from: this.ownerAddress })
-      .wait();
+      .send({ authWitnesses: [authWitness], from: this.ownerAddress });
 
     return withdrawReceipt;
   }
 
-  async withdrawPublicFromAztecToL1(withdrawAmount: bigint, authwitNonce: Fr = Fr.ZERO): Promise<FieldsOf<TxReceipt>> {
+  async withdrawPublicFromAztecToL1(withdrawAmount: bigint, authwitNonce: Fr = Fr.ZERO): Promise<TxReceipt> {
     const withdrawReceipt = await this.l2Bridge.methods
       .exit_to_l1_public(this.ethAccount, withdrawAmount, EthAddress.ZERO, authwitNonce)
-      .send({ from: this.ownerAddress })
-      .wait();
+      .send({ from: this.ownerAddress });
 
     return withdrawReceipt;
   }
@@ -322,33 +314,23 @@ export class CrossChainTestHarness {
 
   withdrawFundsFromBridgeOnL1(
     amount: bigint,
-    blockNumber: BlockNumber,
+    epochNumber: EpochNumber,
     messageIndex: bigint,
     siblingPath: SiblingPath<number>,
   ) {
-    return this.l1TokenPortalManager.withdrawFunds(
-      amount,
-      this.ethAccount,
-      BigInt(blockNumber),
-      messageIndex,
-      siblingPath,
-    );
+    return this.l1TokenPortalManager.withdrawFunds(amount, this.ethAccount, epochNumber, messageIndex, siblingPath);
   }
 
   async transferToPrivateOnL2(shieldAmount: bigint) {
     this.logger.info('Transferring to private on L2');
-    await this.l2Token.methods
-      .transfer_to_private(this.ownerAddress, shieldAmount)
-      .send({ from: this.ownerAddress })
-      .wait();
+    await this.l2Token.methods.transfer_to_private(this.ownerAddress, shieldAmount).send({ from: this.ownerAddress });
   }
 
   async transferToPublicOnL2(amount: bigint, authwitNonce = Fr.ZERO) {
     this.logger.info('Transferring tokens to public');
     await this.l2Token.methods
       .transfer_to_public(this.ownerAddress, this.ownerAddress, amount, authwitNonce)
-      .send({ from: this.ownerAddress })
-      .wait();
+      .send({ from: this.ownerAddress });
   }
 
   /**

package/src/shared/gas_portal_test_harness.ts

@@ -4,7 +4,7 @@ import { Fr } from '@aztec/aztec.js/fields';
 import type { Logger } from '@aztec/aztec.js/log';
 import type { AztecNode } from '@aztec/aztec.js/node';
 import type { Wallet } from '@aztec/aztec.js/wallet';
-import type { ExtendedViemWalletClient } from '@aztec/ethereum';
+import type { ExtendedViemWalletClient } from '@aztec/ethereum/types';
 import { retryUntil } from '@aztec/foundation/retry';
 import { FeeJuiceContract } from '@aztec/noir-contracts.js/FeeJuice';
 import { ProtocolContractAddress } from '@aztec/protocol-contracts';
@@ -127,7 +127,7 @@ export class GasBridgingTestHarness implements IGasBridgingTestHarness {
   async consumeMessageOnAztecAndClaimPrivately(owner: AztecAddress, claimer: AztecAddress, claim: L2AmountClaim) {
     this.logger.info('Consuming messages on L2 Privately');
     const { claimAmount, claimSecret, messageLeafIndex } = claim;
-    await this.feeJuice.methods.claim(owner, claimAmount, claimSecret, messageLeafIndex).send({ from: claimer }).wait();
+    await this.feeJuice.methods.claim(owner, claimAmount, claimSecret, messageLeafIndex).send({ from: claimer });
   }
 
   async getL2PublicBalanceOf(owner: AztecAddress) {

package/src/shared/index.ts

@@ -1 +1 @@
-export { uniswapL1L2TestSuite, type UniswapSetupContext } from './uniswap_l1_l2.js';
+export { uniswapL1L2TestSuite } from './uniswap_l1_l2.js';

package/src/shared/submit-transactions.ts

@@ -1,8 +1,8 @@
 import { AztecAddress } from '@aztec/aztec.js/addresses';
-import type { SentTx } from '@aztec/aztec.js/contracts';
+import { NO_WAIT } from '@aztec/aztec.js/contracts';
 import { Fr, GrumpkinScalar } from '@aztec/aztec.js/fields';
 import type { Logger } from '@aztec/aztec.js/log';
-import { TxStatus } from '@aztec/aztec.js/tx';
+import { TxHash, type TxReceipt, TxStatus } from '@aztec/aztec.js/tx';
 import { times } from '@aztec/foundation/collection';
 import type { TestWallet } from '@aztec/test-wallet/server';
 
@@ -12,26 +12,20 @@ export const submitTxsTo = async (
   submitter: AztecAddress,
   numTxs: number,
   logger: Logger,
-): Promise<SentTx[]> => {
-  const txs: SentTx[] = [];
+): Promise<TxHash[]> => {
+  const txHashes: TxHash[] = [];
   await Promise.all(
     times(numTxs, async () => {
       const accountManager = await wallet.createSchnorrAccount(Fr.random(), Fr.random(), GrumpkinScalar.random());
       const deployMethod = await accountManager.getDeployMethod();
-      const tx = deployMethod.send({ from: submitter });
-      const txHash = await tx.getTxHash();
+      const txHash = await deployMethod.send({ from: submitter, wait: NO_WAIT });
 
       logger.info(`Tx sent with hash ${txHash}`);
-      const receipt = await tx.getReceipt();
-      expect(receipt).toEqual(
-        expect.objectContaining({
-          status: TxStatus.PENDING,
-          error: '',
-        }),
-      );
+      const receipt: TxReceipt = await wallet.getTxReceipt(txHash);
+      expect(receipt.status).toBe(TxStatus.PENDING);
       logger.info(`Receipt received for ${txHash}`);
-      txs.push(tx);
+      txHashes.push(txHash);
     }),
   );
-  return txs;
+  return txHashes;
 };