@aztec/aztec.js 0.0.0-test.0 → 0.0.1-commit.0208eb9

package/src/account/signerless_account.ts

@@ -0,0 +1,46 @@
+import type { ChainInfo, EntrypointInterface } from '@aztec/entrypoints/interfaces';
+import { DefaultMultiCallEntrypoint } from '@aztec/entrypoints/multicall';
+import type { Fr } from '@aztec/foundation/curves/bn254';
+import { AuthWitness } from '@aztec/stdlib/auth-witness';
+import type { AztecAddress } from '@aztec/stdlib/aztec-address';
+import type { CompleteAddress } from '@aztec/stdlib/contract';
+import type { GasSettings } from '@aztec/stdlib/gas';
+import type { ExecutionPayload, TxExecutionRequest } from '@aztec/stdlib/tx';
+
+import type { CallIntent, IntentInnerHash } from '../utils/authwit.js';
+import type { Account } from './account.js';
+
+/**
+ * Account implementation which creates a transaction using the multicall protocol contract as entrypoint.
+ */
+export class SignerlessAccount implements Account {
+  private entrypoint: EntrypointInterface;
+
+  constructor() {
+    this.entrypoint = new DefaultMultiCallEntrypoint();
+  }
+
+  createTxExecutionRequest(
+    exec: ExecutionPayload,
+    gasSettings: GasSettings,
+    chainInfo: ChainInfo,
+  ): Promise<TxExecutionRequest> {
+    return this.entrypoint.createTxExecutionRequest(exec, gasSettings, chainInfo);
+  }
+
+  wrapExecutionPayload(exec: ExecutionPayload, options?: any): Promise<ExecutionPayload> {
+    return this.entrypoint.wrapExecutionPayload(exec, options);
+  }
+
+  createAuthWit(_intent: Fr | Buffer | IntentInnerHash | CallIntent): Promise<AuthWitness> {
+    throw new Error('SignerlessAccount: Method createAuthWit not implemented.');
+  }
+
+  getCompleteAddress(): CompleteAddress {
+    throw new Error('SignerlessAccount: Method getCompleteAddress not implemented.');
+  }
+
+  getAddress(): AztecAddress {
+    throw new Error('SignerlessAccount: Method getAddress not implemented.');
+  }
+}

package/src/api/abi.ts

@@ -1,10 +1,36 @@
 export {
   type ContractArtifact,
   type FunctionArtifact,
+  type FunctionAbi,
   EventSelector,
+  FunctionType,
   FunctionSelector,
+  FunctionCall,
+  NoteSelector,
+  type ABIParameter,
+  decodeFromAbi,
+  encodeArguments,
+  type AbiType,
+  isAddressStruct,
+  isAztecAddressStruct,
+  isEthAddressStruct,
+  isWrappedFieldStruct,
+  isFunctionSelectorStruct,
   loadContractArtifact,
+  loadContractArtifactForPublic,
+  getAllFunctionAbis,
   contractArtifactToBuffer,
   contractArtifactFromBuffer,
 } from '@aztec/stdlib/abi';
 export { type NoirCompiledContract } from '@aztec/stdlib/noir';
+
+// Type converters for flexible parameter types in contract calls
+export {
+  type AztecAddressLike,
+  type EthAddressLike,
+  type EventSelectorLike,
+  type FieldLike,
+  type FunctionSelectorLike,
+  type U128Like,
+  type WrappedFieldLike,
+} from '../utils/abi_types.js';

package/src/api/account.ts

@@ -1,10 +1,13 @@
 export {
+  type Account,
   type AccountContract,
-  type AccountInterface,
-  type AuthWitnessProvider,
-  type Salt,
-  type Wallet,
+  AccountWithSecretKey,
+  BaseAccount,
+  type AuthorizationProvider,
   getAccountContractAddress,
+  type Salt,
 } from '../account/index.js';
+export type { AuthWitnessProvider, ChainInfo } from '@aztec/entrypoints/interfaces';
+export { ChainInfoSchema } from '@aztec/entrypoints/interfaces';
 
-export { AccountManager } from '../account_manager/index.js';
+export { SignerlessAccount } from '../account/signerless_account.js';

package/src/api/addresses.ts

@@ -1,2 +1,3 @@
 export { AztecAddress } from '@aztec/stdlib/aztec-address';
 export { CompleteAddress } from '@aztec/stdlib/contract';
+export { EthAddress } from '@aztec/foundation/eth-address';

package/src/api/authorization.ts

@@ -0,0 +1,15 @@
+export { AuthWitness } from '@aztec/stdlib/auth-witness';
+export {
+  SetPublicAuthwitContractInteraction,
+  type ContractFunctionInteractionCallIntent,
+  isContractFunctionInteractionCallIntent,
+  getMessageHashFromIntent,
+  computeAuthWitMessageHash,
+  computeInnerAuthWitHashFromAction,
+  lookupValidity,
+  type CallIntent,
+  type IntentInnerHash,
+} from '../utils/authwit.js';
+export { computeInnerAuthWitHash } from '@aztec/stdlib/auth-witness';
+
+export { CallAuthorizationRequest } from '../authorization/call_authorization_request.js';

package/src/api/block.ts

@@ -0,0 +1,2 @@
+export { Body, L2Block } from '@aztec/stdlib/block';
+export { getTimestampRangeForEpoch } from '@aztec/stdlib/epoch-helpers';

package/src/api/contract.ts

@@ -0,0 +1,88 @@
+/**
+ * The `contract` module provides utilities for deploying and interacting with contracts, based on a
+ * `Wallet` instance and a compiled artifact. Refer to the {@link account} module for how to obtain a valid
+ * `Wallet` instance, and to the {@link https://docs.aztec.network/developers/aztec-nr/how_to_compile_contract | Compiling contracts}
+ * section of the documentation for how to generate an artifact out of your Noir source code.
+ *
+ * The {@link Contract} class is the main class in this module, and provides static methods for deploying
+ * a contract or interacting with an already deployed one. The `methods` property of the contract instance
+ * provides access to private, public, and simulate methods, that can be invoked in a transaction via `send()`,
+ * or can be queried via `simulate()`.
+ *
+ * ```ts
+ * // Deploy and get the contract instance directly (default behavior)
+ * const contract = await Contract.deploy(wallet, MyContractArtifact, [...constructorArgs]).send({ from: accountAddress });
+ * console.log(`Contract deployed at ${contract.address}`);
+ *
+ * // Or get the full receipt with contract and instance
+ * const receipt = await Contract.deploy(wallet, MyContractArtifact, [...constructorArgs]).send({
+ *   from: accountAddress,
+ *   wait: { returnReceipt: true }
+ * });
+ * console.log(`Contract deployed at ${receipt.contract.address}`);
+ * ```
+ *
+ * ```ts
+ * const contract = Contract.at(address, MyContractArtifact, wallet);
+ * await contract.methods.mint(1000, owner).send({ from: accountAddress });
+ * console.log(`Total supply is now ${await contract.methods.totalSupply().simulate()}`);
+ * ```
+ *
+ * The result of calling a method in a contract instance, such as `contract.methods.mint(1000, owner)`
+ * in the example, is a {@link ContractFunctionInteraction} instance. Usually this will be just sent as
+ * a transaction to the network via the `send` method, but you can also `simulate` it without sending,
+ * or obtaining the `request` for aggregating into a {@link BatchCall}.
+ *
+ * The `send` method returns a {@link TxReceipt} by default (waits for the transaction to be mined).
+ * If you pass `wait: NO_WAIT` in the options, it will return a {@link TxHash} immediately without waiting.
+ *
+ * @remarks If you are using typescript, consider using the
+ * {@link https://docs.aztec.network/developers/aztec-nr/how_to_compile_contract#use-generated-interfaces | autogenerated type-safe interfaces}
+ * for interacting with your contracts.
+ *
+ * @packageDocumentation
+ */
+export { Contract } from '../contract/contract.js';
+export { ContractFunctionInteraction } from '../contract/contract_function_interaction.js';
+
+export {
+  NO_WAIT,
+  type NoWait,
+  type RequestInteractionOptions,
+  type SendInteractionOptions,
+  type ProfileInteractionOptions,
+  type SimulateInteractionOptions,
+  type InteractionFeeOptions,
+  type InteractionWaitOptions,
+  type GasSettingsOption,
+  type SendReturn,
+  type SimulationReturn,
+  toProfileOptions,
+  toSendOptions,
+  toSimulateOptions,
+} from '../contract/interaction_options.js';
+
+export { DefaultWaitOpts, type WaitOpts } from '../contract/wait_opts.js';
+export { ContractBase, type ContractMethod, type ContractStorageLayout } from '../contract/contract_base.js';
+export { BatchCall } from '../contract/batch_call.js';
+export {
+  type DeployOptions,
+  type DeployReturn,
+  type DeployTxReceipt,
+  type DeployWaitOptions,
+  type DeployInteractionWaitOptions,
+  DeployMethod,
+  type RequestDeployOptions,
+  type SimulateDeployOptions,
+} from '../contract/deploy_method.js';
+export { waitForProven, type WaitForProvenOpts, DefaultWaitForProvenOpts } from '../contract/wait_for_proven.js';
+export { getGasLimits } from '../contract/get_gas_limits.js';
+
+export {
+  type PartialAddress,
+  type ContractClassWithId,
+  type ContractInstanceWithAddress,
+  getContractClassFromArtifact,
+  getContractInstanceFromInstantiationParams,
+  type NodeInfo,
+} from '@aztec/stdlib/contract';

package/src/api/crypto.ts

@@ -0,0 +1 @@
+export { computeSecretHash } from '@aztec/stdlib/hash';

package/src/api/deployment.ts

@@ -1,3 +1,4 @@
-export { registerContractClass } from '../deployment/register_class.js';
-export { broadcastPrivateFunction, broadcastUnconstrainedFunction } from '../deployment/broadcast_function.js';
-export { deployInstance } from '../deployment/deploy_instance.js';
+export { publishContractClass } from '../deployment/publish_class.js';
+export { broadcastPrivateFunction, broadcastUtilityFunction } from '../deployment/broadcast_function.js';
+export { publishInstance } from '../deployment/publish_instance.js';
+export { ContractDeployer } from '../deployment/contract_deployer.js';

package/src/api/ethereum.ts

@@ -0,0 +1,10 @@
+export {
+  L1FeeJuicePortalManager,
+  L1ToL2TokenPortalManager,
+  L1TokenManager,
+  L1TokenPortalManager,
+  type L2AmountClaim,
+  type L2AmountClaimWithRecipient,
+  type L2Claim,
+  generateClaimSecret,
+} from '../ethereum/portal_manager.js';

package/src/api/events.ts

@@ -0,0 +1,44 @@
+import { type EventMetadataDefinition, EventSelector, decodeFromAbi } from '@aztec/stdlib/abi';
+import type { AztecNode } from '@aztec/stdlib/interfaces/client';
+
+/**
+ * Returns decoded public events given search parameters.
+ * @param node - The node to request events from
+ * @param eventMetadata - Metadata of the event. This should be the class generated from the contract. e.g. Contract.events.Event
+ * @param from - The block number to search from.
+ * @param limit - The amount of blocks to search.
+ * @returns - The deserialized events.
+ */
+export async function getDecodedPublicEvents<T>(
+  node: AztecNode,
+  eventMetadataDef: EventMetadataDefinition,
+  from: number,
+  limit: number,
+): Promise<T[]> {
+  const { logs } = await node.getPublicLogs({
+    fromBlock: from,
+    toBlock: from + limit,
+  });
+
+  const decodedEvents = logs
+    .map(log => {
+      // +1 for the event selector
+      const expectedLength = eventMetadataDef.fieldNames.length + 1;
+      if (log.log.fields.length !== expectedLength) {
+        throw new Error(
+          `Something is weird here, we have matching EventSelectors, but the actual payload has mismatched length. Expected ${expectedLength}. Got ${log.log.fields.length}.`,
+        );
+      }
+
+      const logFields = log.log.getEmittedFields();
+      // We are assuming here that event logs are the last 4 bytes of the event. This is not enshrined but is a function of aztec.nr raw log emission.
+      if (!EventSelector.fromField(logFields[logFields.length - 1]).equals(eventMetadataDef.eventSelector)) {
+        return undefined;
+      }
+
+      return decodeFromAbi([eventMetadataDef.abiType], log.log.fields) as T;
+    })
+    .filter(log => log !== undefined) as T[];
+
+  return decodedEvents;
+}

package/src/api/fee.ts

@@ -1,5 +1,5 @@
 export type { FeePaymentMethod } from '../fee/fee_payment_method.js';
-export { FeeJuicePaymentMethod } from '../fee/fee_juice_payment_method.js';
 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 { SponsoredFeePaymentMethod } from '../fee/sponsored_fee_payment.js';

package/src/api/fee_testing.ts

@@ -0,0 +1 @@
+export { SponsoredFeePaymentMethod } from '../fee/sponsored_fee_payment.js';

package/src/api/fields.ts

@@ -1 +1,2 @@
-export { Point, Fr, Fq, GrumpkinScalar } from '@aztec/foundation/fields';
+export { Fr, Fq } from '@aztec/foundation/curves/bn254';
+export { GrumpkinScalar, Point } from '@aztec/foundation/curves/grumpkin';

package/src/api/keys.ts

@@ -0,0 +1,8 @@
+export { type PublicKey, PublicKeys } from '@aztec/stdlib/keys';
+export {
+  computeAppNullifierHidingKey,
+  deriveKeys,
+  deriveMasterIncomingViewingSecretKey,
+  deriveMasterNullifierHidingKey,
+} from '@aztec/stdlib/keys';
+export { generatePublicKey } from '../utils/pub_key.js';

package/src/api/log.ts

@@ -1 +1,2 @@
 export { createLogger, type Logger } from '@aztec/foundation/log';
+export { LogId, type LogFilter } from '@aztec/stdlib/logs';

package/src/api/messaging.ts

@@ -0,0 +1,2 @@
+export { L1ToL2Message, L2Actor, L1Actor } from '@aztec/stdlib/messaging';
+export { isL1ToL2MessageReady, waitForL1ToL2MessageReady } from '../utils/cross_chain.js';

package/src/api/node.ts

@@ -0,0 +1,24 @@
+/**
+ * The `node` module provides utilities for connecting to and interacting with an Aztec node.
+ *
+ * The primary function is {@link createAztecNodeClient}, which creates a JSON-RPC client
+ * that connects to a running Aztec node instance. Use {@link waitForNode} to wait for
+ * the node to be ready before proceeding, and {@link waitForTx} to wait for a transaction
+ * to be mined.
+ *
+ * @example
+ * ```ts
+ * import { createAztecNodeClient, waitForNode, waitForTx } from '@aztec/aztec.js/node';
+ *
+ * const node = createAztecNodeClient('http://localhost:8080');
+ * await waitForNode(node);
+ * const blockNumber = await node.getBlockNumber();
+ *
+ * // Wait for a transaction
+ * const receipt = await waitForTx(node, txHash);
+ * ```
+ *
+ * @packageDocumentation
+ */
+export { createAztecNodeClient, waitForNode, waitForTx, type AztecNode } from '../utils/node.js';
+export { type NodeInfo } from '@aztec/stdlib/contract';

package/src/api/note.ts

@@ -0,0 +1 @@
+export { Comparator, Note } from '@aztec/stdlib/note';

package/src/api/protocol.ts

@@ -0,0 +1,9 @@
+export { ProtocolContractAddress } from '@aztec/protocol-contracts';
+export { INITIAL_L2_BLOCK_NUM } from '@aztec/constants';
+
+export { AuthRegistryContract } from '../contract/protocol_contracts/auth-registry.js';
+export { ContractClassRegistryContract } from '../contract/protocol_contracts/contract-class-registry.js';
+export { ContractInstanceRegistryContract } from '../contract/protocol_contracts/contract-instance-registry.js';
+export { FeeJuiceContract } from '../contract/protocol_contracts/fee-juice.js';
+export { MultiCallEntrypointContract } from '../contract/protocol_contracts/multi-call-entrypoint.js';
+export { PublicChecksContract } from '../contract/protocol_contracts/public-checks.js';

package/src/api/trees.ts

@@ -0,0 +1,2 @@
+export { SiblingPath } from '@aztec/foundation/trees';
+export { MerkleTreeId, merkleTreeIds } from '@aztec/stdlib/trees';

package/src/api/tx.ts

@@ -0,0 +1,15 @@
+export {
+  Tx,
+  TxExecutionRequest,
+  TxExecutionResult,
+  TxHash,
+  TxReceipt,
+  TxStatus,
+  SortedTxStatuses,
+  Capsule,
+  HashedValues,
+  GlobalVariables,
+  TxProfileResult,
+  ExecutionPayload,
+  mergeExecutionPayloads,
+} from '@aztec/stdlib/tx';

package/src/api/utils.ts

@@ -0,0 +1,14 @@
+/**
+ * Utility functions for aztec.js.
+ *
+ * NOTE: This module contains low-usage utilities and may be deprecated in the future.
+ * Prefer using more specific modules:
+ * - Node connection utilities → `@aztec/aztec.js/node`
+ * - Type converters → `@aztec/aztec.js/abi`
+ * - Key generation → `@aztec/aztec.js/keys`
+ * - Messaging utilities → `@aztec/aztec.js/messaging`
+ */
+
+// Low-usage utilities - consider these internal/experimental
+export { getFeeJuiceBalance } from '../utils/fee_juice.js';
+export { readFieldCompressedString } from '../utils/field_compressed_string.js';

package/src/api/wallet.ts

@@ -1,7 +1,74 @@
 export {
-  AccountWallet,
-  AccountWalletWithSecretKey as AccountWalletWithSecretKey,
-  SignerlessWallet,
+  type Aliased,
+  type SimulateOptions,
+  type ProfileOptions,
+  type SendOptions,
+  type BatchableMethods,
+  type BatchedMethod,
+  type BatchedMethodResult,
+  type BatchedMethodResultWrapper,
+  type BatchResults,
   type Wallet,
-  getWallet,
-} from '../wallet/index.js';
+  type PrivateEvent,
+  type PrivateEventFilter,
+  type ContractMetadata,
+  type ContractClassMetadata,
+  AppCapabilitiesSchema,
+  WalletCapabilitiesSchema,
+  FunctionCallSchema,
+  ExecutionPayloadSchema,
+  GasSettingsOptionSchema,
+  WalletSimulationFeeOptionSchema,
+  WaitOptsSchema,
+  SendOptionsSchema,
+  SimulateOptionsSchema,
+  ProfileOptionsSchema,
+  MessageHashOrIntentSchema,
+  BatchedMethodSchema,
+  EventMetadataDefinitionSchema,
+  PrivateEventSchema,
+  PrivateEventFilterSchema,
+  ContractClassMetadataSchema,
+  ContractMetadataSchema,
+  WalletSchema,
+  ContractFunctionPatternSchema,
+  AccountsCapabilitySchema,
+  GrantedAccountsCapabilitySchema,
+  ContractsCapabilitySchema,
+  GrantedContractsCapabilitySchema,
+  ContractClassesCapabilitySchema,
+  GrantedContractClassesCapabilitySchema,
+  SimulationCapabilitySchema,
+  GrantedSimulationCapabilitySchema,
+  TransactionCapabilitySchema,
+  GrantedTransactionCapabilitySchema,
+  DataCapabilitySchema,
+  GrantedDataCapabilitySchema,
+  CapabilitySchema,
+  GrantedCapabilitySchema,
+} from '../wallet/wallet.js';
+
+export {
+  type AppCapabilities,
+  type WalletCapabilities,
+  CAPABILITY_VERSION,
+  type Capability,
+  type GrantedCapability,
+  type ContractFunctionPattern,
+  type AccountsCapability,
+  type GrantedAccountsCapability,
+  type ContractsCapability,
+  type GrantedContractsCapability,
+  type ContractClassesCapability,
+  type GrantedContractClassesCapability,
+  type SimulationCapability,
+  type GrantedSimulationCapability,
+  type TransactionCapability,
+  type GrantedTransactionCapability,
+  type DataCapability,
+  type GrantedDataCapability,
+} from '../wallet/capabilities.js';
+
+export { AccountManager } from '../wallet/account_manager.js';
+
+export { type DeployAccountOptions, DeployAccountMethod } from '../wallet/deploy_account_method.js';

package/src/authorization/call_authorization_request.ts

@@ -0,0 +1,63 @@
+import type { Fr } from '@aztec/foundation/curves/bn254';
+import { FieldReader } from '@aztec/foundation/serialize';
+import { AuthorizationSelector, FunctionSelector } from '@aztec/stdlib/abi';
+import { AztecAddress } from '@aztec/stdlib/aztec-address';
+
+/**
+ * An authwit request for a function call. Includes the preimage of the data
+ * to be signed, as opposed of just the inner hash.
+ */
+export class CallAuthorizationRequest {
+  constructor(
+    /**
+     * The selector of the authwit type, used to identify it
+     * when emitted from `emit_offchain_effect`oracle.
+     * Computed as poseidon2("CallAuthwit((Field),(u32),Field)".to_bytes())
+     */
+    public selector: AuthorizationSelector,
+    /**
+     * The inner hash of the authwit, computed as
+     * poseidon2([msg_sender, selector, args_hash])
+     */
+    public innerHash: Fr,
+    /**
+     * The address performing the call
+     */
+    public msgSender: AztecAddress,
+    /**
+     * The selector of the function that is to be authorized
+     * */
+    public functionSelector: FunctionSelector,
+    /**
+     * The hash of the arguments to the function call,
+     */
+    public argsHash: Fr,
+    /**
+     * The arguments to the function call.
+     */
+    public args: Fr[],
+  ) {}
+
+  static getSelector(): Promise<AuthorizationSelector> {
+    return AuthorizationSelector.fromSignature('CallAuthorization((Field),(u32),Field)');
+  }
+
+  static async fromFields(fields: Fr[]): Promise<CallAuthorizationRequest> {
+    const expectedSelector = await CallAuthorizationRequest.getSelector();
+    const reader = FieldReader.asReader(fields);
+    const selector = AuthorizationSelector.fromField(reader.readField());
+    if (!selector.equals(expectedSelector)) {
+      throw new Error(
+        `Invalid authorization selector for CallAuthwit: expected ${expectedSelector.toString()}, got ${selector.toString()}`,
+      );
+    }
+    return new CallAuthorizationRequest(
+      selector,
+      reader.readField(),
+      AztecAddress.fromField(reader.readField()),
+      FunctionSelector.fromField(reader.readField()),
+      reader.readField(),
+      reader.readFieldArray(reader.remainingFields()),
+    );
+  }
+}