@aztec/stdlib 0.77.0-testnet-ignition.17

package/dest/gas/gas_used.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"gas_used.d.ts","sourceRoot":"","sources":["../../src/gas/gas_used.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,GAAG,EAAE,MAAM,UAAU,CAAC;AAEpC,MAAM,WAAW,OAAO;IACtB;;;;OAIG;IACH,QAAQ,EAAE,GAAG,CAAC;IAEd,4EAA4E;IAC5E,SAAS,EAAE,GAAG,CAAC;IAEf;;OAEG;IACH,WAAW,EAAE,GAAG,CAAC;IAEjB;;OAEG;IACH,SAAS,EAAE,GAAG,CAAC;CAChB"}

package/dest/gas/gas_used.js

@@ -0,0 +1 @@
+export { };

package/dest/gas/index.d.ts

@@ -0,0 +1,5 @@
+export * from './gas.js';
+export * from './gas_fees.js';
+export * from './gas_settings.js';
+export * from './gas_used.js';
+//# sourceMappingURL=index.d.ts.map

package/dest/gas/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/gas/index.ts"],"names":[],"mappings":"AAAA,cAAc,UAAU,CAAC;AACzB,cAAc,eAAe,CAAC;AAC9B,cAAc,mBAAmB,CAAC;AAClC,cAAc,eAAe,CAAC"}

package/dest/gas/index.js

@@ -0,0 +1,4 @@
+export * from './gas.js';
+export * from './gas_fees.js';
+export * from './gas_settings.js';
+export * from './gas_used.js';

package/dest/hash/hash.d.ts

@@ -0,0 +1,77 @@
+import { Fr } from '@aztec/foundation/fields';
+import type { AztecAddress } from '../aztec-address/index.js';
+import type { ContractClassLog } from '../logs/index.js';
+import type { ScopedL2ToL1Message } from '../messaging/l2_to_l1_message.js';
+/**
+ * Computes a hash of a given verification key.
+ * @param vkBuf - The verification key as fields.
+ * @returns The hash of the verification key.
+ */
+export declare function hashVK(keyAsFields: Fr[]): Promise<Fr>;
+/**
+ * Computes a note hash nonce, which will be used to create a unique note hash.
+ * @param nullifierZero - The first nullifier in the tx.
+ * @param noteHashIndex - The index of the note hash.
+ * @returns A note hash nonce.
+ */
+export declare function computeNoteHashNonce(nullifierZero: Fr, noteHashIndex: number): Promise<Fr>;
+/**
+ * Computes a siloed note hash, given the contract address and the note hash itself.
+ * A siloed note hash effectively namespaces a note hash to a specific contract.
+ * @param contract - The contract address
+ * @param noteHash - The note hash to silo.
+ * @returns A siloed note hash.
+ */
+export declare function siloNoteHash(contract: AztecAddress, noteHash: Fr): Promise<Fr>;
+/**
+ * Computes a unique note hash.
+ * @dev Includes a nonce which contains data that guarantees the resulting note hash will be unique.
+ * @param nonce - A nonce (typically derived from tx hash and note hash index in the tx).
+ * @param siloedNoteHash - A siloed note hash.
+ * @returns A unique note hash.
+ */
+export declare function computeUniqueNoteHash(nonce: Fr, siloedNoteHash: Fr): Promise<Fr>;
+/**
+ * Computes a siloed nullifier, given the contract address and the inner nullifier.
+ * A siloed nullifier effectively namespaces a nullifier to a specific contract.
+ * @param contract - The contract address.
+ * @param innerNullifier - The nullifier to silo.
+ * @returns A siloed nullifier.
+ */
+export declare function siloNullifier(contract: AztecAddress, innerNullifier: Fr): Promise<Fr>;
+/**
+ * Computes a public data tree value ready for insertion.
+ * @param value - Raw public data tree value to hash into a tree-insertion-ready value.
+ * @returns Value hash into a tree-insertion-ready value.
+
+ */
+export declare function computePublicDataTreeValue(value: Fr): Fr;
+/**
+ * Computes a public data tree index from contract address and storage slot.
+ * @param contractAddress - Contract where insertion is occurring.
+ * @param storageSlot - Storage slot where insertion is occurring.
+ * @returns Public data tree index computed from contract address and storage slot.
+
+ */
+export declare function computePublicDataTreeLeafSlot(contractAddress: AztecAddress, storageSlot: Fr): Promise<Fr>;
+/**
+ * Computes the hash of a list of arguments.
+ * @param args - Arguments to hash.
+ * @returns Pedersen hash of the arguments.
+ */
+export declare function computeVarArgsHash(args: Fr[]): Promise<Fr>;
+/**
+ * Computes a hash of a secret.
+ * @dev This function is used to generate secrets for the L1 to L2 message flow and for the TransparentNote.
+ * @param secret - The secret to hash (could be generated however you want e.g. `Fr.random()`)
+ * @returns The hash
+ */
+export declare function computeSecretHash(secret: Fr): Promise<Fr>;
+export declare function computeL1ToL2MessageNullifier(contract: AztecAddress, messageHash: Fr, secret: Fr): Promise<Fr>;
+/**
+ * Calculates a siloed hash of a scoped l2 to l1 message.
+ * @returns Fr containing 248 bits of information of sha256 hash.
+ */
+export declare function siloL2ToL1Message(l2ToL1Message: ScopedL2ToL1Message, version: Fr, chainId: Fr): Fr;
+export declare function siloContractClassLog(log: ContractClassLog, contract: AztecAddress): Promise<ContractClassLog>;
+//# sourceMappingURL=hash.d.ts.map

package/dest/hash/hash.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"hash.d.ts","sourceRoot":"","sources":["../../src/hash/hash.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,EAAE,EAAE,MAAM,0BAA0B,CAAC;AAE9C,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,2BAA2B,CAAC;AAC9D,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,kBAAkB,CAAC;AACzD,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,kCAAkC,CAAC;AAE5E;;;;GAIG;AACH,wBAAgB,MAAM,CAAC,WAAW,EAAE,EAAE,EAAE,GAAG,OAAO,CAAC,EAAE,CAAC,CAErD;AAED;;;;;GAKG;AACH,wBAAgB,oBAAoB,CAAC,aAAa,EAAE,EAAE,EAAE,aAAa,EAAE,MAAM,GAAG,OAAO,CAAC,EAAE,CAAC,CAE1F;AAED;;;;;;GAMG;AACH,wBAAgB,YAAY,CAAC,QAAQ,EAAE,YAAY,EAAE,QAAQ,EAAE,EAAE,GAAG,OAAO,CAAC,EAAE,CAAC,CAE9E;AAED;;;;;;GAMG;AACH,wBAAgB,qBAAqB,CAAC,KAAK,EAAE,EAAE,EAAE,cAAc,EAAE,EAAE,GAAG,OAAO,CAAC,EAAE,CAAC,CAEhF;AAED;;;;;;GAMG;AACH,wBAAgB,aAAa,CAAC,QAAQ,EAAE,YAAY,EAAE,cAAc,EAAE,EAAE,GAAG,OAAO,CAAC,EAAE,CAAC,CAErF;AAED;;;;;GAKG;AACH,wBAAgB,0BAA0B,CAAC,KAAK,EAAE,EAAE,GAAG,EAAE,CAExD;AAED;;;;;;GAMG;AACH,wBAAgB,6BAA6B,CAAC,eAAe,EAAE,YAAY,EAAE,WAAW,EAAE,EAAE,GAAG,OAAO,CAAC,EAAE,CAAC,CAEzG;AAED;;;;GAIG;AACH,wBAAgB,kBAAkB,CAAC,IAAI,EAAE,EAAE,EAAE,GAAG,OAAO,CAAC,EAAE,CAAC,CAM1D;AAED;;;;;GAKG;AACH,wBAAgB,iBAAiB,CAAC,MAAM,EAAE,EAAE,GAAG,OAAO,CAAC,EAAE,CAAC,CAEzD;AAED,wBAAsB,6BAA6B,CAAC,QAAQ,EAAE,YAAY,EAAE,WAAW,EAAE,EAAE,EAAE,MAAM,EAAE,EAAE,eAMtG;AAED;;;GAGG;AACH,wBAAgB,iBAAiB,CAAC,aAAa,EAAE,mBAAmB,EAAE,OAAO,EAAE,EAAE,EAAE,OAAO,EAAE,EAAE,GAAG,EAAE,CAiBlG;AAED,wBAAsB,oBAAoB,CAAC,GAAG,EAAE,gBAAgB,EAAE,QAAQ,EAAE,YAAY,GAAG,OAAO,CAAC,gBAAgB,CAAC,CAOnH"}

package/dest/hash/hash.js

@@ -0,0 +1,135 @@
+import { GeneratorIndex } from '@aztec/constants';
+import { poseidon2Hash, poseidon2HashWithSeparator, sha256Trunc } from '@aztec/foundation/crypto';
+import { Fr } from '@aztec/foundation/fields';
+/**
+ * Computes a hash of a given verification key.
+ * @param vkBuf - The verification key as fields.
+ * @returns The hash of the verification key.
+ */ export function hashVK(keyAsFields) {
+    return poseidon2Hash(keyAsFields);
+}
+/**
+ * Computes a note hash nonce, which will be used to create a unique note hash.
+ * @param nullifierZero - The first nullifier in the tx.
+ * @param noteHashIndex - The index of the note hash.
+ * @returns A note hash nonce.
+ */ export function computeNoteHashNonce(nullifierZero, noteHashIndex) {
+    return poseidon2HashWithSeparator([
+        nullifierZero,
+        noteHashIndex
+    ], GeneratorIndex.NOTE_HASH_NONCE);
+}
+/**
+ * Computes a siloed note hash, given the contract address and the note hash itself.
+ * A siloed note hash effectively namespaces a note hash to a specific contract.
+ * @param contract - The contract address
+ * @param noteHash - The note hash to silo.
+ * @returns A siloed note hash.
+ */ export function siloNoteHash(contract, noteHash) {
+    return poseidon2HashWithSeparator([
+        contract,
+        noteHash
+    ], GeneratorIndex.SILOED_NOTE_HASH);
+}
+/**
+ * Computes a unique note hash.
+ * @dev Includes a nonce which contains data that guarantees the resulting note hash will be unique.
+ * @param nonce - A nonce (typically derived from tx hash and note hash index in the tx).
+ * @param siloedNoteHash - A siloed note hash.
+ * @returns A unique note hash.
+ */ export function computeUniqueNoteHash(nonce, siloedNoteHash) {
+    return poseidon2HashWithSeparator([
+        nonce,
+        siloedNoteHash
+    ], GeneratorIndex.UNIQUE_NOTE_HASH);
+}
+/**
+ * Computes a siloed nullifier, given the contract address and the inner nullifier.
+ * A siloed nullifier effectively namespaces a nullifier to a specific contract.
+ * @param contract - The contract address.
+ * @param innerNullifier - The nullifier to silo.
+ * @returns A siloed nullifier.
+ */ export function siloNullifier(contract, innerNullifier) {
+    return poseidon2HashWithSeparator([
+        contract,
+        innerNullifier
+    ], GeneratorIndex.OUTER_NULLIFIER);
+}
+/**
+ * Computes a public data tree value ready for insertion.
+ * @param value - Raw public data tree value to hash into a tree-insertion-ready value.
+ * @returns Value hash into a tree-insertion-ready value.
+
+ */ export function computePublicDataTreeValue(value) {
+    return value;
+}
+/**
+ * Computes a public data tree index from contract address and storage slot.
+ * @param contractAddress - Contract where insertion is occurring.
+ * @param storageSlot - Storage slot where insertion is occurring.
+ * @returns Public data tree index computed from contract address and storage slot.
+
+ */ export function computePublicDataTreeLeafSlot(contractAddress, storageSlot) {
+    return poseidon2HashWithSeparator([
+        contractAddress,
+        storageSlot
+    ], GeneratorIndex.PUBLIC_LEAF_INDEX);
+}
+/**
+ * Computes the hash of a list of arguments.
+ * @param args - Arguments to hash.
+ * @returns Pedersen hash of the arguments.
+ */ export function computeVarArgsHash(args) {
+    if (args.length === 0) {
+        return Promise.resolve(Fr.ZERO);
+    }
+    return poseidon2HashWithSeparator(args, GeneratorIndex.FUNCTION_ARGS);
+}
+/**
+ * Computes a hash of a secret.
+ * @dev This function is used to generate secrets for the L1 to L2 message flow and for the TransparentNote.
+ * @param secret - The secret to hash (could be generated however you want e.g. `Fr.random()`)
+ * @returns The hash
+ */ export function computeSecretHash(secret) {
+    return poseidon2HashWithSeparator([
+        secret
+    ], GeneratorIndex.SECRET_HASH);
+}
+export async function computeL1ToL2MessageNullifier(contract, messageHash, secret) {
+    const innerMessageNullifier = await poseidon2HashWithSeparator([
+        messageHash,
+        secret
+    ], GeneratorIndex.MESSAGE_NULLIFIER);
+    return siloNullifier(contract, innerMessageNullifier);
+}
+/**
+ * Calculates a siloed hash of a scoped l2 to l1 message.
+ * @returns Fr containing 248 bits of information of sha256 hash.
+ */ export function siloL2ToL1Message(l2ToL1Message, version, chainId) {
+    if (l2ToL1Message.contractAddress.isZero()) {
+        return Fr.ZERO;
+    }
+    // Left-pad recipient to 32 bytes to match what the circuit is doing
+    // TODO: Only hash 20 bytes for l2l1 recipient everywhere.
+    const paddedRecipient = Buffer.alloc(32);
+    l2ToL1Message.message.recipient.toBuffer().copy(paddedRecipient, 12);
+    const preimage = Buffer.concat([
+        l2ToL1Message.contractAddress.toBuffer(),
+        version.toBuffer(),
+        paddedRecipient,
+        chainId.toBuffer(),
+        l2ToL1Message.message.content.toBuffer()
+    ]);
+    return Fr.fromBuffer(sha256Trunc(preimage));
+}
+export async function siloContractClassLog(log, contract) {
+    const innerLog = log.clone();
+    if (contract.isZero()) {
+        return innerLog;
+    }
+    innerLog.fields[0] = await poseidon2Hash([
+        contract,
+        innerLog.fields[0]
+    ]);
+    return innerLog;
+}

package/dest/hash/index.d.ts

@@ -0,0 +1,3 @@
+export * from './hash.js';
+export * from './map_slot.js';
+//# sourceMappingURL=index.d.ts.map

package/dest/hash/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/hash/index.ts"],"names":[],"mappings":"AAAA,cAAc,WAAW,CAAC;AAC1B,cAAc,eAAe,CAAC"}

package/dest/hash/index.js

@@ -0,0 +1,2 @@
+export * from './hash.js';
+export * from './map_slot.js';

package/dest/hash/map_slot.d.ts

@@ -0,0 +1,12 @@
+import type { Fr } from '@aztec/foundation/fields';
+/**
+ * Computes the resulting storage slot for an entry in a map.
+ * @param mapSlot - The slot of the map within state.
+ * @param key - The key of the map.
+ * @returns The slot in the contract storage where the value is stored.
+ */
+export declare function deriveStorageSlotInMap(mapSlot: Fr | bigint, key: {
+    /** Convert key to a field. */
+    toField: () => Fr;
+}): Promise<Fr>;
+//# sourceMappingURL=map_slot.d.ts.map

package/dest/hash/map_slot.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"map_slot.d.ts","sourceRoot":"","sources":["../../src/hash/map_slot.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,EAAE,EAAE,MAAM,0BAA0B,CAAC;AAEnD;;;;;GAKG;AACH,wBAAgB,sBAAsB,CACpC,OAAO,EAAE,EAAE,GAAG,MAAM,EACpB,GAAG,EAAE;IACH,8BAA8B;IAC9B,OAAO,EAAE,MAAM,EAAE,CAAC;CACnB,GACA,OAAO,CAAC,EAAE,CAAC,CAEb"}

package/dest/hash/map_slot.js

@@ -0,0 +1,12 @@
+import { poseidon2Hash } from '@aztec/foundation/crypto';
+/**
+ * Computes the resulting storage slot for an entry in a map.
+ * @param mapSlot - The slot of the map within state.
+ * @param key - The key of the map.
+ * @returns The slot in the contract storage where the value is stored.
+ */ export function deriveStorageSlotInMap(mapSlot, key) {
+    return poseidon2Hash([
+        mapSlot,
+        key.toField()
+    ]);
+}

package/dest/interfaces/archiver.d.ts

@@ -0,0 +1,9 @@
+import type { ApiSchemaFor } from '@aztec/foundation/schemas';
+import { type L2BlockSource } from '../block/l2_block_source.js';
+import type { NullifierWithBlockSource } from '../block/nullifier_with_block_source.js';
+import { type ContractDataSource } from '../contract/index.js';
+import type { L1ToL2MessageSource } from '../messaging/l1_to_l2_message_source.js';
+import type { L2LogsSource } from './l2_logs_source.js';
+export type ArchiverApi = Omit<L2BlockSource & L2LogsSource & ContractDataSource & L1ToL2MessageSource & NullifierWithBlockSource, 'start' | 'stop'>;
+export declare const ArchiverApiSchema: ApiSchemaFor<ArchiverApi>;
+//# sourceMappingURL=archiver.d.ts.map

package/dest/interfaces/archiver.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"archiver.d.ts","sourceRoot":"","sources":["../../src/interfaces/archiver.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,2BAA2B,CAAC;AAM9D,OAAO,EAAE,KAAK,aAAa,EAAgB,MAAM,6BAA6B,CAAC;AAC/E,OAAO,KAAK,EAAE,wBAAwB,EAAE,MAAM,yCAAyC,CAAC;AACxF,OAAO,EAEL,KAAK,kBAAkB,EAGxB,MAAM,sBAAsB,CAAC;AAK9B,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,yCAAyC,CAAC;AAOnF,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,qBAAqB,CAAC;AAExD,MAAM,MAAM,WAAW,GAAG,IAAI,CAC5B,aAAa,GAAG,YAAY,GAAG,kBAAkB,GAAG,mBAAmB,GAAG,wBAAwB,EAClG,OAAO,GAAG,MAAM,CACjB,CAAC;AAEF,eAAO,MAAM,iBAAiB,EAAE,YAAY,CAAC,WAAW,CAmDvD,CAAC"}

package/dest/interfaces/archiver.js

@@ -0,0 +1,52 @@
+import { z } from 'zod';
+import { inBlockSchemaFor } from '../block/in_block.js';
+import { L2Block } from '../block/l2_block.js';
+import { L2TipsSchema } from '../block/l2_block_source.js';
+import { ContractClassPublicSchema, ContractInstanceWithAddressSchema, PublicFunctionSchema } from '../contract/index.js';
+import { L1RollupConstantsSchema } from '../epoch-helpers/index.js';
+import { LogFilterSchema } from '../logs/log_filter.js';
+import { PrivateLog } from '../logs/private_log.js';
+import { TxScopedL2Log } from '../logs/tx_scoped_l2_log.js';
+import { optional, schemas } from '../schemas/schemas.js';
+import { BlockHeader } from '../tx/block_header.js';
+import { TxEffect } from '../tx/tx_effect.js';
+import { TxHash } from '../tx/tx_hash.js';
+import { TxReceipt } from '../tx/tx_receipt.js';
+import { GetContractClassLogsResponseSchema, GetPublicLogsResponseSchema } from './get_logs_response.js';
+export const ArchiverApiSchema = {
+    getRollupAddress: z.function().args().returns(schemas.EthAddress),
+    getRegistryAddress: z.function().args().returns(schemas.EthAddress),
+    getBlockNumber: z.function().args().returns(schemas.Integer),
+    getProvenBlockNumber: z.function().args().returns(schemas.Integer),
+    getProvenL2EpochNumber: z.function().args().returns(schemas.Integer.optional()),
+    getBlock: z.function().args(schemas.Integer).returns(L2Block.schema.optional()),
+    getBlockHeader: z.function().args(z.union([
+        schemas.Integer,
+        z.literal('latest')
+    ])).returns(BlockHeader.schema.optional()),
+    getBlocks: z.function().args(schemas.Integer, schemas.Integer, optional(z.boolean())).returns(z.array(L2Block.schema)),
+    getTxEffect: z.function().args(TxHash.schema).returns(inBlockSchemaFor(TxEffect.schema).optional()),
+    getSettledTxReceipt: z.function().args(TxHash.schema).returns(TxReceipt.schema.optional()),
+    getL2SlotNumber: z.function().args().returns(schemas.BigInt),
+    getL2EpochNumber: z.function().args().returns(schemas.BigInt),
+    getBlocksForEpoch: z.function().args(schemas.BigInt).returns(z.array(L2Block.schema)),
+    isEpochComplete: z.function().args(schemas.BigInt).returns(z.boolean()),
+    getL2Tips: z.function().args().returns(L2TipsSchema),
+    getPrivateLogs: z.function().args(z.number(), z.number()).returns(z.array(PrivateLog.schema)),
+    getLogsByTags: z.function().args(z.array(schemas.Fr)).returns(z.array(z.array(TxScopedL2Log.schema))),
+    findNullifiersIndexesWithBlock: z.function().args(z.number(), z.array(schemas.Fr)).returns(z.array(optional(inBlockSchemaFor(schemas.BigInt)))),
+    getPublicLogs: z.function().args(LogFilterSchema).returns(GetPublicLogsResponseSchema),
+    getContractClassLogs: z.function().args(LogFilterSchema).returns(GetContractClassLogsResponseSchema),
+    getPublicFunction: z.function().args(schemas.AztecAddress, schemas.FunctionSelector).returns(PublicFunctionSchema.optional()),
+    getContractClass: z.function().args(schemas.Fr).returns(ContractClassPublicSchema.optional()),
+    getBytecodeCommitment: z.function().args(schemas.Fr).returns(schemas.Fr),
+    getContract: z.function().args(schemas.AztecAddress).returns(ContractInstanceWithAddressSchema.optional()),
+    getContractClassIds: z.function().args().returns(z.array(schemas.Fr)),
+    registerContractFunctionSignatures: z.function().args(schemas.AztecAddress, z.array(z.string())).returns(z.void()),
+    getL1ToL2Messages: z.function().args(schemas.BigInt).returns(z.array(schemas.Fr)),
+    getL1ToL2MessageIndex: z.function().args(schemas.Fr).returns(schemas.BigInt.optional()),
+    // TODO(#10007): Remove this method
+    addContractClass: z.function().args(ContractClassPublicSchema).returns(z.void()),
+    getContractFunctionName: z.function().args(schemas.AztecAddress, schemas.FunctionSelector).returns(optional(z.string())),
+    getL1Constants: z.function().args().returns(L1RollupConstantsSchema)
+};