@aztec/aztec.js 0.0.0-test.1 → 0.0.1-commit.1142ef1

package/src/utils/aztec_cheatcodes.ts

@@ -1,77 +0,0 @@
-import { Fr } from '@aztec/foundation/fields';
-import { createLogger } from '@aztec/foundation/log';
-import type { AztecAddress } from '@aztec/stdlib/aztec-address';
-import { deriveStorageSlotInMap } from '@aztec/stdlib/hash';
-import type { PXE } from '@aztec/stdlib/interfaces/client';
-import type { Note } from '@aztec/stdlib/note';
-
-/**
- * A class that provides utility functions for interacting with the aztec chain.
- */
-export class AztecCheatCodes {
-  constructor(
-    /**
-     * The PXE Service to use for interacting with the chain
-     */
-    public pxe: PXE,
-    /**
-     * The logger to use for the aztec cheatcodes
-     */
-    public logger = createLogger('aztecjs:cheat_codes'),
-  ) {}
-
-  /**
-   * Computes the slot value for a given map and key.
-   * @param mapSlot - The slot of the map (specified in Aztec.nr contract)
-   * @param key - The key to lookup in the map
-   * @returns The storage slot of the value in the map
-   */
-  public computeSlotInMap(mapSlot: Fr | bigint, key: Fr | bigint | AztecAddress): Promise<Fr> {
-    const keyFr = typeof key === 'bigint' ? new Fr(key) : key.toField();
-    return deriveStorageSlotInMap(mapSlot, keyFr);
-  }
-
-  /**
-   * Get the current blocknumber
-   * @returns The current block number
-   */
-  public async blockNumber(): Promise<number> {
-    return await this.pxe.getBlockNumber();
-  }
-
-  /**
-   * Get the current timestamp
-   * @returns The current timestamp
-   */
-  public async timestamp(): Promise<number> {
-    const res = await this.pxe.getBlock(await this.blockNumber());
-    return res?.header.globalVariables.timestamp.toNumber() ?? 0;
-  }
-
-  /**
-   * Loads the value stored at the given slot in the public storage of the given contract.
-   * @param who - The address of the contract
-   * @param slot - The storage slot to lookup
-   * @returns The value stored at the given slot
-   */
-  public async loadPublic(who: AztecAddress, slot: Fr | bigint): Promise<Fr> {
-    const storageValue = await this.pxe.getPublicStorageAt(who, new Fr(slot));
-    return storageValue;
-  }
-
-  /**
-   * Loads the value stored at the given slot in the private storage of the given contract.
-   * @param contract - The address of the contract
-   * @param owner - The owner for whom the notes are encrypted
-   * @param slot - The storage slot to lookup
-   * @returns The notes stored at the given slot
-   */
-  public async loadPrivate(owner: AztecAddress, contract: AztecAddress, slot: Fr | bigint): Promise<Note[]> {
-    const extendedNotes = await this.pxe.getNotes({
-      owner,
-      contractAddress: contract,
-      storageSlot: new Fr(slot),
-    });
-    return extendedNotes.map(extendedNote => extendedNote.note);
-  }
-}

package/src/utils/index.ts

@@ -1,21 +0,0 @@
-export { generatePublicKey } from './pub_key.js';
-export {
-  type AztecAddressLike,
-  type EthAddressLike,
-  type EventSelectorLike,
-  type FieldLike,
-  type FunctionSelectorLike,
-  type U128Like,
-  type WrappedFieldLike,
-} from './abi_types.js';
-export {
-  computeAuthWitMessageHash,
-  computeInnerAuthWitHash,
-  computeInnerAuthWitHashFromAction,
-  type IntentAction,
-  type IntentInnerHash,
-} from './authwit.js';
-export { waitForPXE } from './pxe.js';
-export { waitForNode, createAztecNodeClient, type AztecNode } from './node.js';
-export { getFeeJuiceBalance } from './fee_juice.js';
-export { readFieldCompressedString } from './field_compressed_string.js';

package/src/utils/pxe.ts

@@ -1,17 +0,0 @@
-import type { Logger } from '@aztec/foundation/log';
-import { retryUntil } from '@aztec/foundation/retry';
-import type { PXE } from '@aztec/stdlib/interfaces/client';
-
-export const waitForPXE = async (pxe: PXE, logger?: Logger) => {
-  await retryUntil(async () => {
-    try {
-      logger?.verbose('Attempting to contact PXE...');
-      await pxe.getNodeInfo();
-      logger?.verbose('Contacted PXE');
-      return true;
-    } catch (error) {
-      logger?.verbose('Failed to contact PXE');
-    }
-    return undefined;
-  }, 'RPC Get Node Info');
-};

package/src/wallet/account_wallet.ts

@@ -1,242 +0,0 @@
-import { Fr } from '@aztec/foundation/fields';
-import { ProtocolContractAddress } from '@aztec/protocol-contracts';
-import { type ABIParameterVisibility, type FunctionAbi, FunctionType } from '@aztec/stdlib/abi';
-import type { AuthWitness } from '@aztec/stdlib/auth-witness';
-import type { AztecAddress } from '@aztec/stdlib/aztec-address';
-import type { PXE } from '@aztec/stdlib/interfaces/client';
-import type { TxExecutionRequest } from '@aztec/stdlib/tx';
-
-import type { AccountInterface } from '../account/interface.js';
-import { ContractFunctionInteraction } from '../contract/contract_function_interaction.js';
-import type { ExecutionRequestInit } from '../entrypoint/entrypoint.js';
-import {
-  type IntentAction,
-  type IntentInnerHash,
-  computeAuthWitMessageHash,
-  computeInnerAuthWitHashFromAction,
-} from '../utils/authwit.js';
-import { BaseWallet } from './base_wallet.js';
-
-/**
- * A wallet implementation that forwards authentication requests to a provided account.
- */
-export class AccountWallet extends BaseWallet {
-  constructor(pxe: PXE, protected account: AccountInterface) {
-    super(pxe, [account.getAddress()]);
-  }
-
-  createTxExecutionRequest(exec: ExecutionRequestInit): Promise<TxExecutionRequest> {
-    return this.account.createTxExecutionRequest(exec);
-  }
-
-  getChainId(): Fr {
-    return this.account.getChainId();
-  }
-
-  getVersion(): Fr {
-    return this.account.getVersion();
-  }
-
-  override isL1ToL2MessageSynced(l1ToL2Message: Fr): Promise<boolean> {
-    return this.pxe.isL1ToL2MessageSynced(l1ToL2Message);
-  }
-
-  /**
-   * Computes an authentication witness from either a message hash or an intent.
-   *
-   * If a message hash is provided, it will create a witness for the hash directly.
-   * Otherwise, it will compute the message hash using the intent, along with the
-   * chain id and the version values provided by the wallet.
-   *
-   * @param messageHashOrIntent - The message hash of the intent to approve
-   * @returns The authentication witness
-   */
-  async createAuthWit(messageHashOrIntent: Fr | Buffer | IntentAction | IntentInnerHash): Promise<AuthWitness> {
-    let messageHash: Fr;
-    if (Buffer.isBuffer(messageHashOrIntent)) {
-      messageHash = Fr.fromBuffer(messageHashOrIntent);
-    } else if (messageHashOrIntent instanceof Fr) {
-      messageHash = messageHashOrIntent;
-    } else {
-      messageHash = await this.getMessageHash(messageHashOrIntent);
-    }
-
-    const witness = await this.account.createAuthWit(messageHash);
-    await this.pxe.addAuthWitness(witness);
-    return witness;
-  }
-
-  /**
-   * Returns a function interaction to set a message hash as authorized or revoked in this account.
-   *
-   * Public calls can then consume this authorization.
-   *
-   * @param messageHashOrIntent - The message hash or intent to authorize/revoke
-   * @param authorized - True to authorize, false to revoke authorization.
-   * @returns - A function interaction.
-   */
-  public async setPublicAuthWit(
-    messageHashOrIntent: Fr | Buffer | IntentInnerHash | IntentAction,
-    authorized: boolean,
-  ): Promise<ContractFunctionInteraction> {
-    let messageHash: Fr;
-    if (Buffer.isBuffer(messageHashOrIntent)) {
-      messageHash = Fr.fromBuffer(messageHashOrIntent);
-    } else if (messageHashOrIntent instanceof Fr) {
-      messageHash = messageHashOrIntent;
-    } else {
-      messageHash = await this.getMessageHash(messageHashOrIntent);
-    }
-
-    return new ContractFunctionInteraction(this, ProtocolContractAddress.AuthRegistry, this.getSetAuthorizedAbi(), [
-      messageHash,
-      authorized,
-    ]);
-  }
-
-  private async getInnerHashAndConsumer(intent: IntentInnerHash | IntentAction): Promise<{
-    /** The inner hash */
-    innerHash: Fr;
-    /** The consumer of the authwit */
-    consumer: AztecAddress;
-  }> {
-    if ('caller' in intent && 'action' in intent) {
-      const action =
-        intent.action instanceof ContractFunctionInteraction ? await intent.action.request() : intent.action;
-      return {
-        innerHash: await computeInnerAuthWitHashFromAction(intent.caller, action),
-        consumer: action.to,
-      };
-    } else if (Buffer.isBuffer(intent.innerHash)) {
-      return { innerHash: Fr.fromBuffer(intent.innerHash), consumer: intent.consumer };
-    }
-    return { innerHash: intent.innerHash, consumer: intent.consumer };
-  }
-
-  /**
-   * Returns the message hash for the given intent
-   *
-   * @param intent - A tuple of (consumer and inner hash) or (caller and action)
-   * @returns The message hash
-   */
-  private getMessageHash(intent: IntentInnerHash | IntentAction): Promise<Fr> {
-    const chainId = this.getChainId();
-    const version = this.getVersion();
-    return computeAuthWitMessageHash(intent, { chainId, version });
-  }
-
-  /**
-   * Lookup the validity of an authwit in private and public contexts.
-   *
-   * Uses the chain id and version of the wallet.
-   *
-   * @param onBehalfOf - The address of the "approver"
-   * @param intent - The consumer and inner hash or the caller and action to lookup
-   *
-   * @returns - A struct containing the validity of the authwit in private and public contexts.
-   */
-  async lookupValidity(
-    onBehalfOf: AztecAddress,
-    intent: IntentInnerHash | IntentAction,
-  ): Promise<{
-    /** boolean flag indicating if the authwit is valid in private context */
-    isValidInPrivate: boolean;
-    /** boolean flag indicating if the authwit is valid in public context */
-    isValidInPublic: boolean;
-  }> {
-    const { innerHash, consumer } = await this.getInnerHashAndConsumer(intent);
-
-    const messageHash = await this.getMessageHash(intent);
-    const results = { isValidInPrivate: false, isValidInPublic: false };
-
-    // Check private
-    const witness = await this.getAuthWitness(messageHash);
-    if (witness !== undefined) {
-      results.isValidInPrivate = (await new ContractFunctionInteraction(this, onBehalfOf, this.getLookupValidityAbi(), [
-        consumer,
-        innerHash,
-      ]).simulate()) as boolean;
-    }
-
-    // check public
-    results.isValidInPublic = (await new ContractFunctionInteraction(
-      this,
-      ProtocolContractAddress.AuthRegistry,
-      this.getIsConsumableAbi(),
-      [onBehalfOf, messageHash],
-    ).simulate()) as boolean;
-
-    return results;
-  }
-
-  /** Returns the complete address of the account that implements this wallet. */
-  public getCompleteAddress() {
-    return this.account.getCompleteAddress();
-  }
-
-  /** Returns the address of the account that implements this wallet. */
-  public override getAddress() {
-    return this.getCompleteAddress().address;
-  }
-
-  private getSetAuthorizedAbi(): FunctionAbi {
-    return {
-      name: 'set_authorized',
-      isInitializer: false,
-      functionType: FunctionType.PUBLIC,
-      isInternal: true,
-      isStatic: false,
-      parameters: [
-        {
-          name: 'message_hash',
-          type: { kind: 'field' },
-          visibility: 'private' as ABIParameterVisibility,
-        },
-        {
-          name: 'authorize',
-          type: { kind: 'boolean' },
-          visibility: 'private' as ABIParameterVisibility,
-        },
-      ],
-      returnTypes: [],
-      errorTypes: {},
-    };
-  }
-
-  private getLookupValidityAbi(): FunctionAbi {
-    return {
-      name: 'lookup_validity',
-      isInitializer: false,
-      functionType: FunctionType.UNCONSTRAINED,
-      isInternal: false,
-      isStatic: false,
-      parameters: [{ name: 'message_hash', type: { kind: 'field' }, visibility: 'private' as ABIParameterVisibility }],
-      returnTypes: [{ kind: 'boolean' }],
-      errorTypes: {},
-    };
-  }
-
-  private getIsConsumableAbi(): FunctionAbi {
-    return {
-      name: 'unconstrained_is_consumable',
-      isInitializer: false,
-      functionType: FunctionType.UNCONSTRAINED,
-      isInternal: false,
-      isStatic: false,
-      parameters: [
-        {
-          name: 'address',
-          type: {
-            fields: [{ name: 'inner', type: { kind: 'field' } }],
-            kind: 'struct',
-            path: 'authwit::aztec::protocol_types::address::aztec_address::AztecAddress',
-          },
-          visibility: 'private' as ABIParameterVisibility,
-        },
-        { name: 'message_hash', type: { kind: 'field' }, visibility: 'private' as ABIParameterVisibility },
-      ],
-      returnTypes: [{ kind: 'boolean' }],
-      errorTypes: {},
-    };
-  }
-}

package/src/wallet/base_wallet.ts

@@ -1,198 +0,0 @@
-import type { L1_TO_L2_MSG_TREE_HEIGHT } from '@aztec/constants';
-import type { Fr, Point } from '@aztec/foundation/fields';
-import type { SiblingPath } from '@aztec/foundation/trees';
-import type { AbiDecoded, ContractArtifact } from '@aztec/stdlib/abi';
-import type { AuthWitness } from '@aztec/stdlib/auth-witness';
-import type { AztecAddress } from '@aztec/stdlib/aztec-address';
-import type { L2Block } from '@aztec/stdlib/block';
-import type { CompleteAddress, ContractInstanceWithAddress, NodeInfo, PartialAddress } from '@aztec/stdlib/contract';
-import type { GasFees } from '@aztec/stdlib/gas';
-import type {
-  ContractClassMetadata,
-  ContractMetadata,
-  EventMetadataDefinition,
-  GetContractClassLogsResponse,
-  GetPublicLogsResponse,
-  PXE,
-  PXEInfo,
-} from '@aztec/stdlib/interfaces/client';
-import type { LogFilter } from '@aztec/stdlib/logs';
-import type { NotesFilter, UniqueNote } from '@aztec/stdlib/note';
-import type {
-  PrivateExecutionResult,
-  Tx,
-  TxExecutionRequest,
-  TxHash,
-  TxProvingResult,
-  TxReceipt,
-  TxSimulationResult,
-} from '@aztec/stdlib/tx';
-
-import type { Wallet } from '../account/wallet.js';
-import type { ExecutionRequestInit } from '../entrypoint/entrypoint.js';
-import type { IntentAction, IntentInnerHash } from '../utils/authwit.js';
-
-/**
- * A base class for Wallet implementations
- */
-export abstract class BaseWallet implements Wallet {
-  constructor(protected readonly pxe: PXE, private scopes?: AztecAddress[]) {}
-
-  abstract isL1ToL2MessageSynced(l1ToL2Message: Fr): Promise<boolean>;
-
-  abstract getCompleteAddress(): CompleteAddress;
-
-  abstract getChainId(): Fr;
-
-  abstract getVersion(): Fr;
-
-  abstract createTxExecutionRequest(exec: ExecutionRequestInit): Promise<TxExecutionRequest>;
-
-  abstract createAuthWit(intent: Fr | Buffer | IntentInnerHash | IntentAction): Promise<AuthWitness>;
-
-  setScopes(scopes: AztecAddress[]) {
-    this.scopes = scopes;
-  }
-
-  getScopes() {
-    return this.scopes;
-  }
-
-  getAddress() {
-    return this.getCompleteAddress().address;
-  }
-  storeCapsule(contract: AztecAddress, storageSlot: Fr, capsule: Fr[]): Promise<void> {
-    return this.pxe.storeCapsule(contract, storageSlot, capsule);
-  }
-  registerAccount(secretKey: Fr, partialAddress: PartialAddress): Promise<CompleteAddress> {
-    return this.pxe.registerAccount(secretKey, partialAddress);
-  }
-  getRegisteredAccounts(): Promise<CompleteAddress[]> {
-    return this.pxe.getRegisteredAccounts();
-  }
-  registerSender(address: AztecAddress): Promise<AztecAddress> {
-    return this.pxe.registerSender(address);
-  }
-  getSenders(): Promise<AztecAddress[]> {
-    return this.pxe.getSenders();
-  }
-  async removeSender(address: AztecAddress): Promise<void> {
-    await this.pxe.removeSender(address);
-  }
-  registerContract(contract: {
-    /** Instance */ instance: ContractInstanceWithAddress;
-    /** Associated artifact */ artifact?: ContractArtifact;
-  }): Promise<void> {
-    return this.pxe.registerContract(contract);
-  }
-  registerContractClass(artifact: ContractArtifact): Promise<void> {
-    return this.pxe.registerContractClass(artifact);
-  }
-  updateContract(contractAddress: AztecAddress, artifact: ContractArtifact): Promise<void> {
-    return this.pxe.updateContract(contractAddress, artifact);
-  }
-  getContracts(): Promise<AztecAddress[]> {
-    return this.pxe.getContracts();
-  }
-  proveTx(txRequest: TxExecutionRequest, privateExecutionResult: PrivateExecutionResult): Promise<TxProvingResult> {
-    return this.pxe.proveTx(txRequest, privateExecutionResult);
-  }
-  simulateTx(
-    txRequest: TxExecutionRequest,
-    simulatePublic: boolean,
-    msgSender?: AztecAddress,
-    skipTxValidation?: boolean,
-    skipFeeEnforcement?: boolean,
-    profile?: boolean,
-  ): Promise<TxSimulationResult> {
-    return this.pxe.simulateTx(
-      txRequest,
-      simulatePublic,
-      msgSender,
-      skipTxValidation,
-      skipFeeEnforcement,
-      profile,
-      this.scopes,
-    );
-  }
-  sendTx(tx: Tx): Promise<TxHash> {
-    return this.pxe.sendTx(tx);
-  }
-  getTxEffect(txHash: TxHash) {
-    return this.pxe.getTxEffect(txHash);
-  }
-  getTxReceipt(txHash: TxHash): Promise<TxReceipt> {
-    return this.pxe.getTxReceipt(txHash);
-  }
-  getNotes(filter: NotesFilter): Promise<UniqueNote[]> {
-    return this.pxe.getNotes(filter);
-  }
-  getPublicStorageAt(contract: AztecAddress, storageSlot: Fr): Promise<any> {
-    return this.pxe.getPublicStorageAt(contract, storageSlot);
-  }
-  getBlock(number: number): Promise<L2Block | undefined> {
-    return this.pxe.getBlock(number);
-  }
-  getCurrentBaseFees(): Promise<GasFees> {
-    return this.pxe.getCurrentBaseFees();
-  }
-  simulateUnconstrained(
-    functionName: string,
-    args: any[],
-    to: AztecAddress,
-    from?: AztecAddress | undefined,
-  ): Promise<AbiDecoded> {
-    return this.pxe.simulateUnconstrained(functionName, args, to, from);
-  }
-  getPublicLogs(filter: LogFilter): Promise<GetPublicLogsResponse> {
-    return this.pxe.getPublicLogs(filter);
-  }
-  getContractClassLogs(filter: LogFilter): Promise<GetContractClassLogsResponse> {
-    return this.pxe.getContractClassLogs(filter);
-  }
-  getBlockNumber(): Promise<number> {
-    return this.pxe.getBlockNumber();
-  }
-  getProvenBlockNumber(): Promise<number> {
-    return this.pxe.getProvenBlockNumber();
-  }
-  getNodeInfo(): Promise<NodeInfo> {
-    return this.pxe.getNodeInfo();
-  }
-  addAuthWitness(authWitness: AuthWitness) {
-    return this.pxe.addAuthWitness(authWitness);
-  }
-  getAuthWitness(messageHash: Fr) {
-    return this.pxe.getAuthWitness(messageHash);
-  }
-  getPXEInfo(): Promise<PXEInfo> {
-    return this.pxe.getPXEInfo();
-  }
-  getContractClassMetadata(id: Fr, includeArtifact: boolean = false): Promise<ContractClassMetadata> {
-    return this.pxe.getContractClassMetadata(id, includeArtifact);
-  }
-  getContractMetadata(address: AztecAddress): Promise<ContractMetadata> {
-    return this.pxe.getContractMetadata(address);
-  }
-  getPrivateEvents<T>(
-    event: EventMetadataDefinition,
-    from: number,
-    limit: number,
-    vpks: Point[] = [this.getCompleteAddress().publicKeys.masterIncomingViewingPublicKey],
-  ): Promise<T[]> {
-    return this.pxe.getPrivateEvents(event, from, limit, vpks);
-  }
-  getPublicEvents<T>(event: EventMetadataDefinition, from: number, limit: number): Promise<T[]> {
-    return this.pxe.getPublicEvents(event, from, limit);
-  }
-  public getL1ToL2MembershipWitness(
-    contractAddress: AztecAddress,
-    messageHash: Fr,
-    secret: Fr,
-  ): Promise<[bigint, SiblingPath<typeof L1_TO_L2_MSG_TREE_HEIGHT>]> {
-    return this.pxe.getL1ToL2MembershipWitness(contractAddress, messageHash, secret);
-  }
-  getL2ToL1MembershipWitness(blockNumber: number, l2Tol1Message: Fr): Promise<[bigint, SiblingPath<number>]> {
-    return this.pxe.getL2ToL1MembershipWitness(blockNumber, l2Tol1Message);
-  }
-}

package/src/wallet/signerless_wallet.ts

@@ -1,52 +0,0 @@
-import type { Fr } from '@aztec/foundation/fields';
-import { AuthWitness } from '@aztec/stdlib/auth-witness';
-import type { CompleteAddress } from '@aztec/stdlib/contract';
-import type { PXE } from '@aztec/stdlib/interfaces/client';
-import type { TxExecutionRequest } from '@aztec/stdlib/tx';
-
-import { DefaultEntrypoint } from '../entrypoint/default_entrypoint.js';
-import type { EntrypointInterface, ExecutionRequestInit } from '../entrypoint/entrypoint.js';
-import type { IntentAction, IntentInnerHash } from '../utils/authwit.js';
-import { BaseWallet } from './base_wallet.js';
-
-/**
- * Wallet implementation which creates a transaction request directly to the requested contract without any signing.
- */
-export class SignerlessWallet extends BaseWallet {
-  constructor(pxe: PXE, private entrypoint?: EntrypointInterface) {
-    super(pxe);
-  }
-  async createTxExecutionRequest(execution: ExecutionRequestInit): Promise<TxExecutionRequest> {
-    let entrypoint = this.entrypoint;
-    if (!entrypoint) {
-      const { l1ChainId: chainId, protocolVersion } = await this.pxe.getNodeInfo();
-      entrypoint = new DefaultEntrypoint(chainId, protocolVersion);
-    }
-
-    return entrypoint.createTxExecutionRequest(execution);
-  }
-
-  getChainId(): Fr {
-    throw new Error('SignerlessWallet: Method getChainId not implemented.');
-  }
-
-  getVersion(): Fr {
-    throw new Error('SignerlessWallet: Method getVersion not implemented.');
-  }
-
-  getPublicKeysHash(): Fr {
-    throw new Error('SignerlessWallet: Method getPublicKeysHash not implemented.');
-  }
-
-  getCompleteAddress(): CompleteAddress {
-    throw new Error('SignerlessWallet: Method getCompleteAddress not implemented.');
-  }
-
-  createAuthWit(_intent: Fr | Buffer | IntentInnerHash | IntentAction): Promise<AuthWitness> {
-    throw new Error('SignerlessWallet: Method createAuthWit not implemented.');
-  }
-
-  override isL1ToL2MessageSynced(l1ToL2Message: Fr): Promise<boolean> {
-    return this.pxe.isL1ToL2MessageSynced(l1ToL2Message);
-  }
-}