@aztec/stdlib 0.0.0-test.1 → 0.0.1-fake-ceab37513c

package/dest/tx/proposed_block_header.js

@@ -0,0 +1,154 @@
+import { sha256ToField } from '@aztec/foundation/crypto';
+import { EthAddress } from '@aztec/foundation/eth-address';
+import { Fr } from '@aztec/foundation/fields';
+import { BufferReader, bigintToUInt64BE, serializeToBuffer } from '@aztec/foundation/serialize';
+import { bufferToHex, hexToBuffer } from '@aztec/foundation/string';
+import { inspect } from 'util';
+import { z } from 'zod';
+import { AztecAddress } from '../aztec-address/index.js';
+import { GasFees } from '../gas/index.js';
+import { schemas } from '../schemas/index.js';
+import { ContentCommitment } from './content_commitment.js';
+/** The proposed values of an L2 block. */ export class ProposedBlockHeader {
+    lastArchiveRoot;
+    contentCommitment;
+    slotNumber;
+    timestamp;
+    coinbase;
+    feeRecipient;
+    gasFees;
+    totalManaUsed;
+    constructor(/** Root of the archive tree before this block is added. */ lastArchiveRoot, /** Content commitment of the L2 block. */ contentCommitment, /** Slot number of the L2 block */ slotNumber, /** Timestamp of the L2 block. */ timestamp, /** Recipient of block reward. */ coinbase, /** Address to receive fees. */ feeRecipient, /** Global gas prices for this block. */ gasFees, /** Total mana used in the block, computed by the root rollup circuit */ totalManaUsed){
+        this.lastArchiveRoot = lastArchiveRoot;
+        this.contentCommitment = contentCommitment;
+        this.slotNumber = slotNumber;
+        this.timestamp = timestamp;
+        this.coinbase = coinbase;
+        this.feeRecipient = feeRecipient;
+        this.gasFees = gasFees;
+        this.totalManaUsed = totalManaUsed;
+    }
+    static get schema() {
+        return z.object({
+            lastArchiveRoot: schemas.Fr,
+            contentCommitment: ContentCommitment.schema,
+            slotNumber: schemas.Fr,
+            timestamp: schemas.BigInt,
+            coinbase: schemas.EthAddress,
+            feeRecipient: schemas.AztecAddress,
+            gasFees: GasFees.schema,
+            totalManaUsed: schemas.Fr
+        }).transform(ProposedBlockHeader.from);
+    }
+    static getFields(fields) {
+        return [
+            fields.lastArchiveRoot,
+            fields.contentCommitment,
+            fields.slotNumber,
+            fields.timestamp,
+            fields.coinbase,
+            fields.feeRecipient,
+            fields.gasFees,
+            fields.totalManaUsed
+        ];
+    }
+    static from(fields) {
+        return new ProposedBlockHeader(...ProposedBlockHeader.getFields(fields));
+    }
+    static fromBuffer(buffer) {
+        const reader = BufferReader.asReader(buffer);
+        return new ProposedBlockHeader(reader.readObject(Fr), reader.readObject(ContentCommitment), Fr.fromBuffer(reader), reader.readUInt64(), reader.readObject(EthAddress), reader.readObject(AztecAddress), reader.readObject(GasFees), reader.readObject(Fr));
+    }
+    equals(other) {
+        return this.lastArchiveRoot.equals(other.lastArchiveRoot) && this.contentCommitment.equals(other.contentCommitment) && this.slotNumber.equals(other.slotNumber) && this.timestamp === other.timestamp && this.coinbase.equals(other.coinbase) && this.feeRecipient.equals(other.feeRecipient) && this.gasFees.equals(other.gasFees) && this.totalManaUsed.equals(other.totalManaUsed);
+    }
+    toBuffer() {
+        // Note: The order here must match the order in the ProposedHeaderLib solidity library.
+        return serializeToBuffer([
+            this.lastArchiveRoot,
+            this.contentCommitment,
+            this.slotNumber,
+            bigintToUInt64BE(this.timestamp),
+            this.coinbase,
+            this.feeRecipient,
+            this.gasFees,
+            this.totalManaUsed
+        ]);
+    }
+    hash() {
+        return sha256ToField([
+            this.toBuffer()
+        ]);
+    }
+    static empty(fields = {}) {
+        return ProposedBlockHeader.from({
+            lastArchiveRoot: Fr.ZERO,
+            contentCommitment: ContentCommitment.empty(),
+            slotNumber: Fr.ZERO,
+            timestamp: 0n,
+            coinbase: EthAddress.ZERO,
+            feeRecipient: AztecAddress.ZERO,
+            gasFees: GasFees.empty(),
+            totalManaUsed: Fr.ZERO,
+            ...fields
+        });
+    }
+    static random() {
+        return new ProposedBlockHeader(Fr.random(), ContentCommitment.random(), new Fr(BigInt(Math.floor(Math.random() * 1000) + 1)), BigInt(Math.floor(Date.now() / 1000)), EthAddress.random(), new AztecAddress(Fr.random()), GasFees.random(), new Fr(BigInt(Math.floor(Math.random() * 1000000))));
+    }
+    isEmpty() {
+        return this.lastArchiveRoot.isZero() && this.contentCommitment.isEmpty() && this.slotNumber.isZero() && this.timestamp === 0n && this.coinbase.isZero() && this.feeRecipient.isZero() && this.gasFees.isEmpty() && this.totalManaUsed.isZero();
+    }
+    /**
+   * Serializes this instance into a string.
+   * @returns Encoded string.
+   */ toString() {
+        return bufferToHex(this.toBuffer());
+    }
+    static fromString(str) {
+        return ProposedBlockHeader.fromBuffer(hexToBuffer(str));
+    }
+    static fromViem(header) {
+        return new ProposedBlockHeader(Fr.fromString(header.lastArchiveRoot), ContentCommitment.fromViem(header.contentCommitment), new Fr(header.slotNumber), header.timestamp, new EthAddress(hexToBuffer(header.coinbase)), new AztecAddress(hexToBuffer(header.feeRecipient)), new GasFees(header.gasFees.feePerDaGas, header.gasFees.feePerL2Gas), new Fr(header.totalManaUsed));
+    }
+    toViem() {
+        return {
+            lastArchiveRoot: this.lastArchiveRoot.toString(),
+            contentCommitment: this.contentCommitment.toViem(),
+            slotNumber: this.slotNumber.toBigInt(),
+            timestamp: this.timestamp,
+            coinbase: this.coinbase.toString(),
+            feeRecipient: `0x${this.feeRecipient.toBuffer().toString('hex').padStart(64, '0')}`,
+            gasFees: {
+                feePerDaGas: this.gasFees.feePerDaGas,
+                feePerL2Gas: this.gasFees.feePerL2Gas
+            },
+            totalManaUsed: this.totalManaUsed.toBigInt()
+        };
+    }
+    toInspect() {
+        return {
+            lastArchive: this.lastArchiveRoot.toString(),
+            contentCommitment: this.contentCommitment.toInspect(),
+            slotNumber: this.slotNumber.toBigInt(),
+            timestamp: this.timestamp,
+            coinbase: this.coinbase.toString(),
+            feeRecipient: this.feeRecipient.toString(),
+            gasFees: this.gasFees.toInspect(),
+            totalManaUsed: this.totalManaUsed.toBigInt()
+        };
+    }
+    [inspect.custom]() {
+        const gasfees = `da:${this.gasFees.feePerDaGas}, l2:${this.gasFees.feePerL2Gas}`;
+        return `Header {
+  lastArchiveRoot: ${this.lastArchiveRoot.toString()},
+  contentCommitment: ${inspect(this.contentCommitment)},
+  slotNumber: ${this.slotNumber.toBigInt()},
+  timestamp: ${this.timestamp},
+  coinbase: ${this.coinbase.toString()},
+  feeRecipient: ${this.feeRecipient.toString()},
+  gasFees: ${gasfees},
+  totalManaUsed: ${this.totalManaUsed.toBigInt()},
+}`;
+    }
+}

package/dest/tx/proven_tx.d.ts

@@ -0,0 +1,129 @@
+import type { FieldsOf } from '@aztec/foundation/types';
+import { z } from 'zod';
+import { PrivateKernelTailCircuitPublicInputs } from '../kernel/private_kernel_tail_circuit_public_inputs.js';
+import { ClientIvcProof } from '../proofs/client_ivc_proof.js';
+import type { OffchainEffect } from './offchain_effect.js';
+import { PrivateExecutionResult } from './private_execution_result.js';
+import { type ProvingStats } from './profiling.js';
+import { Tx } from './tx.js';
+export declare class TxProvingResult {
+    privateExecutionResult: PrivateExecutionResult;
+    publicInputs: PrivateKernelTailCircuitPublicInputs;
+    clientIvcProof: ClientIvcProof;
+    stats?: ProvingStats | undefined;
+    constructor(privateExecutionResult: PrivateExecutionResult, publicInputs: PrivateKernelTailCircuitPublicInputs, clientIvcProof: ClientIvcProof, stats?: ProvingStats | undefined);
+    toTx(): Promise<Tx>;
+    getOffchainEffects(): OffchainEffect[];
+    static get schema(): z.ZodEffects<z.ZodObject<{
+        privateExecutionResult: import("@aztec/foundation/schemas").ZodFor<PrivateExecutionResult>;
+        publicInputs: z.ZodType<PrivateKernelTailCircuitPublicInputs, any, string>;
+        clientIvcProof: z.ZodType<ClientIvcProof, any, string>;
+        timings: import("@aztec/foundation/schemas").ZodNullableOptional<z.ZodObject<{
+            sync: import("@aztec/foundation/schemas").ZodNullableOptional<z.ZodNumber>;
+            proving: import("@aztec/foundation/schemas").ZodNullableOptional<z.ZodNumber>;
+            perFunction: z.ZodArray<z.ZodObject<{
+                functionName: z.ZodString;
+                time: z.ZodNumber;
+                oracles: import("@aztec/foundation/schemas").ZodNullableOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
+                    times: z.ZodArray<z.ZodNumber, "many">;
+                }, "strip", z.ZodTypeAny, {
+                    times: number[];
+                }, {
+                    times: number[];
+                }>>>;
+            }, "strip", z.ZodTypeAny, {
+                functionName: string;
+                time: number;
+                oracles?: Record<string, {
+                    times: number[];
+                }> | undefined;
+            }, {
+                functionName: string;
+                time: number;
+                oracles?: Record<string, {
+                    times: number[];
+                }> | undefined;
+            }>, "many">;
+            unaccounted: z.ZodNumber;
+            total: z.ZodNumber;
+        }, "strip", z.ZodTypeAny, {
+            total: number;
+            perFunction: {
+                functionName: string;
+                time: number;
+                oracles?: Record<string, {
+                    times: number[];
+                }> | undefined;
+            }[];
+            unaccounted: number;
+            sync?: number | undefined;
+            proving?: number | undefined;
+        }, {
+            total: number;
+            perFunction: {
+                functionName: string;
+                time: number;
+                oracles?: Record<string, {
+                    times: number[];
+                }> | undefined;
+            }[];
+            unaccounted: number;
+            sync?: number | undefined;
+            proving?: number | undefined;
+        }>>;
+    }, "strip", z.ZodTypeAny, {
+        publicInputs: PrivateKernelTailCircuitPublicInputs;
+        clientIvcProof: ClientIvcProof;
+        privateExecutionResult: PrivateExecutionResult;
+        timings?: {
+            total: number;
+            perFunction: {
+                functionName: string;
+                time: number;
+                oracles?: Record<string, {
+                    times: number[];
+                }> | undefined;
+            }[];
+            unaccounted: number;
+            sync?: number | undefined;
+            proving?: number | undefined;
+        } | undefined;
+    }, {
+        publicInputs: string;
+        clientIvcProof: string;
+        timings?: {
+            total: number;
+            perFunction: {
+                functionName: string;
+                time: number;
+                oracles?: Record<string, {
+                    times: number[];
+                }> | undefined;
+            }[];
+            unaccounted: number;
+            sync?: number | undefined;
+            proving?: number | undefined;
+        } | undefined;
+        privateExecutionResult?: any;
+    }>, TxProvingResult, {
+        publicInputs: string;
+        clientIvcProof: string;
+        timings?: {
+            total: number;
+            perFunction: {
+                functionName: string;
+                time: number;
+                oracles?: Record<string, {
+                    times: number[];
+                }> | undefined;
+            }[];
+            unaccounted: number;
+            sync?: number | undefined;
+            proving?: number | undefined;
+        } | undefined;
+        privateExecutionResult?: any;
+    }>;
+    static from(fields: FieldsOf<TxProvingResult>): TxProvingResult;
+    static random(): Promise<TxProvingResult>;
+}
+//# sourceMappingURL=proven_tx.d.ts.map

package/dest/tx/proven_tx.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"proven_tx.d.ts","sourceRoot":"","sources":["../../src/tx/proven_tx.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,yBAAyB,CAAC;AAExD,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,OAAO,EAAE,oCAAoC,EAAE,MAAM,wDAAwD,CAAC;AAC9G,OAAO,EAAE,cAAc,EAAE,MAAM,+BAA+B,CAAC;AAC/D,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,sBAAsB,CAAC;AAC3D,OAAO,EACL,sBAAsB,EAGvB,MAAM,+BAA+B,CAAC;AACvC,OAAO,EAAE,KAAK,YAAY,EAAwB,MAAM,gBAAgB,CAAC;AACzE,OAAO,EAAE,EAAE,EAAE,MAAM,SAAS,CAAC;AAE7B,qBAAa,eAAe;IAEjB,sBAAsB,EAAE,sBAAsB;IAC9C,YAAY,EAAE,oCAAoC;IAClD,cAAc,EAAE,cAAc;IAC9B,KAAK,CAAC,EAAE,YAAY;gBAHpB,sBAAsB,EAAE,sBAAsB,EAC9C,YAAY,EAAE,oCAAoC,EAClD,cAAc,EAAE,cAAc,EAC9B,KAAK,CAAC,EAAE,YAAY,YAAA;IAGvB,IAAI,IAAI,OAAO,CAAC,EAAE,CAAC;IAWzB,kBAAkB,IAAI,cAAc,EAAE;IAItC,MAAM,KAAK,MAAM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OAShB;IAED,MAAM,CAAC,IAAI,CAAC,MAAM,EAAE,QAAQ,CAAC,eAAe,CAAC;WAIhC,MAAM;CAOpB"}

package/dest/tx/proven_tx.js

@@ -0,0 +1,45 @@
+import { optional } from '@aztec/foundation/schemas';
+import { z } from 'zod';
+import { PrivateKernelTailCircuitPublicInputs } from '../kernel/private_kernel_tail_circuit_public_inputs.js';
+import { ClientIvcProof } from '../proofs/client_ivc_proof.js';
+import { PrivateExecutionResult, collectOffchainEffects, collectSortedContractClassLogs } from './private_execution_result.js';
+import { ProvingTimingsSchema } from './profiling.js';
+import { Tx } from './tx.js';
+export class TxProvingResult {
+    privateExecutionResult;
+    publicInputs;
+    clientIvcProof;
+    stats;
+    constructor(privateExecutionResult, publicInputs, clientIvcProof, stats){
+        this.privateExecutionResult = privateExecutionResult;
+        this.publicInputs = publicInputs;
+        this.clientIvcProof = clientIvcProof;
+        this.stats = stats;
+    }
+    async toTx() {
+        const contractClassLogs = collectSortedContractClassLogs(this.privateExecutionResult);
+        return await Tx.create({
+            data: this.publicInputs,
+            clientIvcProof: this.clientIvcProof,
+            contractClassLogFields: contractClassLogs,
+            publicFunctionCalldata: this.privateExecutionResult.publicFunctionCalldata
+        });
+    }
+    getOffchainEffects() {
+        return collectOffchainEffects(this.privateExecutionResult);
+    }
+    static get schema() {
+        return z.object({
+            privateExecutionResult: PrivateExecutionResult.schema,
+            publicInputs: PrivateKernelTailCircuitPublicInputs.schema,
+            clientIvcProof: ClientIvcProof.schema,
+            timings: optional(ProvingTimingsSchema)
+        }).transform(TxProvingResult.from);
+    }
+    static from(fields) {
+        return new TxProvingResult(fields.privateExecutionResult, fields.publicInputs, fields.clientIvcProof);
+    }
+    static async random() {
+        return new TxProvingResult(await PrivateExecutionResult.random(), PrivateKernelTailCircuitPublicInputs.empty(), ClientIvcProof.empty());
+    }
+}

package/dest/tx/public_call_request_with_calldata.d.ts

@@ -0,0 +1,38 @@
+import { Fr } from '@aztec/foundation/fields';
+import { BufferReader } from '@aztec/foundation/serialize';
+import { inspect } from 'util';
+import { FunctionSelector } from '../abi/function_selector.js';
+import { PublicCallRequest } from '../kernel/public_call_request.js';
+import { type ZodFor } from '../schemas/index.js';
+/**
+ * The call request of a public function, including the calldata.
+ */
+export declare class PublicCallRequestWithCalldata {
+    /**
+     * Request of the public call.
+     */
+    request: PublicCallRequest;
+    /**
+     * Function selector and arguments of the public call.
+     */
+    calldata: Fr[];
+    constructor(
+    /**
+     * Request of the public call.
+     */
+    request: PublicCallRequest, 
+    /**
+     * Function selector and arguments of the public call.
+     */
+    calldata: Fr[]);
+    get functionSelector(): FunctionSelector;
+    get args(): Fr[];
+    static get schema(): ZodFor<PublicCallRequestWithCalldata>;
+    static from(fields: Pick<PublicCallRequestWithCalldata, 'request' | 'calldata'>): PublicCallRequestWithCalldata;
+    toBuffer(): Buffer<ArrayBufferLike>;
+    static fromBuffer(buffer: Buffer | BufferReader): PublicCallRequestWithCalldata;
+    static empty(): PublicCallRequestWithCalldata;
+    isEmpty(): boolean;
+    [inspect.custom](): string;
+}
+//# sourceMappingURL=public_call_request_with_calldata.d.ts.map

package/dest/tx/public_call_request_with_calldata.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"public_call_request_with_calldata.d.ts","sourceRoot":"","sources":["../../src/tx/public_call_request_with_calldata.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,EAAE,EAAE,MAAM,0BAA0B,CAAC;AAC9C,OAAO,EAAE,YAAY,EAAqB,MAAM,6BAA6B,CAAC;AAE9E,OAAO,EAAE,OAAO,EAAE,MAAM,MAAM,CAAC;AAG/B,OAAO,EAAE,gBAAgB,EAAE,MAAM,6BAA6B,CAAC;AAC/D,OAAO,EAAE,iBAAiB,EAAE,MAAM,kCAAkC,CAAC;AACrE,OAAO,EAAE,KAAK,MAAM,EAAW,MAAM,qBAAqB,CAAC;AAG3D;;GAEG;AACH,qBAAa,6BAA6B;IAEtC;;OAEG;IACI,OAAO,EAAE,iBAAiB;IACjC;;OAEG;IACI,QAAQ,EAAE,EAAE,EAAE;;IAPrB;;OAEG;IACI,OAAO,EAAE,iBAAiB;IACjC;;OAEG;IACI,QAAQ,EAAE,EAAE,EAAE;IAIvB,IAAI,gBAAgB,IAAI,gBAAgB,CAEvC;IAED,IAAI,IAAI,IAAI,EAAE,EAAE,CAEf;IAED,MAAM,KAAK,MAAM,IAAI,MAAM,CAAC,6BAA6B,CAAC,CAOzD;IAED,MAAM,CAAC,IAAI,CAAC,MAAM,EAAE,IAAI,CAAC,6BAA6B,EAAE,SAAS,GAAG,UAAU,CAAC,GAAG,6BAA6B;IAI/G,QAAQ;IAIR,MAAM,CAAC,UAAU,CAAC,MAAM,EAAE,MAAM,GAAG,YAAY;IAK/C,MAAM,CAAC,KAAK;IAIZ,OAAO,IAAI,OAAO;IAIlB,CAAC,OAAO,CAAC,MAAM,CAAC;CAMjB"}

package/dest/tx/public_call_request_with_calldata.js

@@ -0,0 +1,57 @@
+import { Fr } from '@aztec/foundation/fields';
+import { BufferReader, serializeToBuffer } from '@aztec/foundation/serialize';
+import { inspect } from 'util';
+import { z } from 'zod';
+import { FunctionSelector } from '../abi/function_selector.js';
+import { PublicCallRequest } from '../kernel/public_call_request.js';
+import { schemas } from '../schemas/index.js';
+import { Vector } from '../types/index.js';
+/**
+ * The call request of a public function, including the calldata.
+ */ export class PublicCallRequestWithCalldata {
+    request;
+    calldata;
+    constructor(/**
+     * Request of the public call.
+     */ request, /**
+     * Function selector and arguments of the public call.
+     */ calldata){
+        this.request = request;
+        this.calldata = calldata;
+    }
+    // Public functions get routed through the dispatch function, whose first argument is the target function selector.
+    get functionSelector() {
+        return FunctionSelector.fromField(this.calldata[0]);
+    }
+    get args() {
+        return this.calldata.slice(1);
+    }
+    static get schema() {
+        return z.object({
+            request: PublicCallRequest.schema,
+            calldata: z.array(schemas.Fr)
+        }).transform(PublicCallRequestWithCalldata.from);
+    }
+    static from(fields) {
+        return new PublicCallRequestWithCalldata(fields.request, fields.calldata);
+    }
+    toBuffer() {
+        return serializeToBuffer(this.request, new Vector(this.calldata));
+    }
+    static fromBuffer(buffer) {
+        const reader = BufferReader.asReader(buffer);
+        return new PublicCallRequestWithCalldata(PublicCallRequest.fromBuffer(reader), reader.readVector(Fr));
+    }
+    static empty() {
+        return new PublicCallRequestWithCalldata(PublicCallRequest.empty(), []);
+    }
+    isEmpty() {
+        return this.request.isEmpty() && this.calldata.length === 0;
+    }
+    [inspect.custom]() {
+        return `PublicCallRequestWithCalldata {
+      request: ${inspect(this.request)}
+      calldata: ${this.calldata}
+    }`;
+    }
+}

package/dest/tx/public_simulation_output.d.ts

@@ -2,8 +2,8 @@ import { Fr } from '@aztec/foundation/fields';
 import { type ZodFor } from '@aztec/foundation/schemas';
 import { SimulationError } from '../errors/simulation_error.js';
 import type { GasUsed } from '../gas/gas_used.js';
-import { CombinedConstantData } from '../kernel/combined_constant_data.js';
 import { TxEffect } from '../tx/tx_effect.js';
+import { GlobalVariables } from './global_variables.js';
 /** Return values of simulating a circuit. */
 export type ProcessReturnValues = Fr[] | undefined;
 /** Return values of simulating complete callstack. */
@@ -20,11 +20,11 @@ export declare class NestedProcessReturnValues {
  */
 export declare class PublicSimulationOutput {
     revertReason: SimulationError | undefined;
-    constants: CombinedConstantData;
+    globalVariables: GlobalVariables;
     txEffect: TxEffect;
     publicReturnValues: NestedProcessReturnValues[];
     gasUsed: GasUsed;
-    constructor(revertReason: SimulationError | undefined, constants: CombinedConstantData, txEffect: TxEffect, publicReturnValues: NestedProcessReturnValues[], gasUsed: GasUsed);
+    constructor(revertReason: SimulationError | undefined, globalVariables: GlobalVariables, txEffect: TxEffect, publicReturnValues: NestedProcessReturnValues[], gasUsed: GasUsed);
     static get schema(): ZodFor<PublicSimulationOutput>;
     static random(): Promise<PublicSimulationOutput>;
 }

package/dest/tx/public_simulation_output.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"public_simulation_output.d.ts","sourceRoot":"","sources":["../../src/tx/public_simulation_output.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,EAAE,EAAE,MAAM,0BAA0B,CAAC;AAC9C,OAAO,EAAE,KAAK,MAAM,EAAW,MAAM,2BAA2B,CAAC;AAKjE,OAAO,EAAE,eAAe,EAAE,MAAM,+BAA+B,CAAC;AAEhE,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,oBAAoB,CAAC;AAClD,OAAO,EAAE,oBAAoB,EAAE,MAAM,qCAAqC,CAAC;AAC3E,OAAO,EAAE,QAAQ,EAAE,MAAM,oBAAoB,CAAC;AAE9C,6CAA6C;AAC7C,MAAM,MAAM,mBAAmB,GAAG,EAAE,EAAE,GAAG,SAAS,CAAC;AAEnD,sDAAsD;AACtD,qBAAa,yBAAyB;IACpC,MAAM,EAAE,mBAAmB,CAAC;IAC5B,MAAM,EAAE,yBAAyB,EAAE,CAAC;gBAExB,MAAM,EAAE,mBAAmB,EAAE,MAAM,CAAC,EAAE,yBAAyB,EAAE;IAK7E,MAAM,KAAK,MAAM,IAAI,MAAM,CAAC,yBAAyB,CAAC,CAOrD;IAED,MAAM,CAAC,KAAK;IAIZ,MAAM,CAAC,MAAM,CAAC,KAAK,SAAI,GAAG,yBAAyB;CAMpD;AAED;;GAEG;AACH,qBAAa,sBAAsB;IAExB,YAAY,EAAE,eAAe,GAAG,SAAS;IACzC,SAAS,EAAE,oBAAoB;IAC/B,QAAQ,EAAE,QAAQ;IAClB,kBAAkB,EAAE,yBAAyB,EAAE;IAC/C,OAAO,EAAE,OAAO;gBAJhB,YAAY,EAAE,eAAe,GAAG,SAAS,EACzC,SAAS,EAAE,oBAAoB,EAC/B,QAAQ,EAAE,QAAQ,EAClB,kBAAkB,EAAE,yBAAyB,EAAE,EAC/C,OAAO,EAAE,OAAO;IAGzB,MAAM,KAAK,MAAM,IAAI,MAAM,CAAC,sBAAsB,CAAC,CAwBlD;WAEY,MAAM;CASpB"}
+{"version":3,"file":"public_simulation_output.d.ts","sourceRoot":"","sources":["../../src/tx/public_simulation_output.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,EAAE,EAAE,MAAM,0BAA0B,CAAC;AAC9C,OAAO,EAAE,KAAK,MAAM,EAAW,MAAM,2BAA2B,CAAC;AAKjE,OAAO,EAAE,eAAe,EAAE,MAAM,+BAA+B,CAAC;AAEhE,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,oBAAoB,CAAC;AAClD,OAAO,EAAE,QAAQ,EAAE,MAAM,oBAAoB,CAAC;AAC9C,OAAO,EAAE,eAAe,EAAE,MAAM,uBAAuB,CAAC;AAExD,6CAA6C;AAC7C,MAAM,MAAM,mBAAmB,GAAG,EAAE,EAAE,GAAG,SAAS,CAAC;AAEnD,sDAAsD;AACtD,qBAAa,yBAAyB;IACpC,MAAM,EAAE,mBAAmB,CAAC;IAC5B,MAAM,EAAE,yBAAyB,EAAE,CAAC;gBAExB,MAAM,EAAE,mBAAmB,EAAE,MAAM,CAAC,EAAE,yBAAyB,EAAE;IAK7E,MAAM,KAAK,MAAM,IAAI,MAAM,CAAC,yBAAyB,CAAC,CAOrD;IAED,MAAM,CAAC,KAAK;IAIZ,MAAM,CAAC,MAAM,CAAC,KAAK,SAAI,GAAG,yBAAyB;CAMpD;AAED;;GAEG;AACH,qBAAa,sBAAsB;IAExB,YAAY,EAAE,eAAe,GAAG,SAAS;IACzC,eAAe,EAAE,eAAe;IAChC,QAAQ,EAAE,QAAQ;IAClB,kBAAkB,EAAE,yBAAyB,EAAE;IAC/C,OAAO,EAAE,OAAO;gBAJhB,YAAY,EAAE,eAAe,GAAG,SAAS,EACzC,eAAe,EAAE,eAAe,EAChC,QAAQ,EAAE,QAAQ,EAClB,kBAAkB,EAAE,yBAAyB,EAAE,EAC/C,OAAO,EAAE,OAAO;IAGzB,MAAM,KAAK,MAAM,IAAI,MAAM,CAAC,sBAAsB,CAAC,CAwBlD;WAEY,MAAM;CASpB"}

package/dest/tx/public_simulation_output.js

@@ -4,8 +4,8 @@ import times from 'lodash.times';
 import { z } from 'zod';
 import { SimulationError } from '../errors/simulation_error.js';
 import { Gas } from '../gas/gas.js';
-import { CombinedConstantData } from '../kernel/combined_constant_data.js';
 import { TxEffect } from '../tx/tx_effect.js';
+import { GlobalVariables } from './global_variables.js';
 /** Return values of simulating complete callstack. */ export class NestedProcessReturnValues {
     values;
     nested;
@@ -32,13 +32,13 @@ import { TxEffect } from '../tx/tx_effect.js';
  * Outputs of processing the public component of a transaction.
  */ export class PublicSimulationOutput {
     revertReason;
-    constants;
+    globalVariables;
     txEffect;
     publicReturnValues;
     gasUsed;
-    constructor(revertReason, constants, txEffect, publicReturnValues, gasUsed){
+    constructor(revertReason, globalVariables, txEffect, publicReturnValues, gasUsed){
         this.revertReason = revertReason;
-        this.constants = constants;
+        this.globalVariables = globalVariables;
         this.txEffect = txEffect;
         this.publicReturnValues = publicReturnValues;
         this.gasUsed = gasUsed;
@@ -46,7 +46,7 @@ import { TxEffect } from '../tx/tx_effect.js';
     static get schema() {
         return z.object({
             revertReason: SimulationError.schema.optional(),
-            constants: CombinedConstantData.schema,
+            globalVariables: GlobalVariables.schema,
             txEffect: TxEffect.schema,
             publicReturnValues: z.array(NestedProcessReturnValues.schema),
             gasUsed: z.object({
@@ -55,10 +55,10 @@ import { TxEffect } from '../tx/tx_effect.js';
                 publicGas: Gas.schema,
                 billedGas: Gas.schema
             })
-        }).transform((fields)=>new PublicSimulationOutput(fields.revertReason, fields.constants, fields.txEffect, fields.publicReturnValues, fields.gasUsed));
+        }).transform((fields)=>new PublicSimulationOutput(fields.revertReason, fields.globalVariables, fields.txEffect, fields.publicReturnValues, fields.gasUsed));
     }
     static async random() {
-        return new PublicSimulationOutput(await SimulationError.random(), CombinedConstantData.empty(), TxEffect.empty(), times(2, NestedProcessReturnValues.random), {
+        return new PublicSimulationOutput(await SimulationError.random(), GlobalVariables.empty(), TxEffect.empty(), times(2, NestedProcessReturnValues.random), {
             teardownGas: Gas.random(),
             totalGas: Gas.random(),
             publicGas: Gas.random(),