@aztec/aztec.js 0.1.0-alpha24 → 0.1.0-alpha26

package/src/abis/schnorr_single_key_account_contract.json

@@ -0,0 +1,96 @@
+{
+  "name": "SchnorrSingleKeyAccount",
+  "functions": [
+    {
+      "name": "constructor",
+      "functionType": "secret",
+      "parameters": [],
+      "returnTypes": []
+    },
+    {
+      "name": "entrypoint",
+      "functionType": "secret",
+      "parameters": [
+        {
+          "name": "payload",
+          "type": {
+            "kind": "struct",
+            "fields": [
+              {
+                "name": "flattened_args_hashes",
+                "type": {
+                  "kind": "array",
+                  "length": 2,
+                  "type": {
+                    "kind": "field"
+                  }
+                }
+              },
+              {
+                "name": "flattened_selectors",
+                "type": {
+                  "kind": "array",
+                  "length": 2,
+                  "type": {
+                    "kind": "field"
+                  }
+                }
+              },
+              {
+                "name": "flattened_targets",
+                "type": {
+                  "kind": "array",
+                  "length": 2,
+                  "type": {
+                    "kind": "field"
+                  }
+                }
+              },
+              {
+                "name": "nonce",
+                "type": {
+                  "kind": "field"
+                }
+              }
+            ]
+          },
+          "visibility": "public"
+        },
+        {
+          "name": "owner",
+          "type": {
+            "kind": "array",
+            "length": 64,
+            "type": {
+              "kind": "integer",
+              "sign": "unsigned",
+              "width": 8
+            }
+          },
+          "visibility": "public"
+        },
+        {
+          "name": "signature",
+          "type": {
+            "kind": "array",
+            "length": 64,
+            "type": {
+              "kind": "integer",
+              "sign": "unsigned",
+              "width": 8
+            }
+          },
+          "visibility": "public"
+        },
+        {
+          "name": "partial_address",
+          "type": {
+            "kind": "field"
+          },
+          "visibility": "public"
+        }
+      ],
+      "returnTypes": []
+    }
+  ]
+}

package/src/account_impl/single_key_account_contract.ts

@@ -2,13 +2,14 @@ import { AztecAddress, CircuitsWasm, FunctionData, PartialContractAddress, TxCon
 import { Signer } from '@aztec/circuits.js/barretenberg';
 import { ContractAbi, encodeArguments, generateFunctionSelector } from '@aztec/foundation/abi';
 import { ExecutionRequest, PackedArguments, TxExecutionRequest } from '@aztec/types';
+
 import partition from 'lodash.partition';
+
+import SchnorrSingleKeyAccountContractAbi from '../abis/schnorr_account_contract.json' assert { type: 'json' };
 import { generatePublicKey } from '../index.js';
 import { buildPayload, hashPayload } from './entrypoint_payload.js';
 import { AccountImplementation } from './index.js';
 
-import SchnorrAccountContractAbi from '../abis/schnorr_account_contract.json' assert { type: 'json' };
-
 /**
  * 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
@@ -56,10 +57,10 @@ export class SingleKeyAccountContract implements AccountImplementation {
   }
 
   private getEntrypointAbi() {
-    // We use the SchnorrAccountContract because it implements the interface we need, but ideally
+    // 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 = (SchnorrAccountContractAbi as any as ContractAbi).functions.find(f => f.name === 'entrypoint');
+    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_impl/stored_key_account_contract.ts

@@ -1,19 +1,25 @@
 import { AztecAddress, CircuitsWasm, FunctionData, TxContext } from '@aztec/circuits.js';
 import { Signer } from '@aztec/circuits.js/barretenberg';
 import { ContractAbi, encodeArguments, generateFunctionSelector } from '@aztec/foundation/abi';
+import { DebugLogger, createDebugLogger } from '@aztec/foundation/log';
 import { ExecutionRequest, PackedArguments, TxExecutionRequest } from '@aztec/types';
+
 import partition from 'lodash.partition';
-import { buildPayload, hashPayload } from './entrypoint_payload.js';
-import { AccountImplementation } from './index.js';
 
 import EcdsaAccountContractAbi from '../abis/ecdsa_account_contract.json' assert { type: 'json' };
+import { buildPayload, hashPayload } from './entrypoint_payload.js';
+import { AccountImplementation } 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 StoredKeyAccountContract implements AccountImplementation {
-  constructor(private address: AztecAddress, private privateKey: Buffer, private signer: Signer) {}
+  private log: DebugLogger;
+
+  constructor(private address: AztecAddress, private privateKey: Buffer, private signer: Signer) {
+    this.log = createDebugLogger('aztec:client:accounts:stored_key');
+  }
 
   getAddress(): AztecAddress {
     return this.address;
@@ -30,8 +36,9 @@ export class StoredKeyAccountContract implements AccountImplementation {
     const wasm = await CircuitsWasm.get();
     const { payload, packedArguments: callsPackedArguments } = await buildPayload(privateCalls, publicCalls);
     const hash = hashPayload(payload);
-
     const signature = this.signer.constructSignature(hash, this.privateKey).toBuffer();
+    this.log(`Signed challenge ${hash.toString('hex')} as ${signature.toString('hex')}`);
+
     const args = [payload, signature];
     const abi = this.getEntrypointAbi();
     const selector = generateFunctionSelector(abi.name, abi.parameters);

package/src/aztec_rpc_client/aztec_rpc_client.ts

@@ -1,5 +1,5 @@
 import { AztecAddress, EthAddress, Fr, Point } from '@aztec/circuits.js';
-import { createJsonRpcClient } from '@aztec/foundation/json-rpc';
+import { createJsonRpcClient, defaultFetch } from '@aztec/foundation/json-rpc';
 import {
   AztecRPC,
   ContractData,
@@ -8,9 +8,10 @@ import {
   Tx,
   TxExecutionRequest,
   TxHash,
+  TxReceipt,
 } from '@aztec/types';
 
-export const createAztecRpcClient = (url: string): AztecRPC =>
+export const createAztecRpcClient = (url: string, fetch = defaultFetch): AztecRPC =>
   createJsonRpcClient<AztecRPC>(
     url,
     {
@@ -23,6 +24,7 @@ export const createAztecRpcClient = (url: string): AztecRPC =>
       Point,
       Fr,
     },
-    { Tx, ContractDeploymentTx },
+    { Tx, ContractDeploymentTx, TxReceipt },
     false,
+    fetch,
   );

package/src/aztec_rpc_client/wallet.ts

@@ -1,5 +1,4 @@
-import { AztecAddress, Fr, Point, TxContext } from '@aztec/circuits.js';
-import { ContractAbi } from '@aztec/foundation/abi';
+import { AztecAddress, Fr, PartialContractAddress, Point, PublicKey, TxContext } from '@aztec/circuits.js';
 import {
   AztecRPC,
   ContractData,
@@ -31,19 +30,21 @@ export abstract class BaseWallet implements Wallet {
     executions: ExecutionRequest[],
     txContext: TxContext,
   ): Promise<TxExecutionRequest>;
-  addAccount(
-    privKey: Buffer,
+  addAccount(privKey: Buffer, address: AztecAddress, partialContractAddress: Fr): Promise<AztecAddress> {
+    return this.rpc.addAccount(privKey, address, partialContractAddress);
+  }
+  addPublicKeyAndPartialAddress(
     address: AztecAddress,
-    partialContractAddress: Fr,
-    abi?: ContractAbi | undefined,
-  ): Promise<AztecAddress> {
-    return this.rpc.addAccount(privKey, address, partialContractAddress, abi);
+    publicKey: PublicKey,
+    partialAddress: PartialContractAddress,
+  ): Promise<void> {
+    return this.rpc.addPublicKeyAndPartialAddress(address, publicKey, partialAddress);
   }
   getAccounts(): Promise<AztecAddress[]> {
     return this.rpc.getAccounts();
   }
-  getAccountPublicKey(address: AztecAddress): Promise<Point> {
-    return this.rpc.getAccountPublicKey(address);
+  getPublicKey(address: AztecAddress): Promise<Point> {
+    return this.rpc.getPublicKey(address);
   }
   addContracts(contracts: DeployedContract[]): Promise<void> {
     return this.rpc.addContracts(contracts);
@@ -63,6 +64,9 @@ export abstract class BaseWallet implements Wallet {
   getStorageAt(contract: AztecAddress, storageSlot: Fr): Promise<any> {
     return this.rpc.getStorageAt(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);
   }
@@ -81,6 +85,12 @@ export abstract class BaseWallet implements Wallet {
   getNodeInfo(): Promise<NodeInfo> {
     return this.rpc.getNodeInfo();
   }
+  getPublicKeyAndPartialAddress(address: AztecAddress): Promise<[Point, PartialContractAddress]> {
+    return this.rpc.getPublicKeyAndPartialAddress(address);
+  }
+  isAccountSynchronised(account: AztecAddress) {
+    return this.rpc.isAccountSynchronised(account);
+  }
 }
 
 /**

package/src/contract/contract.ts

@@ -10,7 +10,7 @@ import { ContractFunctionInteraction } from './contract_function_interaction.js'
  * Type representing a contract method that returns a ContractFunctionInteraction instance
  * and has a readonly 'selector' property of type Buffer. Takes any number of arguments.
  */
-type ContractMethod = ((...args: any[]) => ContractFunctionInteraction) & {
+export type ContractMethod = ((...args: any[]) => ContractFunctionInteraction) & {
   /**
    * The unique identifier for a contract function in bytecode.
    */
@@ -42,7 +42,7 @@ export class Contract {
     /**
      * The wallet.
      */
-    private wallet: Wallet,
+    protected wallet: Wallet,
   ) {
     abi.functions.forEach((f: FunctionAbi) => {
       const interactionFunction = (...args: any[]) => {

package/src/contract_deployer/contract_deployer.ts

@@ -8,6 +8,7 @@ import { DeployMethod } from './deploy_method.js';
  * A class for deploying contract.
  */
 export class ContractDeployer {
+  // TODO: remove this?
   constructor(private abi: ContractAbi, private arc: AztecRPC, private publicKey?: PublicKey) {}
 
   /**

package/src/contract_deployer/deploy_method.ts

@@ -89,6 +89,8 @@ export class DeployMethod extends ContractFunctionInteraction {
     const portalContract = options.portalContract ?? EthAddress.ZERO;
     const contractAddressSalt = options.contractAddressSalt ?? Fr.random();
 
+    const { chainId, version } = await this.wallet.getNodeInfo();
+
     const { address, constructorHash, functionTreeRoot, partialAddress } = await getContractDeploymentInfo(
       this.abi,
       this.args,
@@ -104,8 +106,6 @@ export class DeployMethod extends ContractFunctionInteraction {
       portalContract,
     );
 
-    const { chainId, version } = await this.wallet.getNodeInfo();
-
     const txContext = new TxContext(false, false, true, contractDeploymentData, new Fr(chainId), new Fr(version));
     const executionRequest = this.getExecutionRequest(address, AztecAddress.ZERO);
     const txRequest = await this.wallet.createAuthenticatedTxRequest([executionRequest], txContext);

package/src/utils/account.ts

@@ -27,7 +27,7 @@ export async function createAccounts(
     const privKey = i == 0 && privateKey ? privateKey : randomBytes(32);
     const publicKey = await generatePublicKey(privKey);
     const deploymentInfo = await getContractDeploymentInfo(accountContractAbi, [], salt, publicKey);
-    await aztecRpcClient.addAccount(privKey, deploymentInfo.address, deploymentInfo.partialAddress, accountContractAbi);
+    await aztecRpcClient.addAccount(privKey, deploymentInfo.address, deploymentInfo.partialAddress);
     const contractDeployer = new ContractDeployer(accountContractAbi, aztecRpcClient, publicKey);
     const tx = contractDeployer.deploy().send({ contractAddressSalt: salt });
     await tx.isMined(0, 0.5);

package/src/utils/l1_contracts.ts

@@ -1,4 +1,5 @@
 import { EthAddress } from '@aztec/circuits.js';
+import { retryUntil } from '@aztec/foundation/retry';
 
 /**
  * A dictionary of the Aztec-deployed L1 contracts.
@@ -16,6 +17,14 @@ export type L1ContractAddresses = {
    * Address of the L1/L2 messaging inbox contract.
    */
   inbox: EthAddress;
+  /**
+   * Address of the L1/L2 messaging outbox contract.
+   */
+  outbox: EthAddress;
+  /**
+   * Address of the decoder helper contract
+   */
+  decoderHelper?: EthAddress;
 
   /**
    * Registry Address.
@@ -32,7 +41,18 @@ type L1ContractAddressesResp = {
 
 export const getL1ContractAddresses = async (url: string): Promise<L1ContractAddresses> => {
   const reqUrl = new URL(`${url}/api/l1-contract-addresses`);
-  const response = (await (await fetch(reqUrl.toString())).json()) as unknown as L1ContractAddressesResp;
+  const response = await retryUntil(
+    async () => {
+      try {
+        return (await (await fetch(reqUrl.toString())).json()) as unknown as L1ContractAddressesResp;
+      } catch (err) {
+        // do nothing
+      }
+    },
+    'isSandboxReady',
+    120,
+    1,
+  );
   const result = Object.fromEntries(
     Object.entries(response).map(([key, value]) => [key, EthAddress.fromString(value)]),
   );