@aztec/aztec.js 0.7.2 → 0.7.4

package/src/utils/account.ts

@@ -1,8 +1,8 @@
 import { CompleteAddress, GrumpkinScalar } from '@aztec/circuits.js';
 import { AztecRPC } from '@aztec/types';
 
-import { AccountWallet } from '../aztec_rpc_client/wallet.js';
 import { getSchnorrAccount } from '../index.js';
+import { AccountWallet } from '../wallet/account_wallet.js';
 
 /**
  * Deploys and registers a new account using random private keys and returns the associated wallet. Useful for testing.

package/src/wallet/account_wallet.ts

@@ -0,0 +1,70 @@
+import { Fr } from '@aztec/circuits.js';
+import { ABIParameterVisibility, FunctionAbiHeader, FunctionType } from '@aztec/foundation/abi';
+import { AuthWitness, AztecRPC, FunctionCall, TxExecutionRequest } from '@aztec/types';
+
+import { AccountInterface } from '../account/interface.js';
+import { ContractFunctionInteraction } from '../index.js';
+import { BaseWallet } from './base_wallet.js';
+
+/**
+ * A wallet implementation that forwards authentication requests to a provided account.
+ */
+export class AccountWallet extends BaseWallet {
+  constructor(rpc: AztecRPC, protected account: AccountInterface) {
+    super(rpc);
+  }
+
+  createTxExecutionRequest(execs: FunctionCall[]): Promise<TxExecutionRequest> {
+    return this.account.createTxExecutionRequest(execs);
+  }
+
+  async createAuthWitness(message: Fr | Buffer): Promise<AuthWitness> {
+    message = Buffer.isBuffer(message) ? Fr.fromBuffer(message) : message;
+    const witness = await this.account.createAuthWitness(message);
+    await this.rpc.addAuthWitness(witness);
+    return witness;
+  }
+
+  /**
+   * Returns a function interaction to set a message hash as authorized in this account.
+   * Public calls can then consume this authorization.
+   * @param message - Message hash to authorize.
+   * @param authorized - True to authorize, false to revoke authorization.
+   * @returns - A function interaction.
+   */
+  public setPublicAuth(message: Fr | Buffer, authorized: boolean): ContractFunctionInteraction {
+    const args = [message, authorized];
+    return new ContractFunctionInteraction(this, this.getAddress(), this.getSetIsValidStorageAbi(), args);
+  }
+
+  /** 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 getAddress() {
+    return this.getCompleteAddress().address;
+  }
+
+  private getSetIsValidStorageAbi(): FunctionAbiHeader {
+    return {
+      name: 'set_is_valid_storage',
+      functionType: 'open' as FunctionType,
+      isInternal: true,
+      parameters: [
+        {
+          name: 'message_hash',
+          type: { kind: 'field' },
+          visibility: 'private' as ABIParameterVisibility,
+        },
+        {
+          name: 'value',
+          type: { kind: 'boolean' },
+          visibility: 'private' as ABIParameterVisibility,
+        },
+      ],
+      returnTypes: [],
+    };
+  }
+}

package/src/wallet/base_wallet.ts

@@ -0,0 +1,103 @@
+import { AztecAddress, Fr, GrumpkinPrivateKey, PartialAddress } from '@aztec/circuits.js';
+import {
+  AuthWitness,
+  AztecRPC,
+  ContractData,
+  DeployedContract,
+  ExtendedContractData,
+  FunctionCall,
+  L2BlockL2Logs,
+  NodeInfo,
+  NotePreimage,
+  SyncStatus,
+  Tx,
+  TxExecutionRequest,
+  TxHash,
+  TxReceipt,
+} from '@aztec/types';
+
+import { CompleteAddress } from '../index.js';
+import { Wallet } from './index.js';
+
+/**
+ * A base class for Wallet implementations
+ */
+export abstract class BaseWallet implements Wallet {
+  constructor(protected readonly rpc: AztecRPC) {}
+
+  abstract getCompleteAddress(): CompleteAddress;
+
+  abstract createTxExecutionRequest(execs: FunctionCall[]): Promise<TxExecutionRequest>;
+
+  abstract createAuthWitness(message: Fr): Promise<AuthWitness>;
+
+  registerAccount(privKey: GrumpkinPrivateKey, partialAddress: PartialAddress): Promise<void> {
+    return this.rpc.registerAccount(privKey, partialAddress);
+  }
+  registerRecipient(account: CompleteAddress): Promise<void> {
+    return this.rpc.registerRecipient(account);
+  }
+  getRegisteredAccounts(): Promise<CompleteAddress[]> {
+    return this.rpc.getRegisteredAccounts();
+  }
+  getRegisteredAccount(address: AztecAddress): Promise<CompleteAddress | undefined> {
+    return this.rpc.getRegisteredAccount(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(authWitness: AuthWitness) {
+    return this.rpc.addAuthWitness(authWitness);
+  }
+}

package/src/wallet/index.ts

@@ -0,0 +1,10 @@
+import { AccountInterface, AztecRPC } from '../index.js';
+
+export * from './base_wallet.js';
+export * from './account_wallet.js';
+export * from './signerless_wallet.js';
+
+/**
+ * The wallet interface.
+ */
+export type Wallet = AccountInterface & AztecRPC;

package/src/wallet/signerless_wallet.ts

@@ -0,0 +1,39 @@
+import { CircuitsWasm, Fr, TxContext } from '@aztec/circuits.js';
+import { AuthWitness, FunctionCall, PackedArguments, TxExecutionRequest } from '@aztec/types';
+
+import { CompleteAddress } from '../index.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 {
+  async createTxExecutionRequest(executions: FunctionCall[]): Promise<TxExecutionRequest> {
+    if (executions.length !== 1) {
+      throw new Error(`Unexpected number of executions. Expected 1 but 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],
+        [],
+      ),
+    );
+  }
+
+  getCompleteAddress(): CompleteAddress {
+    throw new Error('Method not implemented.');
+  }
+
+  createAuthWitness(_message: Fr): Promise<AuthWitness> {
+    throw new Error('Method not implemented.');
+  }
+}

package/Dockerfile

@@ -1,15 +0,0 @@
-FROM 278380418400.dkr.ecr.eu-west-2.amazonaws.com/yarn-project-base AS builder
-
-COPY . .
-
-WORKDIR /usr/src/yarn-project/aztec.js
-RUN yarn build && yarn formatting && yarn test
-
-# Prune dev dependencies. See comment in base image.
-RUN yarn cache clean
-RUN yarn workspaces focus --production > /dev/null
-
-FROM node:18-alpine
-COPY --from=builder /usr/src/yarn-project/aztec.js /usr/src/yarn-project/aztec.js
-WORKDIR /usr/src/yarn-project/aztec.js
-ENTRYPOINT ["yarn"]