@aztec/aztec.js 0.7.3 → 0.7.4

package/src/account/contract/auth_witness_account_contract.ts

@@ -1,35 +0,0 @@
-import { Schnorr } from '@aztec/circuits.js/barretenberg';
-import { ContractAbi } from '@aztec/foundation/abi';
-import { CompleteAddress, GrumpkinPrivateKey, NodeInfo } from '@aztec/types';
-
-import AuthWitnessAccountContractAbi from '../../abis/schnorr_auth_witness_account_contract.json' assert { type: 'json' };
-import { AuthWitnessAccountEntrypoint } from '../entrypoint/auth_witness_account_entrypoint.js';
-import { AccountContract } from './index.js';
-
-/**
- * Account contract that authenticates transactions using Schnorr signatures verified against
- * the note encryption key, relying on a single private key for both encryption and authentication.
- * Extended to pull verification data from the oracle instead of passed as arguments.
- */
-export class AuthWitnessAccountContract implements AccountContract {
-  constructor(private encryptionPrivateKey: GrumpkinPrivateKey) {}
-
-  public getDeploymentArgs() {
-    return Promise.resolve([]);
-  }
-
-  public async getEntrypoint({ address, partialAddress }: CompleteAddress, { chainId, version }: NodeInfo) {
-    return new AuthWitnessAccountEntrypoint(
-      address,
-      partialAddress,
-      this.encryptionPrivateKey,
-      await Schnorr.new(),
-      chainId,
-      version,
-    );
-  }
-
-  public getContractAbi(): ContractAbi {
-    return AuthWitnessAccountContractAbi as unknown as ContractAbi;
-  }
-}

package/src/account/entrypoint/auth_witness_account_entrypoint.ts

@@ -1,125 +0,0 @@
-import { AztecAddress, Fr, FunctionData, GrumpkinPrivateKey, PartialAddress, TxContext } from '@aztec/circuits.js';
-import { Schnorr } from '@aztec/circuits.js/barretenberg';
-import { ContractAbi, FunctionAbi, encodeArguments } from '@aztec/foundation/abi';
-import { FunctionCall, PackedArguments, TxExecutionRequest } from '@aztec/types';
-
-import SchnorrAuthWitnessAccountContractAbi from '../../abis/schnorr_auth_witness_account_contract.json' assert { type: 'json' };
-import { generatePublicKey } from '../../index.js';
-import { DEFAULT_CHAIN_ID, DEFAULT_VERSION } from '../../utils/defaults.js';
-import { buildPayload, hashPayload } from './entrypoint_payload.js';
-import { Entrypoint } from './index.js';
-
-/**
- * An extended interface for entrypoints that support signing and adding auth witnesses.
- */
-export interface IAuthWitnessAccountEntrypoint extends Entrypoint {
-  /**
-   * Sign a message hash with the private key.
-   * @param message - The message hash to sign.
-   * @returns The signature as a Buffer.
-   */
-  sign(message: Buffer): Buffer;
-
-  /**
-   * Creates an AuthWitness witness for the given message. In this case, witness is the public key, the signature
-   * and the partial address, to be used for verification.
-   * @param message - The message hash to sign.
-   * @param opts - Options.
-   * @returns [publicKey, signature, partialAddress] as Fr[].
-   */
-  createAuthWitness(message: Buffer): Promise<Fr[]>;
-
-  /**
-   * Returns the transaction request and the auth witness for the given function calls.
-   * Returning the witness here as a nonce is generated in the buildPayload action.
-   * @param executions - The function calls to execute
-   * @param opts - The options
-   * @returns The TxRequest, the auth witness to insert in db and the message signed
-   */
-  createTxExecutionRequestWithWitness(executions: FunctionCall[]): Promise<{
-    /** The transaction request */
-    txRequest: TxExecutionRequest;
-    /** The auth witness */
-    witness: Fr[];
-    /** The message signed */
-    message: Buffer;
-  }>;
-}
-
-/**
- * Account contract implementation that uses a single key for signing and encryption. This public key is not
- * stored in the contract, but rather verified against the contract address. Note that this approach is not
- * secure and should not be used in real use cases.
- * The entrypoint is extended to support signing and creating eip1271-like witnesses.
- */
-export class AuthWitnessAccountEntrypoint implements IAuthWitnessAccountEntrypoint {
-  constructor(
-    private address: AztecAddress,
-    private partialAddress: PartialAddress,
-    private privateKey: GrumpkinPrivateKey,
-    private signer: Schnorr,
-    private chainId: number = DEFAULT_CHAIN_ID,
-    private version: number = DEFAULT_VERSION,
-  ) {}
-
-  public sign(message: Buffer): Buffer {
-    return this.signer.constructSignature(message, this.privateKey).toBuffer();
-  }
-
-  async createAuthWitness(message: Buffer): Promise<Fr[]> {
-    const signature = this.sign(message);
-    const publicKey = await generatePublicKey(this.privateKey);
-
-    const sigFr: Fr[] = [];
-    for (let i = 0; i < 64; i++) {
-      sigFr.push(new Fr(signature[i]));
-    }
-
-    return [...publicKey.toFields(), ...sigFr, this.partialAddress];
-  }
-
-  /**
-   * Returns the transaction request and the auth witness for the given function calls.
-   * Returning the witness here as a nonce is generated in the buildPayload action.
-   * @param executions - The function calls to execute
-   * @param opts - The options
-   * @returns The TxRequest, the auth witness to insert in db and the message signed
-   */
-  async createTxExecutionRequestWithWitness(executions: FunctionCall[]): Promise<{
-    /** The transaction request */
-    txRequest: TxExecutionRequest;
-    /** The auth witness */
-    witness: Fr[];
-    /** The message signed */
-    message: Buffer;
-  }> {
-    const { payload, packedArguments: callsPackedArguments } = await buildPayload(executions);
-    const message = await hashPayload(payload);
-    const witness = await this.createAuthWitness(message);
-
-    const args = [payload];
-    const abi = this.getEntrypointAbi();
-    const packedArgs = await PackedArguments.fromArgs(encodeArguments(abi, args));
-    const txRequest = TxExecutionRequest.from({
-      argsHash: packedArgs.hash,
-      origin: this.address,
-      functionData: FunctionData.fromAbi(abi),
-      txContext: TxContext.empty(this.chainId, this.version),
-      packedArguments: [...callsPackedArguments, packedArgs],
-    });
-
-    return { txRequest, message, witness };
-  }
-
-  createTxExecutionRequest(_executions: FunctionCall[]): Promise<TxExecutionRequest> {
-    throw new Error(`Not implemented, use createTxExecutionRequestWithWitness instead`);
-  }
-
-  private getEntrypointAbi(): FunctionAbi {
-    const abi = (SchnorrAuthWitnessAccountContractAbi as any as ContractAbi).functions.find(
-      f => f.name === 'entrypoint',
-    );
-    if (!abi) throw new Error(`Entrypoint abi for account contract not found`);
-    return abi;
-  }
-}

package/src/account/entrypoint/entrypoint_utils.ts

@@ -1,31 +0,0 @@
-import { AztecAddress, FunctionData, TxContext } from '@aztec/circuits.js';
-import { FunctionAbi, encodeArguments } from '@aztec/foundation/abi';
-import { NodeInfo, PackedArguments, TxExecutionRequest } from '@aztec/types';
-
-/**
- * Utility for building a TxExecutionRequest in the context of an Entrypoint.
- * @param origin - Address of the account contract sending this transaction.
- * @param entrypointMethod - Initial method called in the account contract.
- * @param args - Arguments used when calling this initial method.
- * @param callsPackedArguments - Packed arguments of nested calls (if any).
- * @param nodeInfo - Node info with chain id and version.
- * @returns A TxExecutionRequest ready to be simulated, proven, and sent.
- */
-export async function buildTxExecutionRequest(
-  origin: AztecAddress,
-  entrypointMethod: FunctionAbi,
-  args: any[],
-  callsPackedArguments: PackedArguments[],
-  nodeInfo: NodeInfo,
-): Promise<TxExecutionRequest> {
-  const packedArgs = await PackedArguments.fromArgs(encodeArguments(entrypointMethod, args));
-  const { chainId, version } = nodeInfo;
-
-  return TxExecutionRequest.from({
-    argsHash: packedArgs.hash,
-    origin,
-    functionData: FunctionData.fromAbi(entrypointMethod),
-    txContext: TxContext.empty(chainId, version),
-    packedArguments: [...callsPackedArguments, packedArgs],
-  });
-}

package/src/account/entrypoint/index.ts

@@ -1,23 +0,0 @@
-import { FunctionCall, TxExecutionRequest } from '@aztec/types';
-
-export * from './auth_witness_account_entrypoint.js';
-export * from './entrypoint_payload.js';
-export * from './entrypoint_utils.js';
-export * from './single_key_account_entrypoint.js';
-export * from './stored_key_account_entrypoint.js';
-
-// docs:start:entrypoint-interface
-/**
- * Represents a transaction entrypoint in an account contract.
- * Knows how to assemble a transaction execution request given a set of function calls.
- */
-export interface Entrypoint {
-  /**
-   * Generates an authenticated request out of set of intents
-   * @param executions - The execution intents to be run.
-   * @param opts - Options.
-   * @returns The authenticated transaction execution request.
-   */
-  createTxExecutionRequest(executions: FunctionCall[]): Promise<TxExecutionRequest>;
-}
-// docs:end:entrypoint-interface

package/src/account/entrypoint/single_key_account_entrypoint.ts

@@ -1,55 +0,0 @@
-import { AztecAddress, FunctionData, GrumpkinPrivateKey, PartialAddress, TxContext } from '@aztec/circuits.js';
-import { Schnorr } from '@aztec/circuits.js/barretenberg';
-import { ContractAbi, encodeArguments } from '@aztec/foundation/abi';
-import { FunctionCall, PackedArguments, TxExecutionRequest } from '@aztec/types';
-
-import SchnorrSingleKeyAccountContractAbi from '../../abis/schnorr_single_key_account_contract.json' assert { type: 'json' };
-import { generatePublicKey } from '../../index.js';
-import { DEFAULT_CHAIN_ID, DEFAULT_VERSION } from '../../utils/defaults.js';
-import { buildPayload, hashPayload } from './entrypoint_payload.js';
-import { Entrypoint } from './index.js';
-
-/**
- * Account contract implementation that uses a single key for signing and encryption. This public key is not
- * stored in the contract, but rather verified against the contract address. Note that this approach is not
- * secure and should not be used in real use cases.
- */
-export class SingleKeyAccountEntrypoint implements Entrypoint {
-  constructor(
-    private address: AztecAddress,
-    private partialAddress: PartialAddress,
-    private privateKey: GrumpkinPrivateKey,
-    private chainId: number = DEFAULT_CHAIN_ID,
-    private version: number = DEFAULT_VERSION,
-  ) {}
-
-  async createTxExecutionRequest(executions: FunctionCall[]): Promise<TxExecutionRequest> {
-    const { payload, packedArguments: callsPackedArguments } = await buildPayload(executions);
-    const message = await hashPayload(payload);
-
-    const signer = await Schnorr.new();
-    const signature = signer.constructSignature(message, this.privateKey).toBuffer();
-    const publicKey = await generatePublicKey(this.privateKey);
-    const args = [payload, publicKey.toBuffer(), signature, this.partialAddress];
-    const abi = this.getEntrypointAbi();
-    const packedArgs = await PackedArguments.fromArgs(encodeArguments(abi, args));
-    const txRequest = TxExecutionRequest.from({
-      argsHash: packedArgs.hash,
-      origin: this.address,
-      functionData: FunctionData.fromAbi(abi),
-      txContext: TxContext.empty(this.chainId, this.version),
-      packedArguments: [...callsPackedArguments, packedArgs],
-    });
-
-    return txRequest;
-  }
-
-  private getEntrypointAbi() {
-    // We use the SchnorrSingleKeyAccountContract because it implements the interface we need, but ideally
-    // we should have an interface that defines the entrypoint for SingleKeyAccountContracts and
-    // load the abi from it.
-    const abi = (SchnorrSingleKeyAccountContractAbi as any as ContractAbi).functions.find(f => f.name === 'entrypoint');
-    if (!abi) throw new Error(`Entrypoint abi for account contract not found`);
-    return abi;
-  }
-}

package/src/account/entrypoint/stored_key_account_entrypoint.ts

@@ -1,56 +0,0 @@
-import { AztecAddress, FunctionData, TxContext } from '@aztec/circuits.js';
-import { Signature } from '@aztec/circuits.js/barretenberg';
-import { ContractAbi, encodeArguments } from '@aztec/foundation/abi';
-import { DebugLogger, createDebugLogger } from '@aztec/foundation/log';
-import { FunctionCall, PackedArguments, TxExecutionRequest } from '@aztec/types';
-
-import EcdsaAccountContractAbi from '../../abis/ecdsa_account_contract.json' assert { type: 'json' };
-import { DEFAULT_CHAIN_ID, DEFAULT_VERSION } from '../../utils/defaults.js';
-import { buildPayload, hashPayload } from './entrypoint_payload.js';
-import { Entrypoint } from './index.js';
-
-/**
- * Account contract implementation that keeps a signing public key in storage, and is retrieved on
- * every new request in order to validate the payload signature.
- */
-export class StoredKeyAccountEntrypoint implements Entrypoint {
-  private log: DebugLogger;
-
-  constructor(
-    private address: AztecAddress,
-    private sign: (msg: Buffer) => Signature,
-    private chainId: number = DEFAULT_CHAIN_ID,
-    private version: number = DEFAULT_VERSION,
-  ) {
-    this.log = createDebugLogger('aztec:client:accounts:stored_key');
-  }
-
-  async createTxExecutionRequest(executions: FunctionCall[]): Promise<TxExecutionRequest> {
-    const { payload, packedArguments: callsPackedArguments } = await buildPayload(executions);
-    const message = await hashPayload(payload);
-    const signature = this.sign(message).toBuffer();
-    this.log(`Signed challenge ${message.toString('hex')} as ${signature.toString('hex')}`);
-
-    const args = [payload, signature];
-    const abi = this.getEntrypointAbi();
-    const packedArgs = await PackedArguments.fromArgs(encodeArguments(abi, args));
-    const txRequest = TxExecutionRequest.from({
-      argsHash: packedArgs.hash,
-      origin: this.address,
-      functionData: FunctionData.fromAbi(abi),
-      txContext: TxContext.empty(this.chainId, this.version),
-      packedArguments: [...callsPackedArguments, packedArgs],
-    });
-
-    return txRequest;
-  }
-
-  private getEntrypointAbi() {
-    // We use the EcdsaAccountContractAbi because it implements the interface we need, but ideally
-    // we should have an interface that defines the entrypoint for StoredKeyAccountContracts and
-    // load the abi from it.
-    const abi = (EcdsaAccountContractAbi as any as ContractAbi).functions.find(f => f.name === 'entrypoint');
-    if (!abi) throw new Error(`Entrypoint abi for account contract not found`);
-    return abi;
-  }
-}

package/src/aztec_rpc_client/index.ts

@@ -1,2 +0,0 @@
-export * from './aztec_rpc_client.js';
-export * from './wallet.js';

package/src/aztec_rpc_client/wallet.ts

@@ -1,219 +0,0 @@
-import { AztecAddress, CircuitsWasm, Fr, GrumpkinPrivateKey, PartialAddress, TxContext } from '@aztec/circuits.js';
-import {
-  AztecRPC,
-  ContractData,
-  DeployedContract,
-  ExtendedContractData,
-  FunctionCall,
-  L2BlockL2Logs,
-  NodeInfo,
-  NotePreimage,
-  PackedArguments,
-  SyncStatus,
-  Tx,
-  TxExecutionRequest,
-  TxHash,
-  TxReceipt,
-} from '@aztec/types';
-
-import { Entrypoint, IAuthWitnessAccountEntrypoint } from '../account/entrypoint/index.js';
-import { CompleteAddress } from '../index.js';
-
-/**
- * The wallet interface.
- */
-export type Wallet = Entrypoint & AztecRPC;
-
-/**
- * A base class for Wallet implementations
- */
-export abstract class BaseWallet implements Wallet {
-  constructor(protected readonly rpc: AztecRPC) {}
-
-  abstract createTxExecutionRequest(execs: FunctionCall[]): Promise<TxExecutionRequest>;
-
-  registerAccount(privKey: GrumpkinPrivateKey, partialAddress: PartialAddress): Promise<void> {
-    return this.rpc.registerAccount(privKey, partialAddress);
-  }
-  registerRecipient(account: CompleteAddress): Promise<void> {
-    return this.rpc.registerRecipient(account);
-  }
-  getAccounts(): Promise<CompleteAddress[]> {
-    return this.rpc.getAccounts();
-  }
-  getAccount(address: AztecAddress): Promise<CompleteAddress | undefined> {
-    return this.rpc.getAccount(address);
-  }
-  getRecipients(): Promise<CompleteAddress[]> {
-    return this.rpc.getRecipients();
-  }
-  getRecipient(address: AztecAddress): Promise<CompleteAddress | undefined> {
-    return this.rpc.getRecipient(address);
-  }
-  addContracts(contracts: DeployedContract[]): Promise<void> {
-    return this.rpc.addContracts(contracts);
-  }
-  getContracts(): Promise<AztecAddress[]> {
-    return this.rpc.getContracts();
-  }
-  simulateTx(txRequest: TxExecutionRequest, simulatePublic: boolean): Promise<Tx> {
-    return this.rpc.simulateTx(txRequest, simulatePublic);
-  }
-  sendTx(tx: Tx): Promise<TxHash> {
-    return this.rpc.sendTx(tx);
-  }
-  getTxReceipt(txHash: TxHash): Promise<TxReceipt> {
-    return this.rpc.getTxReceipt(txHash);
-  }
-  getPrivateStorageAt(owner: AztecAddress, contract: AztecAddress, storageSlot: Fr): Promise<NotePreimage[]> {
-    return this.rpc.getPrivateStorageAt(owner, contract, storageSlot);
-  }
-  getPublicStorageAt(contract: AztecAddress, storageSlot: Fr): Promise<any> {
-    return this.rpc.getPublicStorageAt(contract, storageSlot);
-  }
-  viewTx(functionName: string, args: any[], to: AztecAddress, from?: AztecAddress | undefined): Promise<any> {
-    return this.rpc.viewTx(functionName, args, to, from);
-  }
-  getExtendedContractData(contractAddress: AztecAddress): Promise<ExtendedContractData | undefined> {
-    return this.rpc.getExtendedContractData(contractAddress);
-  }
-  getContractData(contractAddress: AztecAddress): Promise<ContractData | undefined> {
-    return this.rpc.getContractData(contractAddress);
-  }
-  getUnencryptedLogs(from: number, limit: number): Promise<L2BlockL2Logs[]> {
-    return this.rpc.getUnencryptedLogs(from, limit);
-  }
-  getBlockNumber(): Promise<number> {
-    return this.rpc.getBlockNumber();
-  }
-  getNodeInfo(): Promise<NodeInfo> {
-    return this.rpc.getNodeInfo();
-  }
-  isGlobalStateSynchronised() {
-    return this.rpc.isGlobalStateSynchronised();
-  }
-  isAccountStateSynchronised(account: AztecAddress) {
-    return this.rpc.isAccountStateSynchronised(account);
-  }
-  getSyncStatus(): Promise<SyncStatus> {
-    return this.rpc.getSyncStatus();
-  }
-  addAuthWitness(messageHash: Fr, witness: Fr[]) {
-    return this.rpc.addAuthWitness(messageHash, witness);
-  }
-}
-
-/**
- * A simple wallet implementation that forwards authentication requests to a provided entrypoint implementation.
- */
-export class EntrypointWallet extends BaseWallet {
-  constructor(rpc: AztecRPC, protected accountImpl: Entrypoint) {
-    super(rpc);
-  }
-  createTxExecutionRequest(executions: FunctionCall[]): Promise<TxExecutionRequest> {
-    return this.accountImpl.createTxExecutionRequest(executions);
-  }
-}
-
-/**
- * A wallet implementation supporting auth witnesses.
- * This wallet inserts eip1271-like witnesses into the RPC, which are then fetched using an oracle
- * to provide authentication data to the contract during execution.
- */
-export class AuthWitnessEntrypointWallet extends BaseWallet {
-  constructor(rpc: AztecRPC, protected accountImpl: IAuthWitnessAccountEntrypoint, protected address: CompleteAddress) {
-    super(rpc);
-  }
-
-  /**
-   * Create a transaction request and add the auth witness to the RPC.
-   * Note:  When used in simulations, the witness that is inserted could be used later by attacker with
-   *        access to the RPC.
-   *        Meaning that if you were to use someone elses rpc with db you could send these transactions.
-   *        For simulations it would be desirable to bypass such that no data is generated.
-   *
-   * @param executions - The function calls to execute.
-   * @param opts - The options.
-   * @returns - The TxRequest
-   */
-  async createTxExecutionRequest(executions: FunctionCall[]): Promise<TxExecutionRequest> {
-    const { txRequest, message, witness } = await this.accountImpl.createTxExecutionRequestWithWitness(executions);
-    await this.rpc.addAuthWitness(Fr.fromBuffer(message), witness);
-    return txRequest;
-  }
-
-  sign(messageHash: Buffer): Promise<Buffer> {
-    return Promise.resolve(this.accountImpl.sign(messageHash));
-  }
-
-  /**
-   * Signs the `messageHash` and adds the witness to the RPC.
-   * This is useful for signing messages that are not directly part of the transaction payload, such as
-   * approvals .
-   * @param messageHash - The message hash to sign
-   * @param opts - The options.
-   */
-  async signAndAddAuthWitness(messageHash: Buffer): Promise<void> {
-    const witness = await this.accountImpl.createAuthWitness(messageHash);
-    await this.rpc.addAuthWitness(Fr.fromBuffer(messageHash), witness);
-    return Promise.resolve();
-  }
-
-  /**
-   * Signs the `messageHash` and adds the witness to the RPC.
-   * This is useful for signing messages that are not directly part of the transaction payload, such as
-   * approvals .
-   * @param messageHash - The message hash to sign
-   */
-  async signAndGetAuthWitness(messageHash: Buffer): Promise<Fr[]> {
-    return await this.accountImpl.createAuthWitness(messageHash);
-  }
-
-  /** Returns the complete address of the account that implements this wallet. */
-  public getCompleteAddress() {
-    return this.address;
-  }
-
-  /** Returns the address of the account that implements this wallet. */
-  public getAddress() {
-    return this.address.address;
-  }
-}
-
-/**
- * A wallet implementation that forwards authentication requests to a provided account.
- */
-export class AccountWallet extends EntrypointWallet {
-  constructor(rpc: AztecRPC, protected accountImpl: Entrypoint, protected address: CompleteAddress) {
-    super(rpc, accountImpl);
-  }
-
-  /** Returns the complete address of the account that implements this wallet. */
-  public getCompleteAddress() {
-    return this.address;
-  }
-
-  /** Returns the address of the account that implements this wallet. */
-  public getAddress() {
-    return this.address.address;
-  }
-}
-
-/**
- * Wallet implementation which creates a transaction request directly to the requested contract without any signing.
- */
-export class SignerlessWallet extends BaseWallet {
-  async createTxExecutionRequest(executions: FunctionCall[]): Promise<TxExecutionRequest> {
-    if (executions.length !== 1) {
-      throw new Error(`Unexpected number of executions. Expected 1, received ${executions.length})`);
-    }
-    const [execution] = executions;
-    const wasm = await CircuitsWasm.get();
-    const packedArguments = await PackedArguments.fromArgs(execution.args, wasm);
-    const { chainId, version } = await this.rpc.getNodeInfo();
-    const txContext = TxContext.empty(chainId, version);
-    return Promise.resolve(
-      new TxExecutionRequest(execution.to, execution.functionData, packedArguments.hash, txContext, [packedArguments]),
-    );
-  }
-}