@aztec/accounts 0.23.0 → 0.26.1

package/src/defaults/account_contract.ts

@@ -0,0 +1,25 @@
+import { AccountContract, AccountInterface, AuthWitnessProvider } from '@aztec/aztec.js/account';
+import { CompleteAddress } from '@aztec/circuit-types';
+import { ContractArtifact } from '@aztec/foundation/abi';
+import { NodeInfo } from '@aztec/types/interfaces';
+
+import { DefaultAccountInterface } from '../defaults/account_interface.js';
+
+/**
+ * Base class for implementing an account contract. Requires that the account uses the
+ * default entrypoint method signature.
+ */
+export abstract class DefaultAccountContract implements AccountContract {
+  abstract getAuthWitnessProvider(address: CompleteAddress): AuthWitnessProvider;
+  abstract getDeploymentArgs(): any[];
+
+  constructor(private artifact: ContractArtifact) {}
+
+  getContractArtifact(): ContractArtifact {
+    return this.artifact;
+  }
+
+  getInterface(address: CompleteAddress, nodeInfo: NodeInfo): AccountInterface {
+    return new DefaultAccountInterface(this.getAuthWitnessProvider(address), address, nodeInfo);
+  }
+}

package/src/defaults/account_interface.ts

@@ -0,0 +1,38 @@
+import { AccountInterface, AuthWitnessProvider, EntrypointInterface, FeeOptions } from '@aztec/aztec.js/account';
+import { AuthWitness, FunctionCall, TxExecutionRequest } from '@aztec/circuit-types';
+import { CompleteAddress, Fr } from '@aztec/circuits.js';
+import { DefaultAccountEntrypoint } from '@aztec/entrypoints/account';
+import { NodeInfo } from '@aztec/types/interfaces';
+
+/**
+ * Default implementation for an account interface. Requires that the account uses the default
+ * entrypoint signature, which accept an AppPayload and a FeePayload as defined in noir-libs/aztec-noir/src/entrypoint module
+ */
+export class DefaultAccountInterface implements AccountInterface {
+  private entrypoint: EntrypointInterface;
+
+  constructor(
+    private authWitnessProvider: AuthWitnessProvider,
+    private address: CompleteAddress,
+    nodeInfo: Pick<NodeInfo, 'chainId' | 'protocolVersion'>,
+  ) {
+    this.entrypoint = new DefaultAccountEntrypoint(
+      address.address,
+      authWitnessProvider,
+      nodeInfo.chainId,
+      nodeInfo.protocolVersion,
+    );
+  }
+
+  createTxExecutionRequest(executions: FunctionCall[], fee?: FeeOptions): Promise<TxExecutionRequest> {
+    return this.entrypoint.createTxExecutionRequest(executions, fee);
+  }
+
+  createAuthWitness(message: Fr): Promise<AuthWitness> {
+    return this.authWitnessProvider.createAuthWitness(message);
+  }
+
+  getCompleteAddress(): CompleteAddress {
+    return this.address;
+  }
+}

package/src/defaults/index.ts

@@ -0,0 +1,10 @@
+/**
+ * The `@aztec/accounts/defaults` export provides the base class {@link DefaultAccountContract} for implementing account contracts that use the default entrypoint payload module.
+ *
+ * Read more in {@link https://docs.aztec.network/developers/wallets/writing_an_account_contract | Writing an account contract}.
+ *
+ * @packageDocumentation
+ */
+
+export * from './account_interface.js';
+export * from './account_contract.js';

package/src/ecdsa/account_contract.ts

@@ -0,0 +1,38 @@
+import { AuthWitnessProvider } from '@aztec/aztec.js/account';
+import { AuthWitness, CompleteAddress } from '@aztec/circuit-types';
+import { Ecdsa } from '@aztec/circuits.js/barretenberg';
+import { ContractArtifact } from '@aztec/foundation/abi';
+import { Fr } from '@aztec/foundation/fields';
+
+import { DefaultAccountContract } from '../defaults/account_contract.js';
+import { EcdsaAccountContractArtifact } from './artifact.js';
+
+/**
+ * Account contract that authenticates transactions using ECDSA signatures
+ * verified against a secp256k1 public key stored in an immutable encrypted note.
+ */
+export class EcdsaAccountContract extends DefaultAccountContract {
+  constructor(private signingPrivateKey: Buffer) {
+    super(EcdsaAccountContractArtifact as ContractArtifact);
+  }
+
+  getDeploymentArgs() {
+    const signingPublicKey = new Ecdsa().computePublicKey(this.signingPrivateKey);
+    return [signingPublicKey.subarray(0, 32), signingPublicKey.subarray(32, 64)];
+  }
+
+  getAuthWitnessProvider(_address: CompleteAddress): AuthWitnessProvider {
+    return new EcdsaAuthWitnessProvider(this.signingPrivateKey);
+  }
+}
+
+/** Creates auth witnesses using ECDSA signatures. */
+class EcdsaAuthWitnessProvider implements AuthWitnessProvider {
+  constructor(private signingPrivateKey: Buffer) {}
+
+  createAuthWitness(message: Fr): Promise<AuthWitness> {
+    const ecdsa = new Ecdsa();
+    const signature = ecdsa.constructSignature(message.toBuffer(), this.signingPrivateKey);
+    return Promise.resolve(new AuthWitness(message, [...signature.r, ...signature.s]));
+  }
+}

package/src/ecdsa/artifact.ts

@@ -0,0 +1,5 @@
+import { NoirCompiledContract, loadContractArtifact } from '@aztec/aztec.js';
+
+import EcdsaAccountContractJson from '../artifacts/EcdsaAccount.json' assert { type: 'json' };
+
+export const EcdsaAccountContractArtifact = loadContractArtifact(EcdsaAccountContractJson as NoirCompiledContract);

package/src/ecdsa/index.ts

@@ -0,0 +1,42 @@
+/**
+ * The `@aztec/accounts/ecdsa` export provides an ECDSA account contract implementation, that uses an ECDSA private key for authentication, and a Grumpkin key for encryption.
+ * Consider using this account type when working with integrations with Ethereum wallets.
+ *
+ * @packageDocumentation
+ */
+import { AccountManager, Salt } from '@aztec/aztec.js/account';
+import { AccountWallet, getWallet } from '@aztec/aztec.js/wallet';
+import { GrumpkinPrivateKey, PXE } from '@aztec/circuit-types';
+import { AztecAddress } from '@aztec/circuits.js';
+
+import { EcdsaAccountContract } from './account_contract.js';
+
+export { EcdsaAccountContractArtifact } from './artifact.js';
+export { EcdsaAccountContract };
+
+/**
+ * Creates an Account that relies on an ECDSA signing key for authentication.
+ * @param pxe - An PXE server instance.
+ * @param encryptionPrivateKey - Grumpkin key used for note encryption.
+ * @param signingPrivateKey - Secp256k1 key used for signing transactions.
+ * @param salt - Deployment salt.
+ */
+export function getEcdsaAccount(
+  pxe: PXE,
+  encryptionPrivateKey: GrumpkinPrivateKey,
+  signingPrivateKey: Buffer,
+  salt?: Salt,
+): AccountManager {
+  return new AccountManager(pxe, encryptionPrivateKey, new EcdsaAccountContract(signingPrivateKey), salt);
+}
+
+/**
+ * Gets a wallet for an already registered account using ECDSA signatures.
+ * @param pxe - An PXE server instance.
+ * @param address - Address for the account.
+ * @param signingPrivateKey - ECDSA key used for signing transactions.
+ * @returns A wallet for this account that can be used to interact with a contract instance.
+ */
+export function getEcdsaWallet(pxe: PXE, address: AztecAddress, signingPrivateKey: Buffer): Promise<AccountWallet> {
+  return getWallet(pxe, address, new EcdsaAccountContract(signingPrivateKey));
+}

package/src/schnorr/account_contract.ts

@@ -0,0 +1,38 @@
+import { AuthWitnessProvider } from '@aztec/aztec.js/account';
+import { AuthWitness, CompleteAddress, GrumpkinPrivateKey } from '@aztec/circuit-types';
+import { Schnorr } from '@aztec/circuits.js/barretenberg';
+import { ContractArtifact } from '@aztec/foundation/abi';
+import { Fr } from '@aztec/foundation/fields';
+
+import { DefaultAccountContract } from '../defaults/account_contract.js';
+import { SchnorrAccountContractArtifact } from './artifact.js';
+
+/**
+ * Account contract that authenticates transactions using Schnorr signatures
+ * verified against a Grumpkin public key stored in an immutable encrypted note.
+ */
+export class SchnorrAccountContract extends DefaultAccountContract {
+  constructor(private signingPrivateKey: GrumpkinPrivateKey) {
+    super(SchnorrAccountContractArtifact as ContractArtifact);
+  }
+
+  getDeploymentArgs() {
+    const signingPublicKey = new Schnorr().computePublicKey(this.signingPrivateKey);
+    return [signingPublicKey.x, signingPublicKey.y];
+  }
+
+  getAuthWitnessProvider(_address: CompleteAddress): AuthWitnessProvider {
+    return new SchnorrAuthWitnessProvider(this.signingPrivateKey);
+  }
+}
+
+/** Creates auth witnesses using Schnorr signatures. */
+class SchnorrAuthWitnessProvider implements AuthWitnessProvider {
+  constructor(private signingPrivateKey: GrumpkinPrivateKey) {}
+
+  createAuthWitness(message: Fr): Promise<AuthWitness> {
+    const schnorr = new Schnorr();
+    const signature = schnorr.constructSignature(message.toBuffer(), this.signingPrivateKey).toBuffer();
+    return Promise.resolve(new AuthWitness(message, [...signature]));
+  }
+}

package/src/schnorr/artifact.ts

@@ -0,0 +1,5 @@
+import { NoirCompiledContract, loadContractArtifact } from '@aztec/aztec.js';
+
+import SchnorrAccountContractJson from '../artifacts/SchnorrAccount.json' assert { type: 'json' };
+
+export const SchnorrAccountContractArtifact = loadContractArtifact(SchnorrAccountContractJson as NoirCompiledContract);

package/src/schnorr/index.ts

@@ -0,0 +1,47 @@
+/**
+ * The `@aztec/accounts/schnorr` export provides an account contract implementation that uses Schnorr signatures with a Grumpkin key for authentication, and a separate Grumpkin key for encryption.
+ * This is the suggested account contract type for most use cases within Aztec.
+ *
+ * @packageDocumentation
+ */
+import { AccountManager, Salt } from '@aztec/aztec.js/account';
+import { AccountWallet, getWallet } from '@aztec/aztec.js/wallet';
+import { GrumpkinPrivateKey, PXE } from '@aztec/circuit-types';
+import { AztecAddress } from '@aztec/circuits.js';
+
+import { SchnorrAccountContract } from './account_contract.js';
+
+export { SchnorrAccountContract };
+
+export { SchnorrAccountContractArtifact } from './artifact.js';
+
+/**
+ * Creates an Account Manager that relies on a Grumpkin signing key for authentication.
+ * @param pxe - An PXE server instance.
+ * @param encryptionPrivateKey - Grumpkin key used for note encryption.
+ * @param signingPrivateKey - Grumpkin key used for signing transactions.
+ * @param salt - Deployment salt.
+ */
+export function getSchnorrAccount(
+  pxe: PXE,
+  encryptionPrivateKey: GrumpkinPrivateKey,
+  signingPrivateKey: GrumpkinPrivateKey,
+  salt?: Salt,
+): AccountManager {
+  return new AccountManager(pxe, encryptionPrivateKey, new SchnorrAccountContract(signingPrivateKey), salt);
+}
+
+/**
+ * Gets a wallet for an already registered account using Schnorr signatures.
+ * @param pxe - An PXE server instance.
+ * @param address - Address for the account.
+ * @param signingPrivateKey - Grumpkin key used for signing transactions.
+ * @returns A wallet for this account that can be used to interact with a contract instance.
+ */
+export function getSchnorrWallet(
+  pxe: PXE,
+  address: AztecAddress,
+  signingPrivateKey: GrumpkinPrivateKey,
+): Promise<AccountWallet> {
+  return getWallet(pxe, address, new SchnorrAccountContract(signingPrivateKey));
+}

package/src/single_key/account_contract.ts

@@ -0,0 +1,45 @@
+import { generatePublicKey } from '@aztec/aztec.js';
+import { AuthWitnessProvider } from '@aztec/aztec.js/account';
+import { AuthWitness, CompleteAddress, GrumpkinPrivateKey } from '@aztec/circuit-types';
+import { PartialAddress } from '@aztec/circuits.js';
+import { Schnorr } from '@aztec/circuits.js/barretenberg';
+import { ContractArtifact } from '@aztec/foundation/abi';
+import { Fr } from '@aztec/foundation/fields';
+
+import { DefaultAccountContract } from '../defaults/account_contract.js';
+import { SchnorrSingleKeyAccountContractArtifact } from './artifact.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.
+ */
+export class SingleKeyAccountContract extends DefaultAccountContract {
+  constructor(private encryptionPrivateKey: GrumpkinPrivateKey) {
+    super(SchnorrSingleKeyAccountContractArtifact as ContractArtifact);
+  }
+
+  getDeploymentArgs(): any[] {
+    return [];
+  }
+
+  getAuthWitnessProvider({ partialAddress }: CompleteAddress): AuthWitnessProvider {
+    return new SingleKeyAuthWitnessProvider(this.encryptionPrivateKey, partialAddress);
+  }
+}
+
+/**
+ * Creates auth witnesses using Schnorr signatures and including the partial address and public key
+ * in the witness, so verifiers do not need to store the public key and can instead validate it
+ * by reconstructing the current address.
+ */
+class SingleKeyAuthWitnessProvider implements AuthWitnessProvider {
+  constructor(private privateKey: GrumpkinPrivateKey, private partialAddress: PartialAddress) {}
+
+  createAuthWitness(message: Fr): Promise<AuthWitness> {
+    const schnorr = new Schnorr();
+    const signature = schnorr.constructSignature(message.toBuffer(), this.privateKey);
+    const publicKey = generatePublicKey(this.privateKey);
+    const witness = [...publicKey.toFields(), ...signature.toBuffer(), this.partialAddress];
+    return Promise.resolve(new AuthWitness(message, witness));
+  }
+}

package/src/single_key/artifact.ts

@@ -0,0 +1,7 @@
+import { NoirCompiledContract, loadContractArtifact } from '@aztec/aztec.js';
+
+import SchnorrSingleKeyAccountContractJson from '../artifacts/SchnorrSingleKeyAccount.json' assert { type: 'json' };
+
+export const SchnorrSingleKeyAccountContractArtifact = loadContractArtifact(
+  SchnorrSingleKeyAccountContractJson as NoirCompiledContract,
+);

package/src/single_key/index.ts

@@ -0,0 +1,52 @@
+/**
+ * The `@aztec/accounts/single_key` export provides a testing account contract implementation that uses a single Grumpkin key for both authentication and encryption.
+ * It is not recommended to use this account type in production.
+ *
+ * @packageDocumentation
+ */
+import { AccountManager, Salt } from '@aztec/aztec.js/account';
+import { AccountWallet, getWallet } from '@aztec/aztec.js/wallet';
+import { GrumpkinPrivateKey, PXE } from '@aztec/circuit-types';
+import { AztecAddress } from '@aztec/circuits.js';
+
+import { SingleKeyAccountContract } from './account_contract.js';
+
+export { SingleKeyAccountContract };
+
+export { SchnorrSingleKeyAccountContractArtifact as SingleKeyAccountContractArtifact } from './artifact.js';
+
+/**
+ * Creates an Account that uses the same Grumpkin key for encryption and authentication.
+ * @param pxe - An PXE server instance.
+ * @param encryptionAndSigningPrivateKey - Grumpkin key used for note encryption and signing transactions.
+ * @param salt - Deployment salt .
+ */
+export function getSingleKeyAccount(
+  pxe: PXE,
+  encryptionAndSigningPrivateKey: GrumpkinPrivateKey,
+  salt?: Salt,
+): AccountManager {
+  return new AccountManager(
+    pxe,
+    encryptionAndSigningPrivateKey,
+    new SingleKeyAccountContract(encryptionAndSigningPrivateKey),
+    salt,
+  );
+}
+
+/**
+ * Gets a wallet for an already registered account using Schnorr signatures with a single key for encryption and authentication.
+ * @param pxe - An PXE server instance.
+ * @param address - Address for the account.
+ * @param signingPrivateKey - Grumpkin key used for note encryption and signing transactions.
+ * @returns A wallet for this account that can be used to interact with a contract instance.
+ */
+export function getSingleKeyWallet(
+  pxe: PXE,
+  address: AztecAddress,
+  signingKey: GrumpkinPrivateKey,
+): Promise<AccountWallet> {
+  return getWallet(pxe, address, new SingleKeyAccountContract(signingKey));
+}
+
+export { getSingleKeyAccount as getUnsafeSchnorrAccount, getSingleKeyWallet as getUnsafeSchnorrWallet };

package/src/testing/configuration.ts

@@ -0,0 +1,85 @@
+import { generatePublicKey } from '@aztec/aztec.js';
+import { AccountWalletWithPrivateKey } from '@aztec/aztec.js/wallet';
+import { PXE } from '@aztec/circuit-types';
+import { Fr, GrumpkinScalar } from '@aztec/foundation/fields';
+
+import { getSchnorrAccount } from '../schnorr/index.js';
+
+export const INITIAL_TEST_ENCRYPTION_KEYS = [
+  GrumpkinScalar.fromString('2153536ff6628eee01cf4024889ff977a18d9fa61d0e414422f7681cf085c281'),
+  GrumpkinScalar.fromString('aebd1b4be76efa44f5ee655c20bf9ea60f7ae44b9a7fd1fd9f189c7a0b0cdae'),
+  GrumpkinScalar.fromString('0f6addf0da06c33293df974a565b03d1ab096090d907d98055a8b7f4954e120c'),
+];
+
+export const INITIAL_TEST_SIGNING_KEYS = INITIAL_TEST_ENCRYPTION_KEYS;
+
+export const INITIAL_TEST_ACCOUNT_SALTS = [Fr.ZERO, Fr.ZERO, Fr.ZERO];
+
+/**
+ * Gets a collection of wallets for the Aztec accounts that are initially stored in the test environment.
+ * @param pxe - PXE instance.
+ * @returns A set of AccountWallet implementations for each of the initial accounts.
+ */
+export function getInitialTestAccountsWallets(pxe: PXE): Promise<AccountWalletWithPrivateKey[]> {
+  return Promise.all(
+    INITIAL_TEST_ENCRYPTION_KEYS.map((encryptionKey, i) =>
+      getSchnorrAccount(pxe, encryptionKey!, INITIAL_TEST_SIGNING_KEYS[i]!, INITIAL_TEST_ACCOUNT_SALTS[i]).getWallet(),
+    ),
+  );
+}
+
+/**
+ * Queries a PXE for it's registered accounts and returns wallets for those accounts using keys in the initial test accounts.
+ * @param pxe - PXE instance.
+ * @returns A set of AccountWallet implementations for each of the initial accounts.
+ */
+export async function getDeployedTestAccountsWallets(pxe: PXE): Promise<AccountWalletWithPrivateKey[]> {
+  const registeredAccounts = await pxe.getRegisteredAccounts();
+  return Promise.all(
+    INITIAL_TEST_ENCRYPTION_KEYS.filter(initialKey => {
+      const publicKey = generatePublicKey(initialKey);
+      return registeredAccounts.find(registered => registered.publicKey.equals(publicKey)) != undefined;
+    }).map((encryptionKey, i) =>
+      getSchnorrAccount(pxe, encryptionKey!, INITIAL_TEST_SIGNING_KEYS[i]!, INITIAL_TEST_ACCOUNT_SALTS[i]).getWallet(),
+    ),
+  );
+}
+
+/**
+ * Deploys the initial set of schnorr signature accounts to the test environment
+ * @param pxe - PXE instance.
+ * @returns The set of deployed Account objects and associated private encryption keys
+ */
+export async function deployInitialTestAccounts(pxe: PXE) {
+  const accounts = INITIAL_TEST_ENCRYPTION_KEYS.map((privateKey, i) => {
+    const account = getSchnorrAccount(pxe, privateKey, INITIAL_TEST_SIGNING_KEYS[i], INITIAL_TEST_ACCOUNT_SALTS[i]);
+    return {
+      account,
+      privateKey,
+    };
+  });
+  // Attempt to get as much parallelism as possible
+  const deployMethods = await Promise.all(
+    accounts.map(async x => {
+      const deployMethod = await x.account.getDeployMethod();
+      await deployMethod.create({
+        contractAddressSalt: x.account.salt,
+        skipClassRegistration: true,
+        skipPublicDeployment: true,
+      });
+      await deployMethod.simulate({});
+      return deployMethod;
+    }),
+  );
+  // Send tx together to try and get them in the same rollup
+  const sentTxs = deployMethods.map(dm => {
+    return dm.send();
+  });
+  await Promise.all(
+    sentTxs.map(async (tx, i) => {
+      const wallet = await accounts[i].account.getWallet();
+      return tx.wait({ wallet });
+    }),
+  );
+  return accounts;
+}

package/src/testing/create_account.ts

@@ -0,0 +1,45 @@
+import { AccountWalletWithPrivateKey } from '@aztec/aztec.js/wallet';
+import { PXE } from '@aztec/circuit-types';
+import { GrumpkinScalar } from '@aztec/circuits.js';
+
+import { getSchnorrAccount } from '../schnorr/index.js';
+
+/**
+ * Deploys and registers a new account using random private keys and returns the associated Schnorr account wallet. Useful for testing.
+ * @param pxe - PXE.
+ * @returns - A wallet for a fresh account.
+ */
+export function createAccount(pxe: PXE): Promise<AccountWalletWithPrivateKey> {
+  return getSchnorrAccount(pxe, GrumpkinScalar.random(), GrumpkinScalar.random()).waitDeploy();
+}
+
+/**
+ * Creates a given number of random accounts using the Schnorr account wallet.
+ * @param pxe - PXE.
+ * @param numberOfAccounts - How many accounts to create.
+ * @returns The created account wallets.
+ */
+export async function createAccounts(pxe: PXE, numberOfAccounts = 1): Promise<AccountWalletWithPrivateKey[]> {
+  const accounts = [];
+
+  // Prepare deployments
+  for (let i = 0; i < numberOfAccounts; ++i) {
+    const account = getSchnorrAccount(pxe, GrumpkinScalar.random(), GrumpkinScalar.random());
+    // Unfortunately the function below is not stateless and we call it here because it takes a long time to run and
+    // the results get stored within the account object. By calling it here we increase the probability of all the
+    // accounts being deployed in the same block because it makes the deploy() method basically instant.
+    await account.getDeployMethod().then(d =>
+      d.simulate({
+        contractAddressSalt: account.salt,
+        skipClassRegistration: true,
+        skipPublicDeployment: true,
+      }),
+    );
+    accounts.push(account);
+  }
+
+  // Send them and await them to be mined
+  const txs = await Promise.all(accounts.map(account => account.deploy()));
+  await Promise.all(txs.map(tx => tx.wait({ interval: 0.1 })));
+  return Promise.all(accounts.map(account => account.getWallet()));
+}

package/src/testing/index.ts

@@ -0,0 +1,11 @@
+/**
+ * The `@aztec/accounts/testing` export provides utility methods for testing, in particular in a Sandbox environment.
+ *
+ * Use the {@link createAccount} and {@link createAccounts} methods to create new sample accounts for testing,
+ * or use {@link getInitialTestAccountsWallets} to obtain a list of wallets for the Sandbox pre-seeded accounts.
+ *
+ * @packageDocumentation
+ */
+
+export * from './create_account.js';
+export * from './configuration.js';

package/dest/defaults/account_entrypoint.d.ts

@@ -1,17 +0,0 @@
-import { AuthWitnessProvider, EntrypointInterface } from '@aztec/aztec.js/account';
-import { FunctionCall, TxExecutionRequest } from '@aztec/circuit-types';
-import { AztecAddress } from '@aztec/circuits.js';
-/**
- * Implementation for an entrypoint interface that follows the default entrypoint signature
- * for an account, which accepts an EntrypointPayload as defined in noir-libs/aztec-noir/src/entrypoint.nr.
- */
-export declare class DefaultAccountEntrypoint implements EntrypointInterface {
-    private address;
-    private auth;
-    private chainId;
-    private version;
-    constructor(address: AztecAddress, auth: AuthWitnessProvider, chainId?: number, version?: number);
-    createTxExecutionRequest(executions: FunctionCall[]): Promise<TxExecutionRequest>;
-    private getEntrypointAbi;
-}
-//# sourceMappingURL=account_entrypoint.d.ts.map

package/dest/defaults/account_entrypoint.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"account_entrypoint.d.ts","sourceRoot":"","sources":["../../src/defaults/account_entrypoint.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,mBAAmB,EAAE,mBAAmB,EAAE,MAAM,yBAAyB,CAAC;AACnF,OAAO,EAAE,YAAY,EAAmB,kBAAkB,EAAE,MAAM,sBAAsB,CAAC;AACzF,OAAO,EAAE,YAAY,EAA+B,MAAM,oBAAoB,CAAC;AAM/E;;;GAGG;AACH,qBAAa,wBAAyB,YAAW,mBAAmB;IAEhE,OAAO,CAAC,OAAO;IACf,OAAO,CAAC,IAAI;IACZ,OAAO,CAAC,OAAO;IACf,OAAO,CAAC,OAAO;gBAHP,OAAO,EAAE,YAAY,EACrB,IAAI,EAAE,mBAAmB,EACzB,OAAO,GAAE,MAAyB,EAClC,OAAO,GAAE,MAAwB;IAGrC,wBAAwB,CAAC,UAAU,EAAE,YAAY,EAAE,GAAG,OAAO,CAAC,kBAAkB,CAAC;IAkBvF,OAAO,CAAC,gBAAgB;CAmFzB"}

package/dest/defaults/account_entrypoint.js

@@ -1,117 +0,0 @@
-import { PackedArguments, TxExecutionRequest } from '@aztec/circuit-types';
-import { Fr, FunctionData, TxContext } from '@aztec/circuits.js';
-import { encodeArguments } from '@aztec/foundation/abi';
-import { DEFAULT_CHAIN_ID, DEFAULT_VERSION } from './constants.js';
-import { buildPayload, hashPayload } from './entrypoint_payload.js';
-/**
- * Implementation for an entrypoint interface that follows the default entrypoint signature
- * for an account, which accepts an EntrypointPayload as defined in noir-libs/aztec-noir/src/entrypoint.nr.
- */
-export class DefaultAccountEntrypoint {
-    constructor(address, auth, chainId = DEFAULT_CHAIN_ID, version = DEFAULT_VERSION) {
-        this.address = address;
-        this.auth = auth;
-        this.chainId = chainId;
-        this.version = version;
-    }
-    async createTxExecutionRequest(executions) {
-        const { payload, packedArguments: callsPackedArguments } = buildPayload(executions);
-        const abi = this.getEntrypointAbi();
-        const packedArgs = PackedArguments.fromArgs(encodeArguments(abi, [payload]));
-        const message = Fr.fromBuffer(hashPayload(payload));
-        const authWitness = await this.auth.createAuthWitness(message);
-        const txRequest = TxExecutionRequest.from({
-            argsHash: packedArgs.hash,
-            origin: this.address,
-            functionData: FunctionData.fromAbi(abi),
-            txContext: TxContext.empty(this.chainId, this.version),
-            packedArguments: [...callsPackedArguments, packedArgs],
-            authWitnesses: [authWitness],
-        });
-        return txRequest;
-    }
-    getEntrypointAbi() {
-        return {
-            name: 'entrypoint',
-            functionType: 'secret',
-            isInternal: false,
-            parameters: [
-                {
-                    name: 'payload',
-                    type: {
-                        kind: 'struct',
-                        path: 'authwit::entrypoint::EntrypointPayload',
-                        fields: [
-                            {
-                                name: 'function_calls',
-                                type: {
-                                    kind: 'array',
-                                    length: 4,
-                                    type: {
-                                        kind: 'struct',
-                                        path: 'authwit::entrypoint::FunctionCall',
-                                        fields: [
-                                            {
-                                                name: 'args_hash',
-                                                type: {
-                                                    kind: 'field',
-                                                },
-                                            },
-                                            {
-                                                name: 'function_selector',
-                                                type: {
-                                                    kind: 'struct',
-                                                    path: 'aztec::protocol_types::abis::function_selector::FunctionSelector',
-                                                    fields: [
-                                                        {
-                                                            name: 'inner',
-                                                            type: {
-                                                                kind: 'integer',
-                                                                sign: 'unsigned',
-                                                                width: 32,
-                                                            },
-                                                        },
-                                                    ],
-                                                },
-                                            },
-                                            {
-                                                name: 'target_address',
-                                                type: {
-                                                    kind: 'struct',
-                                                    path: 'aztec::protocol_types::address::AztecAddress',
-                                                    fields: [
-                                                        {
-                                                            name: 'inner',
-                                                            type: {
-                                                                kind: 'field',
-                                                            },
-                                                        },
-                                                    ],
-                                                },
-                                            },
-                                            {
-                                                name: 'is_public',
-                                                type: {
-                                                    kind: 'boolean',
-                                                },
-                                            },
-                                        ],
-                                    },
-                                },
-                            },
-                            {
-                                name: 'nonce',
-                                type: {
-                                    kind: 'field',
-                                },
-                            },
-                        ],
-                    },
-                    visibility: 'public',
-                },
-            ],
-            returnTypes: [],
-        };
-    }
-}
-//# sourceMappingURL=data:application/json;base64,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