@aztec/simulator 0.58.0 → 0.60.0

package/src/avm/journal/nullifiers.ts

@@ -37,17 +37,17 @@ export class NullifierManager {
   /**
    * Get a nullifier's existence in this' cache or parent's (recursively).
    * DOES NOT CHECK HOST STORAGE!
-   * @param storageAddress - the address of the contract whose storage is being read from
+   * @param contractAddress - the address of the contract whose storage is being read from
    * @param nullifier - the nullifier to check for
    * @returns exists: whether the nullifier exists in cache here or in parent's
    */
-  private checkExistsHereOrParent(storageAddress: Fr, nullifier: Fr): boolean {
+  private checkExistsHereOrParent(contractAddress: Fr, nullifier: Fr): boolean {
     // First check this cache
-    let existsAsPending = this.cache.exists(storageAddress, nullifier);
+    let existsAsPending = this.cache.exists(contractAddress, nullifier);
     // Then try parent's nullifier cache
     if (!existsAsPending && this.parent) {
       // Note: this will recurse to grandparent/etc until a cache-hit is encountered.
-      existsAsPending = this.parent.checkExistsHereOrParent(storageAddress, nullifier);
+      existsAsPending = this.parent.checkExistsHereOrParent(contractAddress, nullifier);
     }
     return existsAsPending;
   }
@@ -59,24 +59,24 @@ export class NullifierManager {
    * 3. Fall back to the host state.
    * 4. Not found! Nullifier does not exist.
    *
-   * @param storageAddress - the address of the contract whose storage is being read from
+   * @param contractAddress - the address of the contract whose storage is being read from
    * @param nullifier - the nullifier to check for
    * @returns exists: whether the nullifier exists at all,
    *          isPending: whether the nullifier was found in a cache,
    *          leafIndex: the nullifier's leaf index if it exists and is not pending (comes from host state).
    */
   public async checkExists(
-    storageAddress: Fr,
+    contractAddress: Fr,
     nullifier: Fr,
   ): Promise<[/*exists=*/ boolean, /*isPending=*/ boolean, /*leafIndex=*/ Fr]> {
     // Check this cache and parent's (recursively)
-    const existsAsPending = this.checkExistsHereOrParent(storageAddress, nullifier);
+    const existsAsPending = this.checkExistsHereOrParent(contractAddress, nullifier);
     // Finally try the host's Aztec state (a trip to the database)
     // If the value is found in the database, it will be associated with a leaf index!
     let leafIndex: bigint | undefined = undefined;
     if (!existsAsPending) {
       // silo the nullifier before checking for its existence in the host
-      leafIndex = await this.hostNullifiers.getNullifierIndex(siloNullifier(storageAddress, nullifier));
+      leafIndex = await this.hostNullifiers.getNullifierIndex(siloNullifier(contractAddress, nullifier));
     }
     const exists = existsAsPending || leafIndex !== undefined;
     leafIndex = leafIndex === undefined ? BigInt(0) : leafIndex;
@@ -86,17 +86,17 @@ export class NullifierManager {
   /**
    * Stage a new nullifier (append it to the cache).
    *
-   * @param storageAddress - the address of the contract that the nullifier is associated with
+   * @param contractAddress - the address of the contract that the nullifier is associated with
    * @param nullifier - the nullifier to stage
    */
-  public async append(storageAddress: Fr, nullifier: Fr) {
-    const [exists, ,] = await this.checkExists(storageAddress, nullifier);
+  public async append(contractAddress: Fr, nullifier: Fr) {
+    const [exists, ,] = await this.checkExists(contractAddress, nullifier);
     if (exists) {
       throw new NullifierCollisionError(
-        `Nullifier ${nullifier} at contract ${storageAddress} already exists in parent cache or host.`,
+        `Nullifier ${nullifier} at contract ${contractAddress} already exists in parent cache or host.`,
       );
     }
-    this.cache.append(storageAddress, nullifier);
+    this.cache.append(contractAddress, nullifier);
   }
 
   /**
@@ -135,35 +135,35 @@ export class NullifierCache {
   /**
    * Check whether a nullifier exists in the cache.
    *
-   * @param storageAddress - the address of the contract that the nullifier is associated with
+   * @param contractAddress - the address of the contract that the nullifier is associated with
    * @param nullifier - the nullifier to check existence of
    * @returns whether the nullifier is found in the cache
    */
-  public exists(storageAddress: Fr, nullifier: Fr): boolean {
+  public exists(contractAddress: Fr, nullifier: Fr): boolean {
     const exists =
-      this.cachePerContract.get(storageAddress.toBigInt())?.has(nullifier.toBigInt()) ||
-      this.siloedNullifiers.has(siloNullifier(AztecAddress.fromField(storageAddress), nullifier).toBigInt());
+      this.cachePerContract.get(contractAddress.toBigInt())?.has(nullifier.toBigInt()) ||
+      this.siloedNullifiers.has(siloNullifier(AztecAddress.fromField(contractAddress), nullifier).toBigInt());
     return !!exists;
   }
 
   /**
    * Stage a new nullifier (append it to the cache).
    *
-   * @param storageAddress - the address of the contract that the nullifier is associated with
+   * @param contractAddress - the address of the contract that the nullifier is associated with
    * @param nullifier - the nullifier to stage
    */
-  public append(storageAddress: Fr, nullifier: Fr) {
-    if (this.exists(storageAddress, nullifier)) {
+  public append(contractAddress: Fr, nullifier: Fr) {
+    if (this.exists(contractAddress, nullifier)) {
       throw new NullifierCollisionError(
-        `Nullifier ${nullifier} at contract ${storageAddress} already exists in cache.`,
+        `Nullifier ${nullifier} at contract ${contractAddress} already exists in cache.`,
       );
     }
 
-    let nullifiersForContract = this.cachePerContract.get(storageAddress.toBigInt());
+    let nullifiersForContract = this.cachePerContract.get(contractAddress.toBigInt());
     // If this contract's nullifier set has no cached nullifiers, create a new Set to store them
     if (!nullifiersForContract) {
       nullifiersForContract = new Set();
-      this.cachePerContract.set(storageAddress.toBigInt(), nullifiersForContract);
+      this.cachePerContract.set(contractAddress.toBigInt(), nullifiersForContract);
     }
     nullifiersForContract.add(nullifier.toBigInt());
   }

package/src/avm/journal/public_storage.ts

@@ -45,17 +45,17 @@ export class PublicStorage {
    * Read a storage value from this' cache or parent's (recursively).
    * DOES NOT CHECK HOST STORAGE!
    *
-   * @param storageAddress - the address of the contract whose storage is being read from
+   * @param contractAddress - the address of the contract whose storage is being read from
    * @param slot - the slot in the contract's storage being read from
    * @returns value: the latest value written according to this cache or the parent's. undefined on cache miss.
    */
-  public readHereOrParent(storageAddress: Fr, slot: Fr): Fr | undefined {
+  public readHereOrParent(contractAddress: Fr, slot: Fr): Fr | undefined {
     // First try check this storage cache
-    let value = this.cache.read(storageAddress, slot);
+    let value = this.cache.read(contractAddress, slot);
     // Then try parent's storage cache
     if (!value && this.parent) {
       // Note: this will recurse to grandparent/etc until a cache-hit is encountered.
-      value = this.parent.readHereOrParent(storageAddress, slot);
+      value = this.parent.readHereOrParent(contractAddress, slot);
     }
     return value;
   }
@@ -67,17 +67,17 @@ export class PublicStorage {
    * 3. Fall back to the host state.
    * 4. Not found! Value has never been written to before. Flag it as non-existent and return value zero.
    *
-   * @param storageAddress - the address of the contract whose storage is being read from
+   * @param contractAddress - the address of the contract whose storage is being read from
    * @param slot - the slot in the contract's storage being read from
    * @returns exists: whether the slot has EVER been written to before, value: the latest value written to slot, or 0 if never written to before
    */
-  public async read(storageAddress: Fr, slot: Fr): Promise<PublicStorageReadResult> {
+  public async read(contractAddress: Fr, slot: Fr): Promise<PublicStorageReadResult> {
     let cached = false;
     // Check this cache and parent's (recursively)
-    let value = this.readHereOrParent(storageAddress, slot);
+    let value = this.readHereOrParent(contractAddress, slot);
     // Finally try the host's Aztec state (a trip to the database)
     if (!value) {
-      value = await this.hostPublicStorage.storageRead(storageAddress, slot);
+      value = await this.hostPublicStorage.storageRead(contractAddress, slot);
       // TODO(dbanks12): if value retrieved from host storage, we can cache it here
       // any future reads to the same slot can read from cache instead of more expensive
       // DB access
@@ -93,12 +93,12 @@ export class PublicStorage {
   /**
    * Stage a storage write.
    *
-   * @param storageAddress - the address of the contract whose storage is being written to
+   * @param contractAddress - the address of the contract whose storage is being written to
    * @param slot - the slot in the contract's storage being written to
    * @param value - the value being written to the slot
    */
-  public write(storageAddress: Fr, slot: Fr, value: Fr) {
-    this.cache.write(storageAddress, slot, value);
+  public write(contractAddress: Fr, slot: Fr, value: Fr) {
+    this.cache.write(contractAddress, slot, value);
   }
 
   /**
@@ -114,9 +114,9 @@ export class PublicStorage {
    * Commits ALL staged writes to the host's state.
    */
   public async commitToDB() {
-    for (const [storageAddress, cacheAtContract] of this.cache.cachePerContract) {
+    for (const [contractAddress, cacheAtContract] of this.cache.cachePerContract) {
       for (const [slot, value] of cacheAtContract) {
-        await this.hostPublicStorage.storageWrite(AztecAddress.fromBigInt(storageAddress), new Fr(slot), value);
+        await this.hostPublicStorage.storageWrite(AztecAddress.fromBigInt(contractAddress), new Fr(slot), value);
       }
     }
   }
@@ -139,27 +139,27 @@ class PublicStorageCache {
   /**
    * Read a staged value from storage, if it has been previously written to.
    *
-   * @param storageAddress - the address of the contract whose storage is being read from
+   * @param contractAddress - the address of the contract whose storage is being read from
    * @param slot - the slot in the contract's storage being read from
    * @returns the latest value written to slot, or undefined if no value has been written
    */
-  public read(storageAddress: Fr, slot: Fr): Fr | undefined {
-    return this.cachePerContract.get(storageAddress.toBigInt())?.get(slot.toBigInt());
+  public read(contractAddress: Fr, slot: Fr): Fr | undefined {
+    return this.cachePerContract.get(contractAddress.toBigInt())?.get(slot.toBigInt());
   }
 
   /**
    * Stage a storage write.
    *
-   * @param storageAddress - the address of the contract whose storage is being written to
+   * @param contractAddress - the address of the contract whose storage is being written to
    * @param slot - the slot in the contract's storage being written to
    * @param value - the value being written to the slot
    */
-  public write(storageAddress: Fr, slot: Fr, value: Fr) {
-    let cacheAtContract = this.cachePerContract.get(storageAddress.toBigInt());
+  public write(contractAddress: Fr, slot: Fr, value: Fr) {
+    let cacheAtContract = this.cachePerContract.get(contractAddress.toBigInt());
     if (!cacheAtContract) {
       // If this contract's storage has no staged modifications, create a new inner map to store them
       cacheAtContract = new Map();
-      this.cachePerContract.set(storageAddress.toBigInt(), cacheAtContract);
+      this.cachePerContract.set(contractAddress.toBigInt(), cacheAtContract);
     }
     cacheAtContract.set(slot.toBigInt(), value);
   }

package/src/avm/opcodes/accrued_substate.ts

@@ -39,11 +39,7 @@ export class NoteHashExists extends Instruction {
     const noteHash = memory.get(noteHashOffset).toFr();
     const leafIndex = memory.get(leafIndexOffset).toFr();
 
-    const exists = await context.persistableState.checkNoteHashExists(
-      context.environment.storageAddress,
-      noteHash,
-      leafIndex,
-    );
+    const exists = await context.persistableState.checkNoteHashExists(context.environment.address, noteHash, leafIndex);
     memory.set(existsOffset, exists ? new Uint1(1) : new Uint1(0));
 
     memory.assert({ reads: 2, writes: 1, addressing });
@@ -75,7 +71,7 @@ export class EmitNoteHash extends Instruction {
     }
 
     const noteHash = memory.get(noteHashOffset).toFr();
-    context.persistableState.writeNoteHash(context.environment.storageAddress, noteHash);
+    context.persistableState.writeNoteHash(context.environment.address, noteHash);
 
     memory.assert({ reads: 1, addressing });
     context.machineState.incrementPc();
@@ -148,12 +144,12 @@ export class EmitNullifier extends Instruction {
 
     const nullifier = memory.get(nullifierOffset).toFr();
     try {
-      await context.persistableState.writeNullifier(context.environment.storageAddress, nullifier);
+      await context.persistableState.writeNullifier(context.environment.address, nullifier);
     } catch (e) {
       if (e instanceof NullifierCollisionError) {
         // Error is known/expected, raise as InstructionExecutionError that the will lead the simulator to revert this call
         throw new InstructionExecutionError(
-          `Attempted to emit duplicate nullifier ${nullifier} (storage address: ${context.environment.storageAddress}).`,
+          `Attempted to emit duplicate nullifier ${nullifier} (contract address: ${context.environment.address}).`,
         );
       } else {
         throw e;

package/src/avm/opcodes/environment_getters.ts

@@ -6,7 +6,6 @@ import { Instruction } from './instruction.js';
 
 export enum EnvironmentVariable {
   ADDRESS,
-  STORAGEADDRESS,
   SENDER,
   FUNCTIONSELECTOR,
   TRANSACTIONFEE,
@@ -25,8 +24,6 @@ function getValue(e: EnvironmentVariable, ctx: AvmContext) {
   switch (e) {
     case EnvironmentVariable.ADDRESS:
       return new Field(ctx.environment.address.toField());
-    case EnvironmentVariable.STORAGEADDRESS:
-      return new Field(ctx.environment.storageAddress.toField());
     case EnvironmentVariable.SENDER:
       return new Field(ctx.environment.sender.toField());
     case EnvironmentVariable.FUNCTIONSELECTOR:

package/src/avm/opcodes/hashing.ts

@@ -1,15 +1,7 @@
-import {
-  keccak256,
-  keccakf1600,
-  pedersenHash,
-  poseidon2Permutation,
-  sha256Compression,
-} from '@aztec/foundation/crypto';
-
-import { strict as assert } from 'assert';
+import { keccakf1600, poseidon2Permutation, sha256Compression } from '@aztec/foundation/crypto';
 
 import { type AvmContext } from '../avm_context.js';
-import { Field, TypeTag, Uint8, Uint32, Uint64 } from '../avm_memory_types.js';
+import { Field, TypeTag, Uint32, Uint64 } from '../avm_memory_types.js';
 import { Opcode, OperandType } from '../serialization/instruction_serialization.js';
 import { Addressing } from './addressing_mode.js';
 import { Instruction } from './instruction.js';
@@ -52,52 +44,6 @@ export class Poseidon2 extends Instruction {
   }
 }
 
-export class Keccak extends Instruction {
-  static type: string = 'KECCAK';
-  static readonly opcode: Opcode = Opcode.KECCAK;
-
-  // Informs (de)serialization. See Instruction.deserialize.
-  static readonly wireFormat: OperandType[] = [
-    OperandType.UINT8,
-    OperandType.UINT8,
-    OperandType.UINT32,
-    OperandType.UINT32,
-    OperandType.UINT32,
-  ];
-
-  constructor(
-    private indirect: number,
-    private dstOffset: number,
-    private messageOffset: number,
-    private messageSizeOffset: number,
-  ) {
-    super();
-  }
-
-  // pub fn keccak256(input: [u8], message_size: u32) -> [u8; 32]
-  public async execute(context: AvmContext): Promise<void> {
-    const memory = context.machineState.memory.track(this.type);
-    const operands = [this.dstOffset, this.messageOffset, this.messageSizeOffset];
-    const addressing = Addressing.fromWire(this.indirect, operands.length);
-    const [dstOffset, messageOffset, messageSizeOffset] = addressing.resolve(operands, memory);
-    memory.checkTag(TypeTag.UINT32, messageSizeOffset);
-    const messageSize = memory.get(messageSizeOffset).toNumber();
-    context.machineState.consumeGas(this.gasCost(messageSize));
-
-    memory.checkTagsRange(TypeTag.UINT8, messageOffset, messageSize);
-
-    const messageData = Buffer.concat(memory.getSlice(messageOffset, messageSize).map(word => word.toBuffer()));
-    const hashBuffer = keccak256(messageData);
-
-    // We need to convert the hashBuffer because map doesn't work as expected on an Uint8Array (Buffer).
-    const res = [...hashBuffer].map(byte => new Uint8(byte));
-    memory.setSlice(dstOffset, res);
-
-    memory.assert({ reads: messageSize + 1, writes: 32, addressing });
-    context.machineState.incrementPc();
-  }
-}
-
 export class KeccakF1600 extends Instruction {
   static type: string = 'KECCAKF1600';
   static readonly opcode: Opcode = Opcode.KECCAKF1600;
@@ -108,39 +54,30 @@ export class KeccakF1600 extends Instruction {
     OperandType.UINT8,
     OperandType.UINT16,
     OperandType.UINT16,
-    OperandType.UINT16,
   ];
 
-  constructor(
-    private indirect: number,
-    private dstOffset: number,
-    private stateOffset: number,
-    // This is here for compatibility with the CPP side. Should be removed in both.
-    private stateSizeOffset: number,
-  ) {
+  constructor(private indirect: number, private dstOffset: number, private inputOffset: number) {
     super();
   }
 
   // pub fn keccakf1600(input: [u64; 25]) -> [u64; 25]
   public async execute(context: AvmContext): Promise<void> {
+    const inputSize = 25;
     const memory = context.machineState.memory.track(this.type);
-    const operands = [this.dstOffset, this.stateOffset, this.stateSizeOffset];
+    const operands = [this.dstOffset, this.inputOffset];
     const addressing = Addressing.fromWire(this.indirect, operands.length);
-    const [dstOffset, stateOffset, stateSizeOffset] = addressing.resolve(operands, memory);
-    memory.checkTag(TypeTag.UINT32, stateSizeOffset);
-    const stateSize = memory.get(stateSizeOffset).toNumber();
-    assert(stateSize === 25, 'Invalid state size for keccakf1600');
+    const [dstOffset, inputOffset] = addressing.resolve(operands, memory);
     context.machineState.consumeGas(this.gasCost());
 
-    memory.checkTagsRange(TypeTag.UINT64, stateOffset, stateSize);
+    memory.checkTagsRange(TypeTag.UINT64, inputOffset, inputSize);
 
-    const stateData = memory.getSlice(stateOffset, stateSize).map(word => word.toBigInt());
+    const stateData = memory.getSlice(inputOffset, inputSize).map(word => word.toBigInt());
     const updatedState = keccakf1600(stateData);
 
     const res = updatedState.map(word => new Uint64(word));
     memory.setSlice(dstOffset, res);
 
-    memory.assert({ reads: stateSize + 1, writes: 25, addressing });
+    memory.assert({ reads: inputSize, writes: inputSize, addressing });
     context.machineState.incrementPc();
   }
 }
@@ -193,53 +130,3 @@ export class Sha256Compression extends Instruction {
     context.machineState.incrementPc();
   }
 }
-
-export class Pedersen extends Instruction {
-  static type: string = 'PEDERSEN';
-  static readonly opcode: Opcode = Opcode.PEDERSEN;
-
-  // Informs (de)serialization. See Instruction.deserialize.
-  static readonly wireFormat: OperandType[] = [
-    OperandType.UINT8,
-    OperandType.UINT8,
-    OperandType.UINT32,
-    OperandType.UINT32,
-    OperandType.UINT32,
-    OperandType.UINT32,
-  ];
-
-  constructor(
-    private indirect: number,
-    private genIndexOffset: number,
-    private dstOffset: number,
-    private messageOffset: number,
-    private messageSizeOffset: number,
-  ) {
-    super();
-  }
-
-  public async execute(context: AvmContext): Promise<void> {
-    const memory = context.machineState.memory.track(this.type);
-    const operands = [this.genIndexOffset, this.dstOffset, this.messageOffset, this.messageSizeOffset];
-    const addressing = Addressing.fromWire(this.indirect, operands.length);
-    const [genIndexOffset, dstOffset, messageOffset, messageSizeOffset] = addressing.resolve(operands, memory);
-
-    // We hash a set of field elements
-    const genIndex = Number(memory.get(genIndexOffset).toBigInt());
-    memory.checkTag(TypeTag.UINT32, genIndexOffset);
-    const messageSize = Number(memory.get(messageSizeOffset).toBigInt());
-    memory.checkTag(TypeTag.UINT32, messageSizeOffset);
-    const hashData = memory.getSlice(messageOffset, messageSize);
-
-    context.machineState.consumeGas(this.gasCost(messageSize));
-
-    memory.checkTagsRange(TypeTag.FIELD, messageOffset, messageSize);
-
-    // No domain sep for now
-    const hash = pedersenHash(hashData, genIndex);
-    memory.set(dstOffset, new Field(hash));
-
-    memory.assert({ reads: messageSize + 2, writes: 1, addressing });
-    context.machineState.incrementPc();
-  }
-}

package/src/avm/opcodes/index.ts

@@ -13,4 +13,3 @@ export * from './environment_getters.js';
 export * from './accrued_substate.js';
 export * from './hashing.js';
 export * from './ec_add.js';
-export * from './commitment.js';

package/src/avm/opcodes/storage.ts

@@ -43,7 +43,7 @@ export class SStore extends BaseStorageInstruction {
 
     const slot = memory.get(slotOffset).toFr();
     const value = memory.get(srcOffset).toFr();
-    context.persistableState.writeStorage(context.environment.storageAddress, slot, value);
+    context.persistableState.writeStorage(context.environment.address, slot, value);
 
     memory.assert({ reads: 2, addressing });
     context.machineState.incrementPc();
@@ -68,7 +68,7 @@ export class SLoad extends BaseStorageInstruction {
     memory.checkTag(TypeTag.FIELD, slotOffset);
 
     const slot = memory.get(slotOffset).toFr();
-    const value = await context.persistableState.readStorage(context.environment.storageAddress, slot);
+    const value = await context.persistableState.readStorage(context.environment.address, slot);
     memory.set(dstOffset, new Field(value));
 
     context.machineState.incrementPc();

package/src/avm/serialization/bytecode_serialization.ts

@@ -19,7 +19,6 @@ import {
   InternalReturn,
   Jump,
   JumpI,
-  Keccak,
   KeccakF1600,
   L1ToL2MessageExists,
   Lt,
@@ -30,8 +29,6 @@ import {
   NoteHashExists,
   NullifierExists,
   Or,
-  Pedersen,
-  PedersenCommitment,
   Poseidon2,
   Return,
   Revert,
@@ -131,7 +128,6 @@ const INSTRUCTION_SET = () =>
     // Control Flow - Contract Calls
     [Call.opcode, Instruction.deserialize.bind(Call)],
     [StaticCall.opcode, Instruction.deserialize.bind(StaticCall)],
-    //[DelegateCall.opcode, Instruction.deserialize.bind(DelegateCall)],
     [Return.opcode, Instruction.deserialize.bind(Return)],
     [Opcode.REVERT_8, Revert.as(Revert.wireFormat8).deserialize],
     [Opcode.REVERT_16, Revert.as(Revert.wireFormat16).deserialize],
@@ -141,12 +137,9 @@ const INSTRUCTION_SET = () =>
 
     // Gadgets
     [EcAdd.opcode, Instruction.deserialize.bind(EcAdd)],
-    [Keccak.opcode, Instruction.deserialize.bind(Keccak)],
     [Poseidon2.opcode, Instruction.deserialize.bind(Poseidon2)],
     [Sha256Compression.opcode, Instruction.deserialize.bind(Sha256Compression)],
-    [Pedersen.opcode, Instruction.deserialize.bind(Pedersen)],
     [MultiScalarMul.opcode, Instruction.deserialize.bind(MultiScalarMul)],
-    [PedersenCommitment.opcode, Instruction.deserialize.bind(PedersenCommitment)],
     // Conversions
     [ToRadixLE.opcode, Instruction.deserialize.bind(ToRadixLE)],
     // Future Gadgets -- pending changes in noir

package/src/avm/serialization/instruction_serialization.ts

@@ -69,21 +69,17 @@ export enum Opcode {
   // External calls
   CALL,
   STATICCALL,
-  DELEGATECALL,
   RETURN,
   REVERT_8,
   REVERT_16,
   // Misc
   DEBUGLOG,
   // Gadgets
-  KECCAK,
   POSEIDON2,
   SHA256COMPRESSION,
   KECCAKF1600,
-  PEDERSEN, // temp - may be removed, but alot of contracts rely on it
   ECADD,
   MSM,
-  PEDERSENCOMMITMENT,
   // Conversion
   TORADIXLE,
 }