@aztec/aztec.js 0.73.0 → 0.75.0-commit.c03ba01a2a4122e43e90d5133ba017e54b90e9d2

package/dest/api/ethereum/cheat_codes.js

@@ -0,0 +1,142 @@
+import { EthAddress } from '@aztec/circuits.js';
+import { EthCheatCodes } from '@aztec/ethereum/eth-cheatcodes';
+import { createLogger } from '@aztec/foundation/log';
+import { RollupAbi } from '@aztec/l1-artifacts';
+import { createWalletClient, getContract, http, publicActions } from 'viem';
+import { foundry } from 'viem/chains';
+export { EthCheatCodes };
+/** Cheat codes for the L1 rollup contract. */ export class RollupCheatCodes {
+    ethCheatCodes;
+    client;
+    rollup;
+    logger;
+    constructor(ethCheatCodes, addresses){
+        this.ethCheatCodes = ethCheatCodes;
+        this.logger = createLogger('aztecjs:cheat_codes');
+        this.client = createWalletClient({
+            chain: foundry,
+            transport: http(ethCheatCodes.rpcUrl)
+        }).extend(publicActions);
+        this.rollup = getContract({
+            abi: RollupAbi,
+            address: addresses.rollupAddress.toString(),
+            client: this.client
+        });
+    }
+    /** Returns the current slot */ async getSlot() {
+        const ts = BigInt((await this.client.getBlock()).timestamp);
+        return await this.rollup.read.getSlotAt([
+            ts
+        ]);
+    }
+    /** Returns the current epoch */ async getEpoch() {
+        const slotNumber = await this.getSlot();
+        return await this.rollup.read.getEpochAtSlot([
+            slotNumber
+        ]);
+    }
+    /**
+   * Returns the pending and proven chain tips
+   * @returns The pending and proven chain tips
+   */ async getTips() {
+        const res = await this.rollup.read.getTips();
+        return {
+            pending: res.pendingBlockNumber,
+            proven: res.provenBlockNumber
+        };
+    }
+    /** Fetches the epoch and slot duration config from the rollup contract */ async getConfig() {
+        const [epochDuration, slotDuration] = await Promise.all([
+            this.rollup.read.getEpochDuration(),
+            this.rollup.read.getSlotDuration()
+        ]);
+        return {
+            epochDuration,
+            slotDuration
+        };
+    }
+    /** Warps time in L1 until the next epoch */ async advanceToNextEpoch() {
+        const slot = await this.getSlot();
+        const { epochDuration, slotDuration } = await this.getConfig();
+        const slotsUntilNextEpoch = epochDuration - slot % epochDuration + 1n;
+        const timeToNextEpoch = slotsUntilNextEpoch * slotDuration;
+        const l1Timestamp = BigInt((await this.client.getBlock()).timestamp);
+        await this.ethCheatCodes.warp(Number(l1Timestamp + timeToNextEpoch), true);
+        this.logger.warn(`Advanced to next epoch`);
+    }
+    /** Warps time in L1 until the beginning of the next slot. */ async advanceToNextSlot() {
+        const currentSlot = await this.getSlot();
+        const timestamp = await this.rollup.read.getTimestampForSlot([
+            currentSlot + 1n
+        ]);
+        await this.ethCheatCodes.warp(Number(timestamp));
+        this.logger.warn(`Advanced to slot ${currentSlot + 1n}`);
+        return [
+            timestamp,
+            currentSlot + 1n
+        ];
+    }
+    /**
+   * Warps time in L1 equivalent to however many slots.
+   * @param howMany - The number of slots to advance.
+   */ async advanceSlots(howMany) {
+        const l1Timestamp = (await this.client.getBlock()).timestamp;
+        const slotDuration = await this.rollup.read.getSlotDuration();
+        const timeToWarp = BigInt(howMany) * slotDuration;
+        await this.ethCheatCodes.warp(l1Timestamp + timeToWarp, true);
+        const [slot, epoch] = await Promise.all([
+            this.getSlot(),
+            this.getEpoch()
+        ]);
+        this.logger.warn(`Advanced ${howMany} slots up to slot ${slot} in epoch ${epoch}`);
+    }
+    /** Returns the current proof claim (if any) */ async getProofClaim() {
+        // REFACTOR: This code is duplicated from l1-publisher
+        const { epochToProve, basisPointFee, bondAmount, bondProvider: bondProviderHex, proposerClaimant: proposerClaimantHex } = await this.rollup.read.getProofClaim();
+        const bondProvider = EthAddress.fromString(bondProviderHex);
+        const proposerClaimant = EthAddress.fromString(proposerClaimantHex);
+        if (bondProvider.isZero() && proposerClaimant.isZero() && epochToProve === 0n) {
+            return undefined;
+        }
+        return {
+            epochToProve,
+            basisPointFee,
+            bondAmount,
+            bondProvider,
+            proposerClaimant
+        };
+    }
+    /**
+   * Marks the specified block (or latest if none) as proven
+   * @param maybeBlockNumber - The block number to mark as proven (defaults to latest pending)
+   */ async markAsProven(maybeBlockNumber) {
+        const blockNumber = maybeBlockNumber ? BigInt(maybeBlockNumber) : await this.rollup.read.getTips().then(({ pendingBlockNumber })=>pendingBlockNumber);
+        await this.asOwner(async (account)=>{
+            await this.rollup.write.setAssumeProvenThroughBlockNumber([
+                blockNumber
+            ], {
+                account,
+                chain: this.client.chain
+            });
+            this.logger.warn(`Marked ${blockNumber} as proven`);
+        });
+    }
+    /**
+   * Executes an action impersonated as the owner of the Rollup contract.
+   * @param action - The action to execute
+   */ async asOwner(action) {
+        const owner = await this.rollup.read.owner();
+        await this.ethCheatCodes.startImpersonating(owner);
+        await action(owner, this.rollup);
+        await this.ethCheatCodes.stopImpersonating(owner);
+    }
+    /** Directly calls the L1 gas fee oracle. */ async updateL1GasFeeOracle() {
+        await this.asOwner(async (account, rollup)=>{
+            await rollup.write.updateL1GasFeeOracle({
+                account,
+                chain: this.client.chain
+            });
+            this.logger.warn(`Updated L1 gas fee oracle`);
+        });
+    }
+}

package/dest/api/ethereum/index.js

@@ -0,0 +1,6 @@
+export { L1FeeJuicePortalManager, L1ToL2TokenPortalManager, L1TokenManager, L1TokenPortalManager, generateClaimSecret } from './portal_manager.js';
+export { getL1ContractAddresses } from './l1_contracts.js';
+export { RollupCheatCodes, EthCheatCodes } from './cheat_codes.js';
+export { ChainMonitor } from './chain_monitor.js';
+export { AnvilTestWatcher } from './anvil_test_watcher.js';
+export { deployL1Contract, deployL1Contracts, DeployL1Contracts } from '@aztec/ethereum/deploy-l1-contracts';

package/dest/api/ethereum/l1_contracts.js

@@ -0,0 +1,13 @@
+import { retryUntil } from '@aztec/foundation/retry';
+import { createPXEClient } from '../../rpc_clients/index.js';
+export const getL1ContractAddresses = async (url)=>{
+    const pxeClient = createPXEClient(url);
+    const response = await retryUntil(async ()=>{
+        try {
+            return (await pxeClient.getNodeInfo()).l1ContractAddresses;
+        } catch (err) {
+        // do nothing
+        }
+    }, 'isNodeReady', 120, 1);
+    return response;
+};

package/dest/api/ethereum/portal_manager.js

@@ -0,0 +1,284 @@
+import { EthAddress, Fr } from '@aztec/circuits.js';
+import { computeSecretHash } from '@aztec/circuits.js/hash';
+import { extractEvent } from '@aztec/ethereum/utils';
+import { sha256ToField } from '@aztec/foundation/crypto';
+import { FeeJuicePortalAbi, OutboxAbi, TestERC20Abi, TokenPortalAbi } from '@aztec/l1-artifacts';
+import { getContract, toFunctionSelector } from 'viem';
+/** Stringifies an eth address for logging. */ function stringifyEthAddress(address, name) {
+    return name ? `${name} (${address.toString()})` : address.toString();
+}
+/** Generates a pair secret and secret hash */ export async function generateClaimSecret(logger) {
+    const secret = Fr.random();
+    const secretHash = await computeSecretHash(secret);
+    logger?.verbose(`Generated claim secret=${secret.toString()} hash=${secretHash.toString()}`);
+    return [
+        secret,
+        secretHash
+    ];
+}
+/** Helper for managing an ERC20 on L1. */ export class L1TokenManager {
+    address;
+    publicClient;
+    walletClient;
+    logger;
+    contract;
+    constructor(/** Address of the ERC20 contract. */ address, publicClient, walletClient, logger){
+        this.address = address;
+        this.publicClient = publicClient;
+        this.walletClient = walletClient;
+        this.logger = logger;
+        this.contract = getContract({
+            address: this.address.toString(),
+            abi: TestERC20Abi,
+            client: this.walletClient
+        });
+    }
+    /**
+   * Returns the balance of the given address.
+   * @param address - Address to get the balance of.
+   */ async getL1TokenBalance(address) {
+        return await this.contract.read.balanceOf([
+            address
+        ]);
+    }
+    /**
+   * Mints tokens for the given address. Returns once the tx has been mined.
+   * @param amount - Amount to mint.
+   * @param address - Address to mint the tokens for.
+   * @param addressName - Optional name of the address for logging.
+   */ async mint(amount, address, addressName) {
+        this.logger.info(`Minting ${amount} tokens for ${stringifyEthAddress(address, addressName)}`);
+        await this.publicClient.waitForTransactionReceipt({
+            hash: await this.contract.write.mint([
+                address,
+                amount
+            ])
+        });
+    }
+    /**
+   * Approves tokens for the given address. Returns once the tx has been mined.
+   * @param amount - Amount to approve.
+   * @param address - Address to approve the tokens for.
+   * @param addressName - Optional name of the address for logging.
+   */ async approve(amount, address, addressName = '') {
+        this.logger.info(`Approving ${amount} tokens for ${stringifyEthAddress(address, addressName)}`);
+        await this.publicClient.waitForTransactionReceipt({
+            hash: await this.contract.write.approve([
+                address,
+                amount
+            ])
+        });
+    }
+}
+/** Helper for interacting with the FeeJuicePortal on L1. */ export class L1FeeJuicePortalManager {
+    publicClient;
+    walletClient;
+    logger;
+    tokenManager;
+    contract;
+    constructor(portalAddress, tokenAddress, publicClient, walletClient, logger){
+        this.publicClient = publicClient;
+        this.walletClient = walletClient;
+        this.logger = logger;
+        this.tokenManager = new L1TokenManager(tokenAddress, publicClient, walletClient, logger);
+        this.contract = getContract({
+            address: portalAddress.toString(),
+            abi: FeeJuicePortalAbi,
+            client: this.walletClient
+        });
+    }
+    /** Returns the associated token manager for the L1 ERC20. */ getTokenManager() {
+        return this.tokenManager;
+    }
+    /**
+   * Bridges fee juice from L1 to L2 publicly. Handles L1 ERC20 approvals. Returns once the tx has been mined.
+   * @param to - Address to send the tokens to on L2.
+   * @param amount - Amount of tokens to send.
+   * @param mint - Whether to mint the tokens before sending (only during testing).
+   */ async bridgeTokensPublic(to, amount, mint = false) {
+        const [claimSecret, claimSecretHash] = await generateClaimSecret();
+        if (mint) {
+            await this.tokenManager.mint(amount, this.walletClient.account.address);
+        }
+        await this.tokenManager.approve(amount, this.contract.address, 'FeeJuice Portal');
+        this.logger.info('Sending L1 Fee Juice to L2 to be claimed publicly');
+        const args = [
+            to.toString(),
+            amount,
+            claimSecretHash.toString()
+        ];
+        await this.contract.simulate.depositToAztecPublic(args);
+        const txReceipt = await this.publicClient.waitForTransactionReceipt({
+            hash: await this.contract.write.depositToAztecPublic(args)
+        });
+        const log = extractEvent(txReceipt.logs, this.contract.address, this.contract.abi, 'DepositToAztecPublic', (log)=>log.args.secretHash === claimSecretHash.toString() && log.args.amount === amount && log.args.to === to.toString(), this.logger);
+        return {
+            claimAmount: amount,
+            claimSecret,
+            claimSecretHash,
+            messageHash: log.args.key,
+            messageLeafIndex: log.args.index
+        };
+    }
+    /**
+   * Creates a new instance
+   * @param pxe - PXE client used for retrieving the L1 contract addresses.
+   * @param publicClient - L1 public client.
+   * @param walletClient - L1 wallet client.
+   * @param logger - Logger.
+   */ static async new(pxe, publicClient, walletClient, logger) {
+        const { l1ContractAddresses: { feeJuiceAddress, feeJuicePortalAddress } } = await pxe.getNodeInfo();
+        if (feeJuiceAddress.isZero() || feeJuicePortalAddress.isZero()) {
+            throw new Error('Portal or token not deployed on L1');
+        }
+        return new L1FeeJuicePortalManager(feeJuicePortalAddress, feeJuiceAddress, publicClient, walletClient, logger);
+    }
+}
+/** Helper for interacting with a test TokenPortal on L1 for sending tokens to L2. */ export class L1ToL2TokenPortalManager {
+    publicClient;
+    walletClient;
+    logger;
+    portal;
+    tokenManager;
+    constructor(portalAddress, tokenAddress, publicClient, walletClient, logger){
+        this.publicClient = publicClient;
+        this.walletClient = walletClient;
+        this.logger = logger;
+        this.tokenManager = new L1TokenManager(tokenAddress, publicClient, walletClient, logger);
+        this.portal = getContract({
+            address: portalAddress.toString(),
+            abi: TokenPortalAbi,
+            client: this.walletClient
+        });
+    }
+    /** Returns the token manager for the underlying L1 token. */ getTokenManager() {
+        return this.tokenManager;
+    }
+    /**
+   * Bridges tokens from L1 to L2. Handles token approvals. Returns once the tx has been mined.
+   * @param to - Address to send the tokens to on L2.
+   * @param amount - Amount of tokens to send.
+   * @param mint - Whether to mint the tokens before sending (only during testing).
+   */ async bridgeTokensPublic(to, amount, mint = false) {
+        const [claimSecret, claimSecretHash] = await this.bridgeSetup(amount, mint);
+        this.logger.info('Sending L1 tokens to L2 to be claimed publicly');
+        const { request } = await this.portal.simulate.depositToAztecPublic([
+            to.toString(),
+            amount,
+            claimSecretHash.toString()
+        ]);
+        const txReceipt = await this.publicClient.waitForTransactionReceipt({
+            hash: await this.walletClient.writeContract(request)
+        });
+        const log = extractEvent(txReceipt.logs, this.portal.address, this.portal.abi, 'DepositToAztecPublic', (log)=>log.args.secretHash === claimSecretHash.toString() && log.args.amount === amount && log.args.to === to.toString(), this.logger);
+        return {
+            claimAmount: amount,
+            claimSecret,
+            claimSecretHash,
+            messageHash: log.args.key,
+            messageLeafIndex: log.args.index
+        };
+    }
+    /**
+   * Bridges tokens from L1 to L2 privately. Handles token approvals. Returns once the tx has been mined.
+   * @param to - Address to send the tokens to on L2.
+   * @param amount - Amount of tokens to send.
+   * @param mint - Whether to mint the tokens before sending (only during testing).
+   */ async bridgeTokensPrivate(to, amount, mint = false) {
+        const [claimSecret, claimSecretHash] = await this.bridgeSetup(amount, mint);
+        this.logger.info('Sending L1 tokens to L2 to be claimed privately');
+        const { request } = await this.portal.simulate.depositToAztecPrivate([
+            amount,
+            claimSecretHash.toString()
+        ]);
+        const txReceipt = await this.publicClient.waitForTransactionReceipt({
+            hash: await this.walletClient.writeContract(request)
+        });
+        const log = extractEvent(txReceipt.logs, this.portal.address, this.portal.abi, 'DepositToAztecPrivate', (log)=>log.args.amount === amount && log.args.secretHashForL2MessageConsumption === claimSecretHash.toString(), this.logger);
+        this.logger.info(`Claim message secret: ${claimSecret.toString()}, claim message secret hash: ${claimSecretHash.toString()}`);
+        return {
+            claimAmount: amount,
+            claimSecret,
+            claimSecretHash,
+            recipient: to,
+            messageHash: log.args.key,
+            messageLeafIndex: log.args.index
+        };
+    }
+    async bridgeSetup(amount, mint) {
+        if (mint) {
+            await this.tokenManager.mint(amount, this.walletClient.account.address);
+        }
+        await this.tokenManager.approve(amount, this.portal.address, 'TokenPortal');
+        return generateClaimSecret();
+    }
+}
+/** Helper for interacting with a test TokenPortal on L1 for both withdrawing from and bridging to L2. */ export class L1TokenPortalManager extends L1ToL2TokenPortalManager {
+    outbox;
+    constructor(portalAddress, tokenAddress, outboxAddress, publicClient, walletClient, logger){
+        super(portalAddress, tokenAddress, publicClient, walletClient, logger);
+        this.outbox = getContract({
+            address: outboxAddress.toString(),
+            abi: OutboxAbi,
+            client: walletClient
+        });
+    }
+    /**
+   * Withdraws funds from the portal by consuming an L2 to L1 message. Returns once the tx is mined on L1.
+   * @param amount - Amount to withdraw.
+   * @param recipient - Who will receive the funds.
+   * @param blockNumber - L2 block number of the message.
+   * @param messageIndex - Index of the message.
+   * @param siblingPath - Sibling path of the message.
+   */ async withdrawFunds(amount, recipient, blockNumber, messageIndex, siblingPath) {
+        this.logger.info(`Sending L1 tx to consume message at block ${blockNumber} index ${messageIndex} to withdraw ${amount}`);
+        const isConsumedBefore = await this.outbox.read.hasMessageBeenConsumedAtBlockAndIndex([
+            blockNumber,
+            messageIndex
+        ]);
+        if (isConsumedBefore) {
+            throw new Error(`L1 to L2 message at block ${blockNumber} index ${messageIndex} has already been consumed`);
+        }
+        // Call function on L1 contract to consume the message
+        const { request: withdrawRequest } = await this.portal.simulate.withdraw([
+            recipient.toString(),
+            amount,
+            false,
+            BigInt(blockNumber),
+            messageIndex,
+            siblingPath.toBufferArray().map((buf)=>`0x${buf.toString('hex')}`)
+        ]);
+        await this.publicClient.waitForTransactionReceipt({
+            hash: await this.walletClient.writeContract(withdrawRequest)
+        });
+        const isConsumedAfter = await this.outbox.read.hasMessageBeenConsumedAtBlockAndIndex([
+            blockNumber,
+            messageIndex
+        ]);
+        if (!isConsumedAfter) {
+            throw new Error(`L1 to L2 message at block ${blockNumber} index ${messageIndex} not consumed after withdrawal`);
+        }
+    }
+    /**
+   * Computes the L2 to L1 message leaf for the given parameters.
+   * @param amount - Amount to bridge.
+   * @param recipient - Recipient on L1.
+   * @param l2Bridge - Address of the L2 bridge.
+   * @param callerOnL1 - Caller address on L1.
+   */ getL2ToL1MessageLeaf(amount, recipient, l2Bridge, callerOnL1 = EthAddress.ZERO) {
+        const content = sha256ToField([
+            Buffer.from(toFunctionSelector('withdraw(address,uint256,address)').substring(2), 'hex'),
+            recipient.toBuffer32(),
+            new Fr(amount).toBuffer(),
+            callerOnL1.toBuffer32()
+        ]);
+        const leaf = sha256ToField([
+            l2Bridge.toBuffer(),
+            new Fr(1).toBuffer(),
+            EthAddress.fromString(this.portal.address).toBuffer32() ?? Buffer.alloc(32, 0),
+            new Fr(this.publicClient.chain.id).toBuffer(),
+            content.toBuffer()
+        ]);
+        return leaf;
+    }
+}

package/dest/api/fee.js

@@ -3,4 +3,3 @@ export { PrivateFeePaymentMethod } from '../fee/private_fee_payment_method.js';
 export { PublicFeePaymentMethod } from '../fee/public_fee_payment_method.js';
 export { FeeJuicePaymentMethodWithClaim } from '../fee/fee_juice_payment_method_with_claim.js';
 export { NoFeePaymentMethod } from '../fee/no_fee_payment_method.js';
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZmVlLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vc3JjL2FwaS9mZWUudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQ0EsT0FBTyxFQUFFLHFCQUFxQixFQUFFLE1BQU0sb0NBQW9DLENBQUM7QUFDM0UsT0FBTyxFQUFFLHVCQUF1QixFQUFFLE1BQU0sc0NBQXNDLENBQUM7QUFDL0UsT0FBTyxFQUFFLHNCQUFzQixFQUFFLE1BQU0scUNBQXFDLENBQUM7QUFDN0UsT0FBTyxFQUFFLDhCQUE4QixFQUFFLE1BQU0sK0NBQStDLENBQUM7QUFDL0YsT0FBTyxFQUFFLGtCQUFrQixFQUFFLE1BQU0saUNBQWlDLENBQUMifQ==

package/dest/api/fields.js

@@ -1,2 +1 @@
 export { Point, Fr, Fq, GrumpkinScalar } from '@aztec/foundation/fields';
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZmllbGRzLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vc3JjL2FwaS9maWVsZHMudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUFFLEtBQUssRUFBRSxFQUFFLEVBQUUsRUFBRSxFQUFFLGNBQWMsRUFBRSxNQUFNLDBCQUEwQixDQUFDIn0=

package/dest/api/interfaces/pxe.js

@@ -1,2 +1 @@
-export {};
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicHhlLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vc3JjL2FwaS9pbnRlcmZhY2VzL3B4ZS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiIn0=
+export { };

package/dest/api/log.js

@@ -0,0 +1 @@
+export { createLogger } from '@aztec/foundation/log';

package/dest/api/log_id.js

@@ -1,2 +1 @@
 export { LogId } from '@aztec/circuit-types/log_id';
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibG9nX2lkLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vc3JjL2FwaS9sb2dfaWQudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUFFLEtBQUssRUFBRSxNQUFNLDZCQUE2QixDQUFDIn0=

package/dest/api/tx_hash.js

@@ -1,2 +1 @@
 export { TxHash } from '@aztec/circuit-types/tx_hash';
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidHhfaGFzaC5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uL3NyYy9hcGkvdHhfaGFzaC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQUUsTUFBTSxFQUFFLE1BQU0sOEJBQThCLENBQUMifQ==

package/dest/api/wallet.js

@@ -1,2 +1 @@
-export { AccountWallet, AccountWalletWithSecretKey as AccountWalletWithSecretKey, SignerlessWallet, getWallet, } from '../wallet/index.js';
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoid2FsbGV0LmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vc3JjL2FwaS93YWxsZXQudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUNMLGFBQWEsRUFDYiwwQkFBMEIsSUFBSSwwQkFBMEIsRUFDeEQsZ0JBQWdCLEVBRWhCLFNBQVMsR0FDVixNQUFNLG9CQUFvQixDQUFDIn0=
+export { AccountWallet, AccountWalletWithSecretKey as AccountWalletWithSecretKey, SignerlessWallet, getWallet } from '../wallet/index.js';