@aztec/aztec.js 0.0.0-test.0

package/src/wallet/account_wallet_with_private_key.ts

@@ -0,0 +1,40 @@
+import type { Fr } from '@aztec/foundation/fields';
+import type { PXE } from '@aztec/stdlib/interfaces/client';
+import { computeAddressSecret, deriveMasterIncomingViewingSecretKey } from '@aztec/stdlib/keys';
+
+import type { Salt } from '../account/index.js';
+import type { AccountInterface } from '../account/interface.js';
+import { AccountWallet } from './account_wallet.js';
+
+/**
+ * Extends {@link AccountWallet} with the encryption private key. Not required for
+ * implementing the wallet interface but useful for testing purposes or exporting
+ * an account to another pxe.
+ */
+export class AccountWalletWithSecretKey extends AccountWallet {
+  constructor(
+    pxe: PXE,
+    account: AccountInterface,
+    private secretKey: Fr,
+    /** Deployment salt for this account contract. */
+    public readonly salt: Salt,
+  ) {
+    super(pxe, account);
+  }
+
+  /** Returns the encryption private key associated with this account. */
+  public getSecretKey() {
+    return this.secretKey;
+  }
+
+  /** Returns the encryption secret, the secret of the encryption point—the point that others use to encrypt messages to this account
+   * note - this ensures that the address secret always corresponds to an address point with y being positive
+   * dev - this is also referred to as the address secret, which decrypts payloads encrypted to an address point
+   */
+  public async getEncryptionSecret() {
+    return computeAddressSecret(
+      await this.getCompleteAddress().getPreaddress(),
+      deriveMasterIncomingViewingSecretKey(this.getSecretKey()),
+    );
+  }
+}

package/src/wallet/base_wallet.ts

@@ -0,0 +1,198 @@
+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/index.ts

@@ -0,0 +1,33 @@
+import type { AztecAddress } from '@aztec/stdlib/aztec-address';
+import type { PXE } from '@aztec/stdlib/interfaces/client';
+
+import type { AccountContract } from '../account/contract.js';
+import { AccountWallet } from './account_wallet.js';
+
+export * from '../account/wallet.js';
+export * from './account_wallet.js';
+export * from './account_wallet_with_private_key.js';
+export * from './signerless_wallet.js';
+
+/**
+ * Gets a wallet for an already registered account.
+ * @param pxe - PXE Service instance.
+ * @param address - Address for the account.
+ * @param accountContract - Account contract implementation.
+ * @returns A wallet for this account that can be used to interact with a contract instance.
+ */
+export async function getWallet(
+  pxe: PXE,
+  address: AztecAddress,
+  accountContract: AccountContract,
+): Promise<AccountWallet> {
+  const completeAddress = (await pxe.getRegisteredAccounts()).find(completeAddress =>
+    completeAddress.address.equals(address),
+  );
+  if (!completeAddress) {
+    throw new Error(`Account ${address} not found`);
+  }
+  const nodeInfo = await pxe.getNodeInfo();
+  const entrypoint = accountContract.getInterface(completeAddress, nodeInfo);
+  return new AccountWallet(pxe, entrypoint);
+}

package/src/wallet/signerless_wallet.ts

@@ -0,0 +1,52 @@
+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);
+  }
+}