@aztec/p2p 0.7.10 → 0.8.7

package/src/client/p2p_client.test.ts

@@ -1,79 +0,0 @@
-import { L2BlockSource, mockTx } from '@aztec/types';
-
-import { expect, jest } from '@jest/globals';
-
-import { P2PService } from '../index.js';
-import { TxPool } from '../tx_pool/index.js';
-import { MockBlockSource } from './mocks.js';
-import { P2PClient } from './p2p_client.js';
-
-/**
- * Mockify helper for testing purposes.
- */
-type Mockify<T> = {
-  [P in keyof T]: ReturnType<typeof jest.fn>;
-};
-
-describe('In-Memory P2P Client', () => {
-  let txPool: Mockify<TxPool>;
-  let blockSource: L2BlockSource;
-  let p2pService: Mockify<P2PService>;
-
-  beforeEach(() => {
-    txPool = {
-      addTxs: jest.fn(),
-      getTxByHash: jest.fn().mockReturnValue(undefined),
-      deleteTxs: jest.fn(),
-      getAllTxs: jest.fn().mockReturnValue([]),
-      getAllTxHashes: jest.fn().mockReturnValue([]),
-      hasTx: jest.fn().mockReturnValue(false),
-    };
-
-    p2pService = {
-      start: jest.fn(),
-      stop: jest.fn(),
-      propagateTx: jest.fn(),
-      settledTxs: jest.fn(),
-    };
-
-    blockSource = new MockBlockSource();
-  });
-
-  it('can start & stop', async () => {
-    const client = new P2PClient(blockSource, txPool, p2pService);
-    expect(await client.isReady()).toEqual(false);
-
-    await client.start();
-    expect(await client.isReady()).toEqual(true);
-
-    await client.stop();
-    expect(await client.isReady()).toEqual(false);
-  });
-
-  it('adds txs to pool', async () => {
-    const client = new P2PClient(blockSource, txPool, p2pService);
-    await client.start();
-    const tx1 = mockTx();
-    const tx2 = mockTx();
-    await client.sendTx(tx1);
-    await client.sendTx(tx2);
-
-    expect(txPool.addTxs).toHaveBeenCalledTimes(2);
-    await client.stop();
-  });
-
-  it('rejects txs after being stopped', async () => {
-    const client = new P2PClient(blockSource, txPool, p2pService);
-    await client.start();
-    const tx1 = mockTx();
-    const tx2 = mockTx();
-    await client.sendTx(tx1);
-    await client.sendTx(tx2);
-
-    expect(txPool.addTxs).toHaveBeenCalledTimes(2);
-    await client.stop();
-    const tx3 = mockTx();
-    await expect(client.sendTx(tx3)).rejects.toThrow();
-    expect(txPool.addTxs).toHaveBeenCalledTimes(2);
-  });
-});

package/src/service/known_txs.test.ts

@@ -1,47 +0,0 @@
-import { randomBytes } from '@aztec/foundation/crypto';
-import { TxHash } from '@aztec/types';
-
-import { expect } from '@jest/globals';
-import { Ed25519PeerId, PeerId } from '@libp2p/interface-peer-id';
-import { mock } from 'jest-mock-extended';
-
-import { KnownTxLookup } from './known_txs.js';
-
-const createMockPeerId = (peerId: string): PeerId => {
-  return mock<Ed25519PeerId>({
-    toString: () => peerId,
-  });
-};
-
-const createTxHash = () => {
-  return new TxHash(randomBytes(32));
-};
-
-describe('Known Txs', () => {
-  it('Returns false when a peer has not seen a tx', () => {
-    const knownTxs = new KnownTxLookup();
-
-    const peer = createMockPeerId('Peer 1');
-    const txHash = createTxHash();
-
-    expect(knownTxs.hasPeerSeenTx(peer, txHash.toString())).toEqual(false);
-  });
-
-  it('Returns true when a peer has seen a tx', () => {
-    const knownTxs = new KnownTxLookup();
-
-    const peer = createMockPeerId('Peer 1');
-    const peer2 = createMockPeerId('Peer 2');
-    const txHash = createTxHash();
-
-    knownTxs.addPeerForTx(peer, txHash.toString());
-
-    expect(knownTxs.hasPeerSeenTx(peer, txHash.toString())).toEqual(true);
-    expect(knownTxs.hasPeerSeenTx(peer2, txHash.toString())).toEqual(false);
-
-    knownTxs.addPeerForTx(peer2, txHash.toString());
-
-    expect(knownTxs.hasPeerSeenTx(peer, txHash.toString())).toEqual(true);
-    expect(knownTxs.hasPeerSeenTx(peer2, txHash.toString())).toEqual(true);
-  });
-});

package/src/service/tx_messages.test.ts

@@ -1,67 +0,0 @@
-import { Tx, TxHash, mockTx } from '@aztec/types';
-
-import { expect } from '@jest/globals';
-import { randomBytes } from 'crypto';
-
-import {
-  Messages,
-  createGetTransactionsRequestMessage,
-  createTransactionHashesMessage,
-  createTransactionsMessage,
-  decodeGetTransactionsRequestMessage,
-  decodeMessageType,
-  decodeTransactionHashesMessage,
-  decodeTransactionsMessage,
-  fromTxMessage,
-  getEncodedMessage,
-  toTxMessage,
-} from './tx_messages.js';
-
-const makeTxHash = () => {
-  return new TxHash(randomBytes(32));
-};
-
-const verifyTx = (actual: Tx, expected: Tx) => {
-  expect(actual.data!.toBuffer()).toEqual(expected.data?.toBuffer());
-  expect(actual.proof!.toBuffer()).toEqual(expected.proof!.toBuffer());
-  expect(actual.encryptedLogs!.toBuffer()).toEqual(expected.encryptedLogs?.toBuffer());
-  expect(actual.newContracts!.length).toEqual(expected.newContracts!.length);
-  for (let i = 0; i < actual.newContracts!.length; i++) {
-    expect(actual.newContracts![i].toBuffer()).toEqual(expected.newContracts![i].toBuffer());
-  }
-};
-
-describe('Messages', () => {
-  it('Correctly serialises and deserialises a single private transaction', () => {
-    const transaction = mockTx();
-    const message = toTxMessage(transaction);
-    const decodedTransaction = fromTxMessage(message);
-    verifyTx(decodedTransaction, transaction);
-  });
-
-  it('Correctly serialises and deserialises transactions messages', () => {
-    const privateTransactions = [mockTx(), mockTx(), mockTx()];
-    const message = createTransactionsMessage(privateTransactions);
-    expect(decodeMessageType(message)).toBe(Messages.POOLED_TRANSACTIONS);
-    const decodedTransactions = decodeTransactionsMessage(getEncodedMessage(message));
-    verifyTx(decodedTransactions[0], privateTransactions[0]);
-    verifyTx(decodedTransactions[1], privateTransactions[1]);
-    verifyTx(decodedTransactions[2], privateTransactions[2]);
-  });
-
-  it('Correctly serialises and deserialises transaction hashes message', () => {
-    const txHashes = [makeTxHash(), makeTxHash(), makeTxHash()];
-    const message = createTransactionHashesMessage(txHashes);
-    expect(decodeMessageType(message)).toEqual(Messages.POOLED_TRANSACTION_HASHES);
-    const decodedHashes = decodeTransactionHashesMessage(getEncodedMessage(message));
-    expect(decodedHashes.map(x => x.toString())).toEqual(txHashes.map(x => x.toString()));
-  });
-
-  it('Correctly serialises and deserialises get transactions message', () => {
-    const txHashes = [makeTxHash(), makeTxHash(), makeTxHash()];
-    const message = createGetTransactionsRequestMessage(txHashes);
-    expect(decodeMessageType(message)).toEqual(Messages.GET_TRANSACTIONS);
-    const decodedHashes = decodeGetTransactionsRequestMessage(getEncodedMessage(message));
-    expect(decodedHashes.map(x => x.toString())).toEqual(txHashes.map(x => x.toString()));
-  });
-});

package/src/tx_pool/tx_pool.test.ts

@@ -1,25 +0,0 @@
-import { mockTx } from '@aztec/types';
-
-import { InMemoryTxPool } from './index.js';
-
-describe('In-Memory TX pool', () => {
-  it('Adds txs to the pool', async () => {
-    const pool = new InMemoryTxPool();
-    const tx1 = mockTx();
-
-    await pool.addTxs([tx1]);
-    const poolTx = pool.getTxByHash(await tx1.getTxHash());
-    expect(await poolTx!.getTxHash()).toEqual(await tx1.getTxHash());
-  });
-
-  it('Removes txs from the pool', async () => {
-    const pool = new InMemoryTxPool();
-    const tx1 = mockTx();
-
-    await pool.addTxs([tx1]);
-    pool.deleteTxs([await tx1.getTxHash()]);
-
-    const poolTx = pool.getTxByHash(await tx1.getTxHash());
-    expect(poolTx).toBeFalsy();
-  });
-});

package/tsconfig.json

@@ -1,20 +0,0 @@
-{
-  "extends": "..",
-  "compilerOptions": {
-    "outDir": "dest",
-    "rootDir": "src",
-    "tsBuildInfoFile": ".tsbuildinfo"
-  },
-  "references": [
-    {
-      "path": "../circuits.js"
-    },
-    {
-      "path": "../foundation"
-    },
-    {
-      "path": "../types"
-    }
-  ],
-  "include": ["src"]
-}