@aztec/cli-wallet 0.0.0-test.0 → 0.0.1-commit.0208eb9

package/dest/utils/wallet.js

@@ -0,0 +1,204 @@
+import { EcdsaRAccountContract, EcdsaRSSHAccountContract } from '@aztec/accounts/ecdsa';
+import { SchnorrAccountContract } from '@aztec/accounts/schnorr';
+import { StubAccountContractArtifact, createStubAccount } from '@aztec/accounts/stub';
+import { getIdentities } from '@aztec/accounts/utils';
+import { SignerlessAccount } from '@aztec/aztec.js/account';
+import { getContractInstanceFromInstantiationParams, getGasLimits } from '@aztec/aztec.js/contracts';
+import { AccountManager } from '@aztec/aztec.js/wallet';
+import { Fr } from '@aztec/foundation/curves/bn254';
+import { createPXE, getPXEConfig } from '@aztec/pxe/server';
+import { AztecAddress } from '@aztec/stdlib/aztec-address';
+import { deriveSigningKey } from '@aztec/stdlib/keys';
+import { ExecutionPayload, mergeExecutionPayloads } from '@aztec/stdlib/tx';
+import { BaseWallet } from '@aztec/wallet-sdk/base-wallet';
+import { extractECDSAPublicKeyFromBase64String } from './ecdsa.js';
+import { printGasEstimates } from './options/fees.js';
+export class CLIWallet extends BaseWallet {
+    userLog;
+    db;
+    accountCache;
+    constructor(pxe, node, userLog, db){
+        super(pxe, node), this.userLog = userLog, this.db = db, this.accountCache = new Map();
+        this.cancellableTransactions = true;
+    }
+    static async create(node, log, db, overridePXEConfig) {
+        const pxeConfig = Object.assign(getPXEConfig(), overridePXEConfig);
+        const pxe = await createPXE(node, pxeConfig);
+        return new CLIWallet(pxe, node, log, db);
+    }
+    async getAccounts() {
+        const accounts = await this.db?.listAliases('accounts') ?? [];
+        return Promise.resolve(accounts.map(({ key, value })=>({
+                alias: value,
+                item: AztecAddress.fromString(key)
+            })));
+    }
+    async createCancellationTxExecutionRequest(from, txNonce, increasedFee) {
+        const executionPayload = ExecutionPayload.empty();
+        const feeOptions = await this.completeFeeOptions(from, executionPayload.feePayer, increasedFee.gasSettings);
+        const feeExecutionPayload = await feeOptions.walletFeePaymentMethod?.getExecutionPayload();
+        const fromAccount = await this.getAccountFromAddress(from);
+        const chainInfo = await this.getChainInfo();
+        const executionOptions = {
+            txNonce,
+            cancellable: this.cancellableTransactions,
+            feePaymentMethodOptions: feeOptions.accountFeePaymentMethodOptions
+        };
+        return await fromAccount.createTxExecutionRequest(feeExecutionPayload ?? executionPayload, feeOptions.gasSettings, chainInfo, executionOptions);
+    }
+    async proveCancellationTx(from, txNonce, increasedFee) {
+        const cancellationTxRequest = await this.createCancellationTxExecutionRequest(from, txNonce, increasedFee);
+        return await this.pxe.proveTx(cancellationTxRequest);
+    }
+    async getAccountFromAddress(address) {
+        let account;
+        if (address.equals(AztecAddress.ZERO)) {
+            account = new SignerlessAccount();
+        } else if (this.accountCache.has(address.toString())) {
+            return this.accountCache.get(address.toString());
+        } else {
+            const accountManager = await this.createOrRetrieveAccount(address);
+            account = await accountManager.getAccount();
+        }
+        if (!account) {
+            throw new Error(`Account not found in wallet for address: ${address}`);
+        }
+        return account;
+    }
+    async createAccount(secret, salt, contract) {
+        const accountManager = await AccountManager.create(this, secret, contract, salt);
+        const instance = accountManager.getInstance();
+        const artifact = await contract.getContractArtifact();
+        await this.registerContract(instance, artifact, secret);
+        this.accountCache.set(accountManager.address.toString(), await accountManager.getAccount());
+        return accountManager;
+    }
+    async createOrRetrieveAccount(address, secretKey, type = 'schnorr', salt, publicKey) {
+        let account;
+        salt ??= Fr.ZERO;
+        if (this.db && address) {
+            ({ type, secretKey, salt } = await this.db.retrieveAccount(address));
+        }
+        if (!secretKey) {
+            throw new Error('Cannot retrieve/create wallet without secret key');
+        }
+        switch(type){
+            case 'schnorr':
+                {
+                    account = await this.createAccount(secretKey, salt, new SchnorrAccountContract(deriveSigningKey(secretKey)));
+                    break;
+                }
+            case 'ecdsasecp256r1':
+                {
+                    account = await this.createAccount(secretKey, salt, new EcdsaRAccountContract(deriveSigningKey(secretKey).toBuffer()));
+                    break;
+                }
+            case 'ecdsasecp256r1ssh':
+                {
+                    let publicSigningKey;
+                    if (this.db && address) {
+                        publicSigningKey = await this.db.retrieveAccountMetadata(address, 'publicSigningKey');
+                    } else if (publicKey) {
+                        const identities = await getIdentities();
+                        const foundIdentity = identities.find((identity)=>identity.type === 'ecdsa-sha2-nistp256' && identity.publicKey === publicKey);
+                        if (!foundIdentity) {
+                            throw new Error(`Identity for public key ${publicKey} not found in the SSH agent`);
+                        }
+                        publicSigningKey = extractECDSAPublicKeyFromBase64String(foundIdentity.publicKey);
+                    } else {
+                        throw new Error('Public key must be provided for ECDSA SSH account');
+                    }
+                    account = await this.createAccount(secretKey, salt, new EcdsaRSSHAccountContract(publicSigningKey));
+                    break;
+                }
+            default:
+                {
+                    throw new Error(`Unsupported account type: ${type}`);
+                }
+        }
+        return account;
+    }
+    /**
+   * Creates a stub account that impersonates the given address, allowing kernelless simulations
+   * to bypass the account's authorization mechanisms via contract overrides.
+   * @param address - The address of the account to impersonate
+   * @returns The stub account, contract instance, and artifact for simulation
+   */ async getFakeAccountDataFor(address) {
+        const originalAccount = await this.getAccountFromAddress(address);
+        // Account contracts can only be overridden if they have an associated address
+        // Overwriting SignerlessAccount is not supported, and does not really make sense
+        // since it has no authorization mechanism.
+        if (originalAccount instanceof SignerlessAccount) {
+            throw new Error(`Cannot create fake account data for SignerlessAccount at address: ${address}`);
+        }
+        const originalAddress = originalAccount.getCompleteAddress();
+        const contractInstance = await this.pxe.getContractInstance(originalAddress.address);
+        if (!contractInstance) {
+            throw new Error(`No contract instance found for address: ${originalAddress.address}`);
+        }
+        const stubAccount = createStubAccount(originalAddress);
+        const instance = await getContractInstanceFromInstantiationParams(StubAccountContractArtifact, {
+            salt: Fr.random()
+        });
+        return {
+            account: stubAccount,
+            instance,
+            artifact: StubAccountContractArtifact
+        };
+    }
+    async simulateTx(executionPayload, opts) {
+        let simulationResults;
+        const feeOptions = opts.fee?.estimateGas ? await this.completeFeeOptionsForEstimation(opts.from, executionPayload.feePayer, opts.fee?.gasSettings) : await this.completeFeeOptions(opts.from, executionPayload.feePayer, opts.fee?.gasSettings);
+        const feeExecutionPayload = await feeOptions.walletFeePaymentMethod?.getExecutionPayload();
+        const chainInfo = await this.getChainInfo();
+        const executionOptions = {
+            txNonce: Fr.random(),
+            cancellable: this.cancellableTransactions,
+            feePaymentMethodOptions: feeOptions.accountFeePaymentMethodOptions
+        };
+        const finalExecutionPayload = feeExecutionPayload ? mergeExecutionPayloads([
+            feeExecutionPayload,
+            executionPayload
+        ]) : executionPayload;
+        // Kernelless simulations using the multicall entrypoints are not currently supported,
+        // since we only override proper account contracts.
+        // TODO: allow disabling kernels even when no overrides are necessary
+        if (opts.from.equals(AztecAddress.ZERO)) {
+            const fromAccount = await this.getAccountFromAddress(opts.from);
+            const txRequest = await fromAccount.createTxExecutionRequest(finalExecutionPayload, feeOptions.gasSettings, chainInfo, executionOptions);
+            simulationResults = await this.pxe.simulateTx(txRequest, true, opts?.skipTxValidation, opts?.skipFeeEnforcement ?? true);
+        } else {
+            const { account: fromAccount, instance, artifact } = await this.getFakeAccountDataFor(opts.from);
+            const txRequest = await fromAccount.createTxExecutionRequest(finalExecutionPayload, feeOptions.gasSettings, chainInfo, executionOptions);
+            const contractOverrides = {
+                [opts.from.toString()]: {
+                    instance,
+                    artifact
+                }
+            };
+            simulationResults = await this.pxe.simulateTx(txRequest, true, true, true, {
+                contracts: contractOverrides
+            });
+        }
+        if (opts.fee?.estimateGas) {
+            const limits = getGasLimits(simulationResults, opts.fee?.estimatedGasPadding);
+            printGasEstimates(feeOptions, limits, this.userLog);
+        }
+        return simulationResults;
+    }
+    // Exposed because of the `aztec-wallet get-tx` command. It has been decided that it's fine to keep around because
+    // this is just a CLI wallet.
+    getContracts() {
+        return this.pxe.getContracts();
+    }
+    // Exposed because of the `aztec-wallet get-tx` command. It has been decided that it's fine to keep around because
+    // this is just a CLI wallet.
+    getNotes(filter) {
+        return this.pxe.debug.getNotes(filter);
+    }
+    // Exposed because of the `aztec-wallet get-tx` command. It has been decided that it's fine to keep around because
+    // this is just a CLI wallet.
+    getContractArtifact(id) {
+        return this.pxe.getContractArtifact(id);
+    }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@aztec/cli-wallet",
-  "version": "0.0.0-test.0",
+  "version": "0.0.1-commit.0208eb9",
   "type": "module",
   "exports": {
     ".": "./dest/cmds/index.js",
@@ -20,11 +20,9 @@
     "start": "node --no-warnings ./dest/bin",
     "start:debug": "node --inspect=0.0.0.0:9221 --no-warnings ./dest/bin",
     "dev": "LOG_LEVEL=debug && node ./dest/bin",
-    "build": "yarn clean && tsc -b",
-    "build:dev": "tsc -b --watch",
+    "build": "yarn clean && ../scripts/tsc.sh",
+    "build:dev": "../scripts/tsc.sh --watch",
     "clean": "rm -rf ./dest .tsbuildinfo",
-    "formatting": "run -T prettier --check ./src && run -T eslint ./src",
-    "formatting:fix": "run -T eslint --fix ./src && run -T prettier -w ./src",
     "test": "NODE_NO_WARNINGS=1 node --experimental-vm-modules ../node_modules/.bin/jest --passWithNoTests --maxWorkers=${JEST_MAX_WORKERS:-8}"
   },
   "inherits": [
@@ -62,33 +60,42 @@
     "testTimeout": 120000,
     "setupFiles": [
       "../../foundation/src/jest/setup.mjs"
+    ],
+    "testEnvironment": "../../foundation/src/jest/env.mjs",
+    "setupFilesAfterEnv": [
+      "../../foundation/src/jest/setupAfterEnv.mjs"
     ]
   },
   "dependencies": {
-    "@aztec/accounts": "0.0.0-test.0",
-    "@aztec/aztec.js": "0.0.0-test.0",
-    "@aztec/cli": "0.0.0-test.0",
-    "@aztec/ethereum": "0.0.0-test.0",
-    "@aztec/foundation": "0.0.0-test.0",
-    "@aztec/kv-store": "0.0.0-test.0",
-    "@aztec/noir-contracts.js": "0.0.0-test.0",
-    "@aztec/pxe": "0.0.0-test.0",
-    "@aztec/stdlib": "0.0.0-test.0",
+    "@aztec/accounts": "0.0.1-commit.0208eb9",
+    "@aztec/aztec.js": "0.0.1-commit.0208eb9",
+    "@aztec/bb.js": "0.0.1-commit.0208eb9",
+    "@aztec/cli": "0.0.1-commit.0208eb9",
+    "@aztec/entrypoints": "0.0.1-commit.0208eb9",
+    "@aztec/ethereum": "0.0.1-commit.0208eb9",
+    "@aztec/foundation": "0.0.1-commit.0208eb9",
+    "@aztec/kv-store": "0.0.1-commit.0208eb9",
+    "@aztec/noir-contracts.js": "0.0.1-commit.0208eb9",
+    "@aztec/noir-noirc_abi": "0.0.1-commit.0208eb9",
+    "@aztec/pxe": "0.0.1-commit.0208eb9",
+    "@aztec/stdlib": "0.0.1-commit.0208eb9",
+    "@aztec/wallet-sdk": "0.0.1-commit.0208eb9",
     "commander": "^12.1.0",
     "inquirer": "^10.1.8",
     "source-map-support": "^0.5.21",
     "tslib": "^2.4.0"
   },
   "devDependencies": {
-    "@jest/globals": "^29.5.0",
-    "@types/jest": "^29.5.0",
-    "@types/node": "^18.7.23",
+    "@jest/globals": "^30.0.0",
+    "@types/jest": "^30.0.0",
+    "@types/node": "^22.15.17",
     "@types/source-map-support": "^0.5.10",
-    "jest": "^29.5.0",
-    "jest-mock-extended": "^3.0.5",
-    "ts-jest": "^29.1.0",
+    "@typescript/native-preview": "7.0.0-dev.20260113.1",
+    "jest": "^30.0.0",
+    "jest-mock-extended": "^4.0.0",
+    "ts-jest": "^29.4.0",
     "ts-node": "^10.9.1",
-    "typescript": "^5.0.4"
+    "typescript": "^5.3.3"
   },
   "files": [
     "dest",
@@ -97,6 +104,6 @@
   ],
   "types": "./dest/index.d.ts",
   "engines": {
-    "node": ">=18"
+    "node": ">=20.10"
   }
 }

package/src/bin/index.ts

@@ -1,24 +1,31 @@
-import { Fr, computeSecretHash, fileURLToPath } from '@aztec/aztec.js';
+#!/usr/bin/env node
+import { computeSecretHash } from '@aztec/aztec.js/crypto';
+import { Fr } from '@aztec/aztec.js/fields';
+import { createAztecNodeClient } from '@aztec/aztec.js/node';
+import { ProtocolContractAddress } from '@aztec/aztec.js/protocol';
+import { BackendType, Barretenberg } from '@aztec/bb.js';
 import { LOCALHOST } from '@aztec/cli/cli-utils';
 import { type LogFn, createConsoleLogger, createLogger } from '@aztec/foundation/log';
 import { openStoreAt } from '@aztec/kv-store/lmdb-v2';
-import type { PXEServiceConfig } from '@aztec/pxe/config';
+import type { PXEConfig } from '@aztec/pxe/config';
+import { getPackageVersion } from '@aztec/stdlib/update-checker';
 
 import { Argument, Command, Option } from 'commander';
-import { mkdirSync, readFileSync } from 'fs';
 import { homedir } from 'os';
-import { dirname, join, resolve } from 'path';
+import { join } from 'path';
 
 import { injectCommands } from '../cmds/index.js';
 import { Aliases, WalletDB } from '../storage/wallet_db.js';
+import { CliWalletAndNodeWrapper } from '../utils/cli_wallet_and_node_wrapper.js';
 import { createAliasOption } from '../utils/options/index.js';
-import { PXEWrapper } from '../utils/pxe_wrapper.js';
+import { CLIWallet } from '../utils/wallet.js';
 
 const userLog = createConsoleLogger();
 const debugLogger = createLogger('wallet');
 
-const { WALLET_DATA_DIRECTORY = join(homedir(), '.aztec/wallet'), PXE_PROVER = 'none' } = process.env;
+const { WALLET_DATA_DIRECTORY = join(homedir(), '.aztec/wallet') } = process.env;
 
+// TODO: This function is only used in 1 place so we could just inline this
 function injectInternalCommands(program: Command, log: LogFn, db: WalletDB) {
   program
     .command('alias')
@@ -55,7 +62,7 @@ function injectInternalCommands(program: Command, log: LogFn, db: WalletDB) {
       const options = command.optsWithGlobals();
       const { alias } = options;
       const value = Fr.random();
-      const hash = computeSecretHash(value);
+      const hash = await computeSecretHash(value);
 
       await db.storeAlias('secrets', alias, Buffer.from(value.toString()), log);
       await db.storeAlias('secrets', `${alias}:hash`, Buffer.from(hash.toString()), log);
@@ -66,23 +73,21 @@ function injectInternalCommands(program: Command, log: LogFn, db: WalletDB) {
 
 /** CLI wallet main entrypoint */
 async function main() {
-  const packageJsonPath = resolve(dirname(fileURLToPath(import.meta.url)), '../../package.json');
-  const walletVersion: string = JSON.parse(readFileSync(packageJsonPath).toString()).version;
+  const walletVersion = getPackageVersion() ?? '0.0.0';
 
   const db = WalletDB.getInstance();
-  const pxeWrapper = new PXEWrapper();
+  const walletAndNodeWrapper = new CliWalletAndNodeWrapper();
 
   const program = new Command('wallet');
   program
     .description('Aztec wallet')
     .version(walletVersion)
     .option('-d, --data-dir <string>', 'Storage directory for wallet data', WALLET_DATA_DIRECTORY)
-    .option('-p, --prover <string>', 'wasm|native|none', PXE_PROVER)
     .addOption(
-      new Option('--remote-pxe', 'Connect to an external PXE RPC server, instead of the local one')
-        .env('REMOTE_PXE')
-        .default(false)
-        .conflicts('rpc-url'),
+      new Option('-p, --prover <string>', 'The type of prover the wallet uses')
+        .choices(['wasm', 'native', 'none'])
+        .env('PXE_PROVER')
+        .default('native'),
     )
     .addOption(
       new Option('-n, --node-url <string>', 'URL of the Aztec node to connect to')
@@ -90,34 +95,59 @@ async function main() {
         .default(`http://${LOCALHOST}:8080`),
     )
     .hook('preSubcommand', async command => {
-      const { dataDir, remotePxe, nodeUrl, prover } = command.optsWithGlobals();
+      // Skip initialization if user is just requesting help
+      if (command.args.includes('--help') || command.args.includes('-h')) {
+        return;
+      }
+
+      const { dataDir, nodeUrl, prover } = command.optsWithGlobals();
 
-      if (!remotePxe) {
-        debugLogger.info('Using local PXE service');
+      const proverEnabled = prover !== 'none';
 
-        const proverEnabled = prover !== 'none';
+      switch (prover) {
+        case 'native':
+          await Barretenberg.initSingleton({ backend: BackendType.NativeUnixSocket });
+          break;
+        case 'wasm':
+          await Barretenberg.initSingleton({ backend: BackendType.Wasm });
+          break;
+      }
 
-        const bbBinaryPath =
-          prover === 'native'
-            ? resolve(dirname(fileURLToPath(import.meta.url)), '../../../../barretenberg/cpp/build/bin/bb')
-            : undefined;
-        const bbWorkingDirectory = dataDir + '/bb';
-        mkdirSync(bbWorkingDirectory, { recursive: true });
+      const overridePXEConfig: Partial<PXEConfig> = {
+        proverEnabled,
+        dataDirectory: join(dataDir, 'pxe'),
+      };
 
-        const overridePXEConfig: Partial<PXEServiceConfig> = {
-          proverEnabled,
-          bbBinaryPath: prover === 'native' ? bbBinaryPath : undefined,
-          bbWorkingDirectory: prover === 'native' ? bbWorkingDirectory : undefined,
-        };
+      const node = createAztecNodeClient(nodeUrl);
+      const wallet = await CLIWallet.create(node, userLog, db, overridePXEConfig);
+
+      walletAndNodeWrapper.setNodeAndWallet(node, wallet);
 
-        await pxeWrapper.init(nodeUrl, join(dataDir, 'pxe'), overridePXEConfig);
-      }
       await db.init(await openStoreAt(dataDir));
+      let protocolContractsRegistered;
+      try {
+        protocolContractsRegistered = !!(await db.retrieveAlias('contracts:ContractClassRegistry'));
+        // eslint-disable-next-line no-empty
+      } catch {}
+      if (!protocolContractsRegistered) {
+        userLog('Registering protocol contract aliases...');
+        for (const [name, address] of Object.entries(ProtocolContractAddress)) {
+          await db.storeAlias('contracts', name, Buffer.from(address.toString()), userLog);
+          await db.storeAlias(
+            'artifacts',
+            address.toString(),
+            Buffer.from(`${name.slice(0, 1).toUpperCase()}${name.slice(1)}`),
+            userLog,
+          );
+        }
+      }
     });
 
-  injectCommands(program, userLog, debugLogger, db, pxeWrapper);
+  injectCommands(program, userLog, debugLogger, walletAndNodeWrapper, db);
   injectInternalCommands(program, userLog, db);
   await program.parseAsync(process.argv);
+
+  await Barretenberg.destroySingleton();
 }
 
 main().catch(err => {

package/src/cmds/authorize_action.ts

@@ -1,9 +1,15 @@
-import { type AccountWalletWithSecretKey, type AztecAddress, Contract } from '@aztec/aztec.js';
+import type { AztecAddress } from '@aztec/aztec.js/addresses';
+import { SetPublicAuthwitContractInteraction } from '@aztec/aztec.js/authorization';
+import { Contract } from '@aztec/aztec.js/contracts';
+import type { Wallet } from '@aztec/aztec.js/wallet';
 import { prepTx } from '@aztec/cli/utils';
 import type { LogFn } from '@aztec/foundation/log';
 
+import { DEFAULT_TX_TIMEOUT_S } from '../utils/cli_wallet_and_node_wrapper.js';
+
 export async function authorizeAction(
-  wallet: AccountWalletWithSecretKey,
+  wallet: Wallet,
+  from: AztecAddress,
   functionName: string,
   caller: AztecAddress,
   functionArgsIn: any[],
@@ -24,11 +30,16 @@ export async function authorizeAction(
     );
   }
 
-  const contract = await Contract.at(contractAddress, contractArtifact, wallet);
+  const contract = Contract.at(contractAddress, contractArtifact, wallet);
   const action = contract.methods[functionName](...functionArgs);
 
-  const setAuthwitnessInteraction = await wallet.setPublicAuthWit({ caller, action }, true);
-  const witness = await setAuthwitnessInteraction.send().wait();
+  const setAuthwitnessInteraction = await SetPublicAuthwitContractInteraction.create(
+    wallet,
+    from,
+    { caller, action },
+    true,
+  );
+  const witness = await setAuthwitnessInteraction.send({ wait: { timeout: DEFAULT_TX_TIMEOUT_S } });
 
   log(`Authorized action ${functionName} on contract ${contractAddress} for caller ${caller}`);
 

package/src/cmds/bridge_fee_juice.ts

@@ -1,14 +1,18 @@
-import { L1FeeJuicePortalManager, type PXE } from '@aztec/aztec.js';
+import { L1FeeJuicePortalManager } from '@aztec/aztec.js/ethereum';
+import type { AztecNode } from '@aztec/aztec.js/node';
+import { ProtocolContractAddress } from '@aztec/aztec.js/protocol';
 import { prettyPrintJSON } from '@aztec/cli/utils';
-import { createEthereumChain, createL1Clients } from '@aztec/ethereum';
-import { Fr } from '@aztec/foundation/fields';
+import { createEthereumChain } from '@aztec/ethereum/chain';
+import { createExtendedL1Client } from '@aztec/ethereum/client';
+import { Fr } from '@aztec/foundation/curves/bn254';
 import type { LogFn, Logger } from '@aztec/foundation/log';
 import type { AztecAddress } from '@aztec/stdlib/aztec-address';
+import { getNonNullifiedL1ToL2MessageWitness } from '@aztec/stdlib/messaging';
 
 export async function bridgeL1FeeJuice(
   amount: bigint,
   recipient: AztecAddress,
-  pxe: PXE,
+  node: AztecNode,
   l1RpcUrls: string[],
   chainId: number,
   privateKey: string | undefined,
@@ -22,14 +26,10 @@ export async function bridgeL1FeeJuice(
 ) {
   // Prepare L1 client
   const chain = createEthereumChain(l1RpcUrls, chainId);
-  const { publicClient, walletClient } = createL1Clients(chain.rpcUrls, privateKey ?? mnemonic, chain.chainInfo);
-
-  const {
-    protocolContractAddresses: { feeJuice: feeJuiceAddress },
-  } = await pxe.getPXEInfo();
+  const client = createExtendedL1Client(chain.rpcUrls, privateKey ?? mnemonic, chain.chainInfo);
 
   // Setup portal manager
-  const portal = await L1FeeJuicePortalManager.new(pxe, publicClient, walletClient, debugLogger);
+  const portal = await L1FeeJuicePortalManager.new(node, client, debugLogger);
   const { claimAmount, claimSecret, messageHash, messageLeafIndex } = await portal.bridgeTokensPublic(
     recipient,
     amount,
@@ -66,8 +66,12 @@ export async function bridgeL1FeeJuice(
     const delayedCheck = (delay: number) => {
       return new Promise((resolve, reject) => {
         setTimeout(() => {
-          void pxe
-            .getL1ToL2MembershipWitness(feeJuiceAddress, Fr.fromHexString(messageHash), claimSecret)
+          void getNonNullifiedL1ToL2MessageWitness(
+            node,
+            ProtocolContractAddress.FeeJuice,
+            Fr.fromHexString(messageHash),
+            claimSecret,
+          )
             .then(witness => resolve(witness))
             .catch(err => reject(err));
         }, delay);