@aztec/ethereum 0.0.1-commit.fce3e4f → 0.0.1-commit.fffb133c

package/dest/deploy_l1_contract.js

@@ -0,0 +1,312 @@
+import { EthAddress } from '@aztec/foundation/eth-address';
+import { createLogger } from '@aztec/foundation/log';
+import { DateProvider } from '@aztec/foundation/timer';
+import { concatHex, encodeAbiParameters, encodeDeployData, getContractAddress, numberToHex, padHex } from 'viem';
+import { DEPLOYER_ADDRESS } from './deploy_aztec_l1_contracts.js';
+import { RegisterNewRollupVersionPayloadArtifact } from './l1_artifacts.js';
+import { getL1TxUtilsConfigEnvVars } from './l1_tx_utils/config.js';
+import { createL1TxUtilsFromViemWallet } from './l1_tx_utils/factory.js';
+import { formatViemError } from './utils.js';
+export class L1Deployer {
+    client;
+    acceleratedTestDeployments;
+    logger;
+    txUtilsConfig;
+    createVerificationJson;
+    salt;
+    txHashes;
+    l1TxUtils;
+    verificationRecords;
+    constructor(client, maybeSalt, dateProvider = new DateProvider(), acceleratedTestDeployments = false, logger = createLogger('L1Deployer'), txUtilsConfig, createVerificationJson = false){
+        this.client = client;
+        this.acceleratedTestDeployments = acceleratedTestDeployments;
+        this.logger = logger;
+        this.txUtilsConfig = txUtilsConfig;
+        this.createVerificationJson = createVerificationJson;
+        this.txHashes = [];
+        this.verificationRecords = [];
+        this.salt = maybeSalt ? padHex(numberToHex(maybeSalt), {
+            size: 32
+        }) : undefined;
+        this.l1TxUtils = createL1TxUtilsFromViemWallet(this.client, {
+            logger: this.logger,
+            dateProvider
+        }, {
+            ...this.txUtilsConfig,
+            debugMaxGasLimit: acceleratedTestDeployments
+        });
+    }
+    async deploy(params, args, opts = {}) {
+        this.logger.debug(`Deploying ${params.name} contract`, {
+            args
+        });
+        try {
+            const { txHash, address, deployedLibraries, existed } = await deployL1Contract(this.client, params.contractAbi, params.contractBytecode, args ?? [], {
+                salt: this.salt,
+                libraries: params.libraries,
+                logger: this.logger,
+                l1TxUtils: this.l1TxUtils,
+                acceleratedTestDeployments: this.acceleratedTestDeployments,
+                gasLimit: opts.gasLimit,
+                noSimulation: opts.noSimulation
+            });
+            if (txHash) {
+                this.txHashes.push(txHash);
+            }
+            this.logger.debug(`Deployed ${params.name} at ${address}`, {
+                args
+            });
+            if (this.createVerificationJson) {
+                // Encode constructor args for verification
+                let constructorArgsHex = '0x';
+                try {
+                    const abiItem = params.contractAbi.find((x)=>x && x.type === 'constructor');
+                    const inputDefs = abiItem && Array.isArray(abiItem.inputs) ? abiItem.inputs : [];
+                    constructorArgsHex = inputDefs.length > 0 ? encodeAbiParameters(inputDefs, args ?? []) : '0x';
+                } catch  {
+                    constructorArgsHex = '0x';
+                }
+                this.verificationRecords.push({
+                    name: params.name,
+                    address: address.toString(),
+                    constructorArgsHex,
+                    libraries: deployedLibraries ?? []
+                });
+            }
+            return {
+                address,
+                existed
+            };
+        } catch (error) {
+            throw new Error(`Failed to deploy ${params.name}`, {
+                cause: formatViemError(error)
+            });
+        }
+    }
+    async waitForDeployments() {
+        if (this.acceleratedTestDeployments) {
+            this.logger.info('Accelerated test deployments - skipping waiting for deployments');
+            return;
+        }
+        if (this.txHashes.length === 0) {
+            return;
+        }
+        this.logger.verbose(`Waiting for ${this.txHashes.length} transactions to be mined`, {
+            txHashes: this.txHashes
+        });
+        const receipts = await Promise.all(this.txHashes.map((txHash)=>this.client.waitForTransactionReceipt({
+                hash: txHash
+            })));
+        const failed = receipts.filter((r)=>r.status !== 'success');
+        if (failed.length > 0) {
+            throw new Error(`Some deployment txs have failed: ${failed.map((f)=>f.transactionHash).join(', ')}`);
+        }
+        this.logger.info('All transactions mined successfully', {
+            txHashes: this.txHashes
+        });
+    }
+    sendTransaction(tx, options) {
+        return this.l1TxUtils.sendTransaction(tx, options).then(({ txHash, state })=>({
+                txHash,
+                gasLimit: state.gasLimit,
+                gasPrice: state.gasPrice
+            }));
+    }
+}
+/**
+ * Helper function to deploy ETH contracts.
+ * @param walletClient - A viem WalletClient.
+ * @param publicClient - A viem PublicClient.
+ * @param abi - The ETH contract's ABI (as abitype's Abi).
+ * @param bytecode  - The ETH contract's bytecode.
+ * @param args - Constructor arguments for the contract.
+ * @param salt - Optional salt for CREATE2 deployment (does not wait for deployment tx to be mined if set, does not send tx if contract already exists).
+ * @returns The ETH address the contract was deployed to.
+ */ export async function deployL1Contract(extendedClient, abi, bytecode, args = [], opts = {}) {
+    let txHash = undefined;
+    let resultingAddress = undefined;
+    const deployedLibraries = [];
+    const { salt: saltFromOpts, libraries, logger, gasLimit, acceleratedTestDeployments, noSimulation } = opts;
+    let { l1TxUtils } = opts;
+    if (!l1TxUtils) {
+        const config = getL1TxUtilsConfigEnvVars();
+        l1TxUtils = createL1TxUtilsFromViemWallet(extendedClient, {
+            logger
+        }, {
+            ...config,
+            debugMaxGasLimit: acceleratedTestDeployments
+        });
+    }
+    if (libraries) {
+        // Note that this does NOT work well for linked libraries having linked libraries.
+        // Verify that all link references have corresponding code
+        for(const linkRef in libraries.linkReferences){
+            for(const contractName in libraries.linkReferences[linkRef]){
+                if (!libraries.libraryCode[contractName]) {
+                    throw new Error(`Missing library code for ${contractName}`);
+                }
+            }
+        }
+        const replacements = {};
+        const libraryTxs = [];
+        for(const libraryName in libraries?.libraryCode){
+            const lib = libraries.libraryCode[libraryName];
+            const { libraries: _libraries, ...optsWithoutLibraries } = opts;
+            const { address, txHash } = await deployL1Contract(extendedClient, lib.contractAbi, lib.contractBytecode, [], optsWithoutLibraries);
+            // Log deployed library name and address for easier verification/triage
+            logger?.verbose(`Linked library deployed`, {
+                library: libraryName,
+                address: address.toString(),
+                txHash
+            });
+            if (txHash) {
+                libraryTxs.push(txHash);
+            }
+            // Try to find the source file for this library from linkReferences
+            let fileNameForLibrary = undefined;
+            for(const fileName in libraries.linkReferences){
+                if (libraries.linkReferences[fileName] && libraries.linkReferences[fileName][libraryName]) {
+                    fileNameForLibrary = fileName;
+                    break;
+                }
+            }
+            if (fileNameForLibrary) {
+                deployedLibraries.push({
+                    file: fileNameForLibrary,
+                    contract: libraryName,
+                    address: address.toString()
+                });
+            }
+            for(const linkRef in libraries.linkReferences){
+                for(const contractName in libraries.linkReferences[linkRef]){
+                    // If the library name matches the one we just deployed, we replace it.
+                    if (contractName !== libraryName) {
+                        continue;
+                    }
+                    // We read the first instance to figure out what we are to replace.
+                    const start = 2 + 2 * libraries.linkReferences[linkRef][contractName][0].start;
+                    const length = 2 * libraries.linkReferences[linkRef][contractName][0].length;
+                    const toReplace = bytecode.slice(start, start + length);
+                    replacements[toReplace] = address;
+                }
+            }
+        }
+        const escapeRegExp = (s)=>{
+            return s.replace(/[.*+?^${}()|[\]\\]/g, '\\$&'); // Escape special characters
+        };
+        for(const toReplace in replacements){
+            const replacement = replacements[toReplace].toString().slice(2);
+            bytecode = bytecode.replace(new RegExp(escapeRegExp(toReplace), 'g'), replacement);
+        }
+        // Reth fails gas estimation if the deployed contract attempts to call a library that is not yet deployed,
+        // so we wait for all library deployments to be mined before deploying the contract.
+        // However, if we are in fast mode or using debugMaxGasLimit, we will skip simulation, so we can skip waiting.
+        if (libraryTxs.length > 0 && !acceleratedTestDeployments) {
+            logger?.verbose(`Awaiting for linked libraries to be deployed`);
+            await Promise.all(libraryTxs.map((txHash)=>extendedClient.waitForTransactionReceipt({
+                    hash: txHash
+                })));
+        } else {
+            logger?.verbose(`Skipping waiting for linked libraries to be deployed ${acceleratedTestDeployments ? '(accelerated test deployments)' : ''}`);
+        }
+    }
+    let existed = false;
+    if (saltFromOpts) {
+        logger?.info(`Deploying contract with salt ${saltFromOpts}`);
+        const { address, paddedSalt: salt, calldata } = getExpectedAddress(abi, bytecode, args, saltFromOpts);
+        resultingAddress = address;
+        const existing = await extendedClient.getCode({
+            address: resultingAddress
+        });
+        if (existing === undefined || existing === '0x') {
+            if (!noSimulation) {
+                try {
+                    await l1TxUtils.simulate({
+                        to: DEPLOYER_ADDRESS,
+                        data: concatHex([
+                            salt,
+                            calldata
+                        ]),
+                        gas: gasLimit
+                    });
+                } catch (err) {
+                    logger?.error(`Failed to simulate deployment tx using universal deployer`, err);
+                    await l1TxUtils.simulate({
+                        to: null,
+                        data: encodeDeployData({
+                            abi,
+                            bytecode,
+                            args
+                        }),
+                        gas: gasLimit
+                    });
+                }
+            }
+            const res = await l1TxUtils.sendTransaction({
+                to: DEPLOYER_ADDRESS,
+                data: concatHex([
+                    salt,
+                    calldata
+                ])
+            }, {
+                gasLimit
+            });
+            txHash = res.txHash;
+            logger?.verbose(`Deployed contract with salt ${salt} to address ${resultingAddress} in tx ${txHash}.`);
+        } else {
+            logger?.verbose(`Skipping existing deployment of contract with salt ${salt} to address ${resultingAddress}`);
+            existed = true;
+        }
+    } else {
+        const deployData = encodeDeployData({
+            abi,
+            bytecode,
+            args
+        });
+        const { receipt } = await l1TxUtils.sendAndMonitorTransaction({
+            to: null,
+            data: deployData
+        }, {
+            gasLimit
+        });
+        txHash = receipt.transactionHash;
+        resultingAddress = receipt.contractAddress;
+        if (!resultingAddress) {
+            throw new Error(`No contract address found in receipt: ${JSON.stringify(receipt, (_, val)=>typeof val === 'bigint' ? String(val) : val)}`);
+        }
+    }
+    return {
+        address: EthAddress.fromString(resultingAddress),
+        txHash,
+        deployedLibraries,
+        existed
+    };
+}
+export function getExpectedAddress(abi, bytecode, args, salt) {
+    const paddedSalt = padHex(salt, {
+        size: 32
+    });
+    const calldata = encodeDeployData({
+        abi,
+        bytecode,
+        args
+    });
+    const address = getContractAddress({
+        from: DEPLOYER_ADDRESS,
+        salt: paddedSalt,
+        bytecode: calldata,
+        opcode: 'CREATE2'
+    });
+    return {
+        address,
+        paddedSalt,
+        calldata
+    };
+}
+export const deployUpgradePayload = async (deployer, addresses)=>{
+    const payloadAddress = (await deployer.deploy(RegisterNewRollupVersionPayloadArtifact, [
+        addresses.registryAddress.toString(),
+        addresses.rollupAddress.toString()
+    ])).address;
+    return payloadAddress;
+};

package/dest/forwarder_proxy.d.ts

@@ -0,0 +1,32 @@
+import { EthAddress } from '@aztec/foundation/eth-address';
+import type { Logger } from '@aztec/foundation/log';
+import type { ExtendedViemWalletClient } from './types.js';
+export declare const FORWARDER_SOLIDITY_SOURCE = "\ncontract ForwarderProxy {\n  function forward(address target, bytes calldata data) external payable returns (bytes memory) {\n    (bool success, bytes memory result) = target.call{value: msg.value}(data);\n    require(success, \"call failed\");\n    return result;\n  }\n}";
+export declare const FORWARDER_ABI: readonly [{
+    readonly inputs: readonly [{
+        readonly internalType: "address";
+        readonly name: "target";
+        readonly type: "address";
+    }, {
+        readonly internalType: "bytes";
+        readonly name: "data";
+        readonly type: "bytes";
+    }];
+    readonly name: "forward";
+    readonly outputs: readonly [{
+        readonly internalType: "bytes";
+        readonly name: "";
+        readonly type: "bytes";
+    }];
+    readonly stateMutability: "payable";
+    readonly type: "function";
+}];
+export declare const FORWARDER_BYTECODE: `0x${string}`;
+/**
+ * Deploys the forwarder proxy contract to L1.
+ * @param client - The L1 client to use for deployment
+ * @param logger - Optional logger
+ * @returns The deployed forwarder contract address
+ */
+export declare function deployForwarderProxy(client: ExtendedViemWalletClient, logger?: Logger): Promise<EthAddress>;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZm9yd2FyZGVyX3Byb3h5LmQudHMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi9zcmMvZm9yd2FyZGVyX3Byb3h5LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUNBLE9BQU8sRUFBRSxVQUFVLEVBQUUsTUFBTSwrQkFBK0IsQ0FBQztBQUMzRCxPQUFPLEtBQUssRUFBRSxNQUFNLEVBQUUsTUFBTSx1QkFBdUIsQ0FBQztBQVFwRCxPQUFPLEtBQUssRUFBRSx3QkFBd0IsRUFBRSxNQUFNLFlBQVksQ0FBQztBQUUzRCxlQUFPLE1BQU0seUJBQXlCLHVSQU9wQyxDQUFDO0FBRUgsZUFBTyxNQUFNLGFBQWE7Ozs7Ozs7Ozs7Ozs7Ozs7OztFQXlCaEIsQ0FBQztBQUVYLGVBQU8sTUFBTSxrQkFBa0IsZUFDbzZELENBQUM7QUFRcDhEOzs7OztHQUtHO0FBQ0gsd0JBQXNCLG9CQUFvQixDQUFDLE1BQU0sRUFBRSx3QkFBd0IsRUFBRSxNQUFNLENBQUMsRUFBRSxNQUFNLEdBQUcsT0FBTyxDQUFDLFVBQVUsQ0FBQyxDQVVqSCJ9

package/dest/forwarder_proxy.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"forwarder_proxy.d.ts","sourceRoot":"","sources":["../src/forwarder_proxy.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,UAAU,EAAE,MAAM,+BAA+B,CAAC;AAC3D,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,uBAAuB,CAAC;AAQpD,OAAO,KAAK,EAAE,wBAAwB,EAAE,MAAM,YAAY,CAAC;AAE3D,eAAO,MAAM,yBAAyB,uRAOpC,CAAC;AAEH,eAAO,MAAM,aAAa;;;;;;;;;;;;;;;;;;EAyBhB,CAAC;AAEX,eAAO,MAAM,kBAAkB,eACo6D,CAAC;AAQp8D;;;;;GAKG;AACH,wBAAsB,oBAAoB,CAAC,MAAM,EAAE,wBAAwB,EAAE,MAAM,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC,UAAU,CAAC,CAUjH"}

package/dest/forwarder_proxy.js

@@ -0,0 +1,93 @@
+/* eslint-disable no-console */ import { createLogger } from '@aztec/foundation/log';
+import { DateProvider } from '@aztec/foundation/timer';
+import { extractChain } from 'viem';
+import { anvil, mainnet, sepolia } from 'viem/chains';
+import { L1Deployer } from './deploy_l1_contract.js';
+export const FORWARDER_SOLIDITY_SOURCE = `
+contract ForwarderProxy {
+  function forward(address target, bytes calldata data) external payable returns (bytes memory) {
+    (bool success, bytes memory result) = target.call{value: msg.value}(data);
+    require(success, "call failed");
+    return result;
+  }
+}`;
+export const FORWARDER_ABI = [
+    {
+        inputs: [
+            {
+                internalType: 'address',
+                name: 'target',
+                type: 'address'
+            },
+            {
+                internalType: 'bytes',
+                name: 'data',
+                type: 'bytes'
+            }
+        ],
+        name: 'forward',
+        outputs: [
+            {
+                internalType: 'bytes',
+                name: '',
+                type: 'bytes'
+            }
+        ],
+        stateMutability: 'payable',
+        type: 'function'
+    }
+];
+export const FORWARDER_BYTECODE = '0x6080604052348015600e575f5ffd5b506103bf8061001c5f395ff3fe60806040526004361061001d575f3560e01c80636fadcf7214610021575b5f5ffd5b61003b600480360381019061003691906101d0565b610051565b604051610048919061029d565b60405180910390f35b60605f5f8573ffffffffffffffffffffffffffffffffffffffff1634868660405161007d9291906102f9565b5f6040518083038185875af1925050503d805f81146100b7576040519150601f19603f3d011682016040523d82523d5f602084013e6100bc565b606091505b509150915081610101576040517f08c379a00000000000000000000000000000000000000000000000000000000081526004016100f89061036b565b60405180910390fd5b80925050509392505050565b5f5ffd5b5f5ffd5b5f73ffffffffffffffffffffffffffffffffffffffff82169050919050565b5f61013e82610115565b9050919050565b61014e81610134565b8114610158575f5ffd5b50565b5f8135905061016981610145565b92915050565b5f5ffd5b5f5ffd5b5f5ffd5b5f5f83601f8401126101905761018f61016f565b5b8235905067ffffffffffffffff8111156101ad576101ac610173565b5b6020830191508360018202830111156101c9576101c8610177565b5b9250929050565b5f5f5f604084860312156101e7576101e661010d565b5b5f6101f48682870161015b565b935050602084013567ffffffffffffffff81111561021557610214610111565b5b6102218682870161017b565b92509250509250925092565b5f81519050919050565b5f82825260208201905092915050565b8281835e5f83830152505050565b5f601f19601f8301169050919050565b5f61026f8261022d565b6102798185610237565b9350610289818560208601610247565b61029281610255565b840191505092915050565b5f6020820190508181035f8301526102b58184610265565b905092915050565b5f81905092915050565b828183375f83830152505050565b5f6102e083856102bd565b93506102ed8385846102c7565b82840190509392505050565b5f6103058284866102d5565b91508190509392505050565b5f82825260208201905092915050565b7f63616c6c206661696c65640000000000000000000000000000000000000000005f82015250565b5f610355600b83610311565b915061036082610321565b602082019050919050565b5f6020820190508181035f83015261038281610349565b905091905056fea26469706673582212209a1c8cf638cf1569450a731ef9457b862f9e153b0a46e5555429bcf4dffd999564736f6c634300081e0033';
+const FORWARDER_ARTIFACT = {
+    name: 'Forwarder',
+    contractAbi: FORWARDER_ABI,
+    contractBytecode: FORWARDER_BYTECODE
+};
+/**
+ * Deploys the forwarder proxy contract to L1.
+ * @param client - The L1 client to use for deployment
+ * @param logger - Optional logger
+ * @returns The deployed forwarder contract address
+ */ export async function deployForwarderProxy(client, logger) {
+    const log = logger ?? createLogger('ethereum:forwarder');
+    const nonce = await client.getTransactionCount({
+        address: client.account.address
+    });
+    const deployer = new L1Deployer(client, nonce, new DateProvider(), false, log, undefined, false);
+    log.info('Deploying forwarder proxy contract');
+    const deployment = await deployer.deploy(FORWARDER_ARTIFACT, []);
+    log.info(`Forwarder proxy deployed at ${deployment.address.toString()}`);
+    return deployment.address;
+}
+/**
+ * Main function for deploying the forwarder proxy from command line.
+ * Usage: node forwarder_proxy.js <private_key> <rpc_url>
+ */ async function main() {
+    const args = process.argv.slice(2);
+    if (args.length < 3) {
+        console.error('Usage: node forwarder_proxy.js <private_key> <rpc_url> <chain_id>');
+        process.exit(1);
+    }
+    const [privateKey, rpcUrl, chainId] = args;
+    // Dynamic import to avoid pulling in dependencies at module load time
+    const { createExtendedL1Client } = await import('./client.js');
+    const client = createExtendedL1Client([
+        rpcUrl
+    ], privateKey.startsWith('0x') ? privateKey : `0x${privateKey}`, extractChain({
+        chains: [
+            mainnet,
+            sepolia,
+            anvil
+        ],
+        id: parseInt(chainId)
+    }));
+    const address = await deployForwarderProxy(client);
+    console.log(`Forwarder proxy deployed at: ${address.toString()}`);
+}
+// Only run main if this is the entry point
+if (import.meta.url === `file://${process.argv[1]}`) {
+    main().catch((err)=>{
+        console.error('Failed to deploy forwarder proxy:', err);
+        process.exit(1);
+    });
+}

package/dest/generated/l1-contracts-defaults.d.ts

@@ -0,0 +1,30 @@
+/** Default L1 contracts configuration values from network-defaults.yml */
+export declare const l1ContractsDefaultEnv: {
+    readonly ETHEREUM_SLOT_DURATION: 12;
+    readonly AZTEC_SLOT_DURATION: 36;
+    readonly AZTEC_EPOCH_DURATION: 32;
+    readonly AZTEC_TARGET_COMMITTEE_SIZE: 48;
+    readonly AZTEC_LAG_IN_EPOCHS_FOR_VALIDATOR_SET: 2;
+    readonly AZTEC_LAG_IN_EPOCHS_FOR_RANDAO: 2;
+    readonly AZTEC_ACTIVATION_THRESHOLD: 100000000000000000000;
+    readonly AZTEC_EJECTION_THRESHOLD: 50000000000000000000;
+    readonly AZTEC_LOCAL_EJECTION_THRESHOLD: 98000000000000000000;
+    readonly AZTEC_EXIT_DELAY_SECONDS: 172800;
+    readonly AZTEC_INBOX_LAG: 1;
+    readonly AZTEC_PROOF_SUBMISSION_EPOCHS: 1;
+    readonly AZTEC_MANA_TARGET: 100000000;
+    readonly AZTEC_PROVING_COST_PER_MANA: 100;
+    readonly AZTEC_INITIAL_ETH_PER_FEE_ASSET: 10000000;
+    readonly AZTEC_SLASHER_FLAVOR: "tally";
+    readonly AZTEC_SLASHING_ROUND_SIZE_IN_EPOCHS: 4;
+    readonly AZTEC_SLASHING_LIFETIME_IN_ROUNDS: 5;
+    readonly AZTEC_SLASHING_EXECUTION_DELAY_IN_ROUNDS: 0;
+    readonly AZTEC_SLASHING_OFFSET_IN_ROUNDS: 2;
+    readonly AZTEC_SLASHING_VETOER: "0x0000000000000000000000000000000000000000";
+    readonly AZTEC_SLASHING_DISABLE_DURATION: 432000;
+    readonly AZTEC_SLASH_AMOUNT_SMALL: 10000000000000000000;
+    readonly AZTEC_SLASH_AMOUNT_MEDIUM: 20000000000000000000;
+    readonly AZTEC_SLASH_AMOUNT_LARGE: 50000000000000000000;
+    readonly AZTEC_GOVERNANCE_PROPOSER_ROUND_SIZE: 300;
+};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibDEtY29udHJhY3RzLWRlZmF1bHRzLmQudHMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvZ2VuZXJhdGVkL2wxLWNvbnRyYWN0cy1kZWZhdWx0cy50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFHQSwwRUFBMEU7QUFDMUUsZUFBTyxNQUFNLHFCQUFxQjs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7O0NBMkJ4QixDQUFDIn0=

package/dest/generated/l1-contracts-defaults.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"l1-contracts-defaults.d.ts","sourceRoot":"","sources":["../../src/generated/l1-contracts-defaults.ts"],"names":[],"mappings":"AAGA,0EAA0E;AAC1E,eAAO,MAAM,qBAAqB;;;;;;;;;;;;;;;;;;;;;;;;;;;CA2BxB,CAAC"}

package/dest/generated/l1-contracts-defaults.js

@@ -0,0 +1,30 @@
+// Auto-generated from spartan/environments/network-defaults.yml
+// Do not edit manually - run yarn generate to regenerate
+/** Default L1 contracts configuration values from network-defaults.yml */ export const l1ContractsDefaultEnv = {
+    ETHEREUM_SLOT_DURATION: 12,
+    AZTEC_SLOT_DURATION: 36,
+    AZTEC_EPOCH_DURATION: 32,
+    AZTEC_TARGET_COMMITTEE_SIZE: 48,
+    AZTEC_LAG_IN_EPOCHS_FOR_VALIDATOR_SET: 2,
+    AZTEC_LAG_IN_EPOCHS_FOR_RANDAO: 2,
+    AZTEC_ACTIVATION_THRESHOLD: 100000000000000000000,
+    AZTEC_EJECTION_THRESHOLD: 50000000000000000000,
+    AZTEC_LOCAL_EJECTION_THRESHOLD: 98000000000000000000,
+    AZTEC_EXIT_DELAY_SECONDS: 172800,
+    AZTEC_INBOX_LAG: 1,
+    AZTEC_PROOF_SUBMISSION_EPOCHS: 1,
+    AZTEC_MANA_TARGET: 100000000,
+    AZTEC_PROVING_COST_PER_MANA: 100,
+    AZTEC_INITIAL_ETH_PER_FEE_ASSET: 10000000,
+    AZTEC_SLASHER_FLAVOR: 'tally',
+    AZTEC_SLASHING_ROUND_SIZE_IN_EPOCHS: 4,
+    AZTEC_SLASHING_LIFETIME_IN_ROUNDS: 5,
+    AZTEC_SLASHING_EXECUTION_DELAY_IN_ROUNDS: 0,
+    AZTEC_SLASHING_OFFSET_IN_ROUNDS: 2,
+    AZTEC_SLASHING_VETOER: '0x0000000000000000000000000000000000000000',
+    AZTEC_SLASHING_DISABLE_DURATION: 432000,
+    AZTEC_SLASH_AMOUNT_SMALL: 10000000000000000000,
+    AZTEC_SLASH_AMOUNT_MEDIUM: 20000000000000000000,
+    AZTEC_SLASH_AMOUNT_LARGE: 50000000000000000000,
+    AZTEC_GOVERNANCE_PROPOSER_ROUND_SIZE: 300
+};