Precompiles reference

ArbOS provides child chain-specific precompiles with methods smart contracts can call the same way they can solidity functions. This reference page exhaustively documents the specific calls ArbOS makes available through precompiles. For a more conceptual description of what precompiles are and how they work, please refer to the precompiles conceptual page.

This reference page is divided into two sections. The first one lists all precompiles in a summary table with links to the reference of the specific precompile, along with the address where they live, their purpose and links to the go implementation and solidity interface. The second one details the methods available in each precompile with links to the specific implementation.

General information of precompiles

This section is divided into two tables. We first list precompiles we expect users to most often use, and then the rest of precompiles. However, both tables display the same information: name and purpose of the precompile, address, and links to the solidity interface and the go implementation.

Common precompiles

Precompile	Address	Solidity interface	Go implementation	Purpose
ArbAggregator	`0x6d`	Interface	Implementation	Configuring transaction aggregation
ArbGasInfo	`0x6c`	Interface	Implementation	Info about gas pricing
ArbRetryableTx	`0x6e`	Interface	Implementation	Managing retryables
ArbSys	`0x64`	Interface	Implementation	System-level functionality
ArbWasm	`0x71`	Interface	Implementation	Manages Stylus contracts
ArbWasmCache	`0x72`	Interface	Implementation	Manages Stylus cache

Other precompiles

Precompile	Address	Solidity interface	Go implementation	Purpose
ArbAddressTable	`0x66`	Interface	Implementation	Supporting compression of addresses
ArbBLS	-	-	-	Disabled (Former registry of BLS public keys)
ArbDebug	`0xff`	Interface	Implementation	Testing tools
ArbFunctionTable	`0x68`	Interface	Implementation	No longer used
ArbInfo	`0x65`	Interface	Implementation	Info about accounts
ArbOwner	`0x70`	Interface	Implementation	Chain administration, callable only by chain owner
ArbOwnerPublic	`0x6b`	Interface	Implementation	Info about chain owners
ArbosTest	`0x69`	Interface	Implementation	No longer used
ArbStatistics	`0x6f`	Interface	Implementation	Info about the pre-Nitro state

Precompiles reference

`ArbAddressTable`

ArbAddressTable (Interface | Implementation) provides the ability to create short-hands for commonly used accounts.

Precompile address: 0x0000000000000000000000000000000000000066

Method	Solidity interface	Go implementation	Description
`addressExists()`	Interface	Implementation	AddressExists checks if an address exists in the table
`compress()`	Interface	Implementation	Compress and returns the bytes that represent the address
`decompress()`	Interface	Implementation	Decompress the compressed bytes at the given offset with those of the corresponding account
`lookup()`	Interface	Implementation	Lookup the index of an address in the table
`lookupIndex()`	Interface	Implementation	LookupIndex for an address in the table by index
`register()`	Interface	Implementation	Register adds an account to the table, shrinking its compressed representation
`size()`	Interface	Implementation	Size gets the number of addresses in the table

`ArbAggregator`

ArbAggregator (Interface | Implementation) provides aggregators and their users methods for configuring how they participate in parent chain aggregation. Arbitrum One's default aggregator is the Sequencer, which a user will prefer unless SetPreferredAggregator is invoked to change it.

Compression ratios are measured in basis points. Methods that are checkmarked are access-controlled and will revert if not called by the aggregator, its fee collector, or a chain owner.

Precompile address: 0x000000000000000000000000000000000000006D

Method	Solidity interface	Go implementation	Description
⚠️`getPreferredAggregator()`	Interface	Implementation	Deprecated: Do not use this method.
⚠️`getDefaultAggregator()`	Interface	Implementation	Deprecated: Do not use this method.
`getBatchPosters()`	Interface	Implementation	GetBatchPosters gets the addresses of all current batch posters
`addBatchPoster()`	Interface	Implementation	Adds additional batch poster address
`getFeeCollector()`	Interface	Implementation	GetFeeCollector gets a batch poster's fee collector
`setFeeCollector(address batchPoster, address newFeeCollector)`	Interface	Implementation	SetFeeCollector sets a batch poster's fee collector (caller must be the batch poster, its fee collector, or an owner)
⚠️`getTxBaseFee()`	Interface	Implementation	Deprecated: always returns zero
⚠️`setTxBaseFee(address aggregator, uint256 feeInL1Gas)`	Interface	Implementation	Deprecated: no-op

Note: methods marked with ⚠️ are deprecated and their use is not supported.

`ArbBLS`

Disabled

This precompile has been disabled. It previously provided a registry of BLS public keys for accounts.

`ArbDebug`

ArbDebug (Interface | Implementation) provides mechanisms useful for testing. The methods of ArbDebug are only available for chains with the AllowDebugPrecompiles chain parameter set. Otherwise, calls to this precompile will revert.

Precompile address: 0x00000000000000000000000000000000000000ff

Method	Solidity interface	Go implementation	Description
`becomeChainOwner()`	Interface	Implementation	Caller becomes a chain owner
`overwriteContractCode()`	Interface	Implementation	Overwrite an existing contract's code
`events(bool flag, bytes32 value)`	Interface	Implementation	Emits events with values based on the args provided
`eventsView()`	Interface	Implementation	Tries (and fails) to emit logs in a view context
`customRevert()`	Interface	Implementation	Throws a custom error
`panic()`	Interface	Implementation	Halts the chain by panicking in the STF
`legacyError()`	Interface	Implementation	Throws a hardcoded error

Event	Solidity interface	Go implementation	Description
`Basic`	Interface	Implementation	Emitted in `Events` for testing
`Mixed`	Interface	Implementation	Emitted in `Events` for testing
`Store`	Interface	Implementation	Never emitted (used for testing log sizes)

`ArbFunctionTable`

ArbFunctionTable (Interface | Implementation) provides aggregators the ability to manage function tables, to enable one form of transaction compression. The Nitro aggregator implementation does not use these, so these methods have been stubbed and their effects disabled. They are kept for backwards compatibility.

Precompile address: 0x0000000000000000000000000000000000000068

Method	Solidity interface	Go implementation	Description
`upload()`	Interface	Implementation	Upload does nothing
`size()`	Interface	Implementation	Size returns the empty table's size, which is 0
`get(address addr, uint256 index)`	Interface	Implementation	Get reverts since the table is empty

`ArbGasInfo`

ArbGasInfo (Interface | Implementation) provides insight into the cost of using the chain. These methods have been adjusted to account for Nitro's heavy use of calldata compression. Of note to end-users, we no longer make a distinction between non-zero and zero-valued calldata bytes.

Precompile address: 0x000000000000000000000000000000000000006C

Method	Solidity interface	Go implementation	Description
`getPricesInWeiWithAggregator()`	Interface	Implementation	GetPricesInWeiWithAggregator gets prices in wei when using the provided aggregator
`getPricesInWei()`	Interface	Implementation	GetPricesInWei gets prices in wei when using the caller's preferred aggregator
`getPricesInArbGasWithAggregator()`	Interface	Implementation	GetPricesInArbGasWithAggregator gets prices in ArbGas when using the provided aggregator
`getPricesInArbGas()`	Interface	Implementation	GetPricesInArbGas gets prices in ArbGas when using the caller's preferred aggregator
`getGasAccountingParams()`	Interface	Implementation	GetGasAccountingParams gets the rollup's speed limit, pool size, and block gas limit
`getMaxTxGasLimit()`	Interface	Implementation	GetMaxTxGasLimit gets the max tx gas limit
`getMinimumGasPrice()`	Interface	Implementation	GetMinimumGasPrice gets the minimum gas price needed for a transaction to succeed
`getL1BaseFeeEstimate()`	Interface	Implementation	GetL1BaseFeeEstimate gets the current estimate of the L1 basefee
`getL1BaseFeeEstimateInertia()`	Interface	Implementation	GetL1BaseFeeEstimateInertia gets how slowly ArbOS updates its estimate of the L1 basefee
`getL1RewardRate()`	Interface	Implementation	GetL1RewardRate gets the L1 pricer reward rate
`getL1RewardRecipient()`	Interface	Implementation	GetL1RewardRecipient gets the L1 pricer reward recipient
`getL1GasPriceEstimate()`	Interface	Implementation	GetL1GasPriceEstimate gets the current estimate of the L1 basefee
`getCurrentTxL1GasFees()`	Interface	Implementation	GetCurrentTxL1GasFees gets the fee in wei paid to the batch poster for posting this tx
`getGasBacklog()`	Interface	Implementation	GetGasBacklog gets the backlogged amount of gas burnt in excess of the speed limit
`getPricingInertia()`	Interface	Implementation	GetPricingInertia gets how slowly ArbOS updates the L2 basefee in response to backlogged gas
`getGasBacklogTolerance()`	Interface	Implementation	GetGasBacklogTolerance gets the forgivable amount of backlogged gas ArbOS will ignore when raising the basefee
`getL1PricingSurplus()`	Interface	Implementation	GetL1PricingSurplus gets the surplus of funds for L1 batch posting payments (may be negative)
`getPerBatchGasCharge()`	Interface	Implementation	GetPerBatchGasCharge gets the base charge (in L1 gas) attributed to each data batch in the calldata pricer
`getAmortizedCostCapBips()`	Interface	Implementation	GetAmortizedCostCapBips gets the cost amortization cap in basis points
`getL1FeesAvailable()`	Interface	Implementation	GetL1FeesAvailable gets the available funds from L1 fees
`getL1PricingEquilibrationUnits()`	Interface	Implementation	GetL1PricingEquilibrationUnits gets the equilibration units parameter for L1 price adjustment algorithm (Available since ArbOS 20)
`getLastL1PricingUpdateTime()`	Interface	Implementation	GetLastL1PricingUpdateTime gets the last time the L1 calldata pricer was updated (Available since ArbOS 20)
`getL1PricingFundsDueForRewards()`	Interface	Implementation	GetL1PricingFundsDueForRewards gets the amount of L1 calldata payments due for rewards (per the L1 reward rate) (Available since ArbOS 20)
`getL1PricingUnitsSinceUpdate()`	Interface	Implementation	GetL1PricingUnitsSinceUpdate gets the amount of L1 calldata posted since the last update (Available since ArbOS 20)
`getLastL1PricingSurplus()`	Interface	Implementation	GetLastL1PricingSurplus gets the L1 pricing surplus as of the last update (may be negative) (Available since ArbOS 20)
`getMaxBlockGasLimit()`	Interface	Implementation	GetMaxBlockGasLimit gets the maximum block gas limit
`getGasPricingConstraints()`	Interface	Implementation	GetGasPricingConstraints gets the current gas pricing constraints used by the Multi-Constraint Pricer.

`ArbInfo`

ArbInfo (Interface | Implementation) provides the ability to lookup basic info about accounts and contracts.

Precompile address: 0x0000000000000000000000000000000000000065

Method	Solidity interface	Go implementation	Description
`getBalance()`	Interface	Implementation	GetBalance retrieves an account's balance
`getCode()`	Interface	Implementation	GetCode retrieves a contract's deployed code

`ArbosTest`

ArbosTest (Interface | Implementation) provides a method of burning arbitrary amounts of gas, which exists for historical reasons. In Classic, ArbosTest had additional methods only the zero address could call. These have been removed since users don't use them and calls to missing methods revert.

Precompile address: 0x0000000000000000000000000000000000000069

Method	Solidity interface	Go implementation	Description
`burnArbGas()`	Interface	Implementation	BurnArbGas unproductively burns the amount of L2 ArbGas

`ArbOwner`

ArbOwner (Interface | Implementation) provides owners with tools for managing the rollup. Calls by non-owners will always revert.

Most of Arbitrum Classic's owner methods have been removed since they no longer make sense in Nitro:

What were once chain parameters are now parts of ArbOS's state, and those that remain are set at genesis.
ArbOS upgrades happen with the rest of the system rather than being independent
Exemptions to address aliasing are no longer offered. Exemptions were intended to support backward compatibility for contracts deployed before aliasing was introduced, but no exemptions were ever requested.

Precompile address: 0x0000000000000000000000000000000000000070

Method	Solidity interface	Go implementation	Description
`addChainOwner()`	Interface	Implementation	AddChainOwner adds account as a chain owner
`removeChainOwner()`	Interface	Implementation	RemoveChainOwner removes account from the list of chain owners
`isChainOwner()`	Interface	Implementation	IsChainOwner checks if the account is a chain owner
`getAllChainOwners()`	Interface	Implementation	GetAllChainOwners retrieves the list of chain owners
`setNativeTokenManagementFrom()`	Interface	Implementation	future.
`addNativeTokenOwner()`	Interface	Implementation	AddNativeTokenOwner adds account as a native token owner
`removeNativeTokenOwner()`	Interface	Implementation	RemoveNativeTokenOwner removes account from the list of native token owners
`isNativeTokenOwner()`	Interface	Implementation	IsNativeTokenOwner checks if the account is a native token owner
`getAllNativeTokenOwners()`	Interface	Implementation	GetAllNativeTokenOwners retrieves the list of native token owners
`setL1BaseFeeEstimateInertia()`	Interface	Implementation	SetL1BaseFeeEstimateInertia sets how slowly ArbOS updates its estimate of the L1 basefee
`setL2BaseFee()`	Interface	Implementation	SetL2BaseFee sets the L2 gas price directly, bypassing the pool calculus
`setMinimumL2BaseFee()`	Interface	Implementation	SetMinimumL2BaseFee sets the minimum base fee needed for a transaction to succeed
`setSpeedLimit()`	Interface	Implementation	SetSpeedLimit sets the computational speed limit for the chain
`setMaxTxGasLimit()`	Interface	Implementation	SetMaxTxGasLimit sets the maximum size a tx can be
`setMaxBlockGasLimit()`	Interface	Implementation	SetMaxBlockGasLimit sets the maximum size a block can be
`setL2GasPricingInertia()`	Interface	Implementation	SetL2GasPricingInertia sets the L2 gas pricing inertia
`setL2GasBacklogTolerance()`	Interface	Implementation	SetL2GasBacklogTolerance sets the L2 gas backlog tolerance
`getNetworkFeeAccount()`	Interface	Implementation	GetNetworkFeeAccount gets the network fee collector
`getInfraFeeAccount()`	Interface	Implementation	GetInfraFeeAccount gets the infrastructure fee collector
`setNetworkFeeAccount()`	Interface	Implementation	SetNetworkFeeAccount sets the network fee collector to the new network fee account
`setInfraFeeAccount()`	Interface	Implementation	SetInfraFeeAccount sets the infra fee collector to the new network fee account
`scheduleArbOSUpgrade(uint64 newVersion, uint64 timestamp)`	Interface	Implementation	ScheduleArbOSUpgrade to the requested version at the requested timestamp
`setL1PricingEquilibrationUnits()`	Interface	Implementation	Sets equilibration units parameter for L1 price adjustment algorithm
`setL1PricingInertia()`	Interface	Implementation	Sets inertia parameter for L1 price adjustment algorithm
`setL1PricingRewardRecipient()`	Interface	Implementation	Sets reward recipient address for L1 price adjustment algorithm
`setL1PricingRewardRate()`	Interface	Implementation	Sets reward amount for L1 price adjustment algorithm, in wei per unit
`setL1PricePerUnit()`	Interface	Implementation	Set how much ArbOS charges per L1 gas spent on transaction data.
`setParentGasFloorPerToken()`	Interface	Implementation	Set how much L1 charges per non-zero byte of calldata
`setPerBatchGasCharge()`	Interface	Implementation	Sets the base charge (in L1 gas) attributed to each data batch in the calldata pricer
`setBrotliCompressionLevel()`	Interface	Implementation	Sets the Brotli compression level used for fast compression (default level is 1)
`setAmortizedCostCapBips()`	Interface	Implementation	Sets the cost amortization cap in basis points
`releaseL1PricerSurplusFunds()`	Interface	Implementation	Releases surplus funds from L1PricerFundsPoolAddress for use
`setInkPrice()`	Interface	Implementation	Sets the amount of ink 1 gas buys
`setWasmMaxStackDepth()`	Interface	Implementation	Sets the maximum depth (in wasm words) a wasm stack may grow
`setWasmFreePages()`	Interface	Implementation	Gets the number of free wasm pages a tx gets
`setWasmPageGas()`	Interface	Implementation	Sets the base cost of each additional wasm page
`setWasmPageLimit()`	Interface	Implementation	Sets the initial number of pages a wasm may allocate
`setWasmMaxSize()`	Interface	Implementation	decompression.
`setWasmMinInitGas(uint8 gas, uint16 cached)`	Interface	Implementation	Sets the minimum costs to invoke a program
`setWasmInitCostScalar()`	Interface	Implementation	Sets the linear adjustment made to program init costs
`setWasmExpiryDays()`	Interface	Implementation	Sets the number of days after which programs deactivate
`setWasmKeepaliveDays()`	Interface	Implementation	Sets the age a program must be to perform a keepalive
`setWasmBlockCacheSize()`	Interface	Implementation	Sets the number of extra programs ArbOS caches during a given block
`addWasmCacheManager()`	Interface	Implementation	Adds account as a wasm cache manager
`removeWasmCacheManager()`	Interface	Implementation	Removes account from the list of wasm cache managers
`setChainConfig()`	Interface	Implementation	Sets serialized chain config in ArbOS state
`setCalldataPriceIncrease()`	Interface	Implementation	(EIP-7623)
`setGasBacklog()`	Interface	Implementation	SetGasBacklog sets the L2 gas backlog directly (used by single-constraint pricing model only)
`setGasPricingConstraints()`	Interface	Implementation	SetGasPricingConstraints sets the gas pricing constraints used by the multi-constraint pricing model

Event	Solidity interface	Go implementation	Description
`OwnerActs`	Interface	Implementation	/ Emitted when a successful call is made to this precompile

`ArbOwnerPublic`

ArbOwnerPublic (Interface | Implementation) provides non-owners with info about the current chain owners.

Precompile address: 0x000000000000000000000000000000000000006b

Method	Solidity interface	Go implementation	Description
`isChainOwner()`	Interface	Implementation	IsChainOwner checks if the user is a chain owner
`rectifyChainOwner()`	Interface	Implementation	RectifyChainOwner checks if the account is a chain owner (Available since ArbOS 11)
`getAllChainOwners()`	Interface	Implementation	GetAllChainOwners retrieves the list of chain owners
`getNativeTokenManagementFrom()`	Interface	Implementation	native token management becomes enabled
`isNativeTokenOwner()`	Interface	Implementation	IsNativeTokenOwner checks if the account is a native token owner
`getAllNativeTokenOwners()`	Interface	Implementation	GetAllNativeTokenOwners retrieves the list of native token owners
`getNetworkFeeAccount()`	Interface	Implementation	GetNetworkFeeAccount gets the network fee collector
`getInfraFeeAccount()`	Interface	Implementation	GetInfraFeeAccount gets the infrastructure fee collector
`getBrotliCompressionLevel()`	Interface	Implementation	GetBrotliCompressionLevel gets the current brotli compression level used for fast compression
`getParentGasFloorPerToken()`	Interface	Implementation	Get how much L1 charges per non-zero byte of calldata
`getScheduledUpgrade()`	Interface	Implementation	Returns (0, 0, nil) if no ArbOS upgrade is scheduled.
`isCalldataPriceIncreaseEnabled()`	Interface	Implementation	(EIP-7623) is enabled

Event	Solidity interface	Go implementation	Description
`ChainOwnerRectified`	Interface	Implementation	Emitted when verifying a chain owner

`ArbRetryableTx`

ArbRetryableTx (Interface | Implementation) provides methods for managing retryables. The model has been adjusted for Nitro, most notably in terms of how retry transactions are scheduled. For more information on retryables, please see the retryable documentation.

Precompile address: 0x000000000000000000000000000000000000006E

Method	Solidity interface	Go implementation	Description
`redeem()`	Interface	Implementation	Redeem schedules an attempt to redeem the retryable, donating all of the call's gas to the redeem attempt
`getLifetime()`	Interface	Implementation	GetLifetime gets the default lifetime period a retryable has at creation
`getTimeout()`	Interface	Implementation	GetTimeout gets the timestamp for when ticket will expire
`keepalive()`	Interface	Implementation	Keepalive adds one lifetime period to the ticket's expiry
`getBeneficiary()`	Interface	Implementation	GetBeneficiary gets the beneficiary of the ticket
`cancel()`	Interface	Implementation	Cancel the ticket and refund its callvalue to its beneficiary
`getCurrentRedeemer()`	Interface	Implementation	Gets the redeemer of the current retryable redeem attempt
`submitRetryable()`	Interface	Implementation	Do not call. This method represents a retryable submission to aid explorers. Calling it will always revert.

Event	Solidity interface	Go implementation	Description
`TicketCreated`	Interface	Implementation	Emitted when creating a retryable
`LifetimeExtended`	Interface	Implementation	Emitted when extending a retryable's expiry date
`RedeemScheduled`	Interface	Implementation	Emitted when scheduling a retryable
`Canceled`	Interface	Implementation	Emitted when cancelling a retryable
`Redeemed`	Interface	Implementation	DEPRECATED in favour of new `RedeemScheduled` event after the nitro upgrade.

`ArbStatistics`

ArbStatistics (Interface | Implementation) provides statistics about the chain as of just before the Nitro upgrade. In Arbitrum Classic, this was how a user would get info such as the total number of accounts, but there are better ways to get that info in Nitro.

Precompile address: 0x000000000000000000000000000000000000006F

Method	Solidity interface	Go implementation	Description
`getStats()`	Interface	Implementation	GetStats returns the current block number and some statistics about the rollup's pre-Nitro state

`ArbSys`

ArbSys (Interface | Implementation) provides system-level functionality for interacting with the parent chain and understanding the call stack.

Precompile address: 0x0000000000000000000000000000000000000064

Method	Solidity interface	Go implementation	Description
`arbBlockNumber()`	Interface	Implementation	ArbBlockNumber gets the current L2 block number
`arbBlockHash()`	Interface	Implementation	ArbBlockHash gets the L2 block hash, if sufficiently recent
`arbChainID()`	Interface	Implementation	ArbChainID gets the rollup's unique chain identifier
`arbOSVersion()`	Interface	Implementation	ArbOSVersion gets the current ArbOS version
`getStorageGasAvailable()`	Interface	Implementation	GetStorageGasAvailable returns 0 since Nitro has no concept of storage gas
`isTopLevelCall()`	Interface	Implementation	IsTopLevelCall checks if the call is top-level (deprecated)
`mapL1SenderContractAddressToL2Alias()`	Interface	Implementation	MapL1SenderContractAddressToL2Alias gets the contract's L2 alias
`wasMyCallersAddressAliased()`	Interface	Implementation	WasMyCallersAddressAliased checks if the caller's caller was aliased
`myCallersAddressWithoutAliasing()`	Interface	Implementation	MyCallersAddressWithoutAliasing gets the caller's caller without any potential aliasing
`withdrawEth()`	Interface	Implementation	WithdrawEth send paid eth to the destination on L1
`sendTxToL1()`	Interface	Implementation	SendTxToL1 sends a transaction to L1, adding it to the outbox
`sendMerkleTreeState()`	Interface	Implementation	SendMerkleTreeState gets the root, size, and partials of the outbox Merkle tree state (caller must be the 0 address)

Event	Solidity interface	Go implementation	Description
`L2ToL1Tx`	Interface	Implementation	Logs a send transaction from L2 to L1, including data for outbox proving
`L2ToL1Transaction`	Interface	Implementation	DEPRECATED in favour of the new `L2ToL1Tx` event above after the nitro upgrade
`SendMerkleUpdate`	Interface	Implementation	Logs a new merkle branch needed for constructing outbox proofs

`ArbWasm`

ArbWasm (Interface | Implementation) provides helper methods for managing Stylus contracts

Precompile address: 0x0000000000000000000000000000000000000071

Method	Solidity interface	Go implementation	Description
`activateProgram()`	Interface	Implementation	Compile a wasm program with the latest instrumentation
`stylusVersion()`	Interface	Implementation	Gets the latest stylus version
`codehashVersion()`	Interface	Implementation	Gets the stylus version that program with codehash was most recently compiled with
`codehashKeepalive()`	Interface	Implementation	Extends a program's expiration date (reverts if too soon)
`codehashAsmSize()`	Interface	Implementation	Gets a program's asm size in bytes
`programVersion()`	Interface	Implementation	Gets the stylus version that program at addr was most recently compiled with
`programInitGas()`	Interface	Implementation	Gets the cost to invoke the program
`programMemoryFootprint()`	Interface	Implementation	Gets the footprint of program at addr
`programTimeLeft()`	Interface	Implementation	Gets returns the amount of time remaining until the program expires
`inkPrice()`	Interface	Implementation	Gets the amount of ink 1 gas buys
`maxStackDepth()`	Interface	Implementation	Gets the wasm stack size limit
`freePages()`	Interface	Implementation	Gets the number of free wasm pages a tx gets
`pageGas()`	Interface	Implementation	Gets the base cost of each additional wasm page
`pageRamp()`	Interface	Implementation	Gets the ramp that drives exponential memory costs
`pageLimit()`	Interface	Implementation	Gets the maximum initial number of pages a wasm may allocate
`minInitGas()`	Interface	Implementation	Gets the minimum costs to invoke a program
`initCostScalar()`	Interface	Implementation	Gets the linear adjustment made to program init costs
`expiryDays()`	Interface	Implementation	Gets the number of days after which programs deactivate
`keepaliveDays()`	Interface	Implementation	Gets the age a program must be to perform a keepalive
`blockCacheSize()`	Interface	Implementation	Gets the number of extra programs ArbOS caches during a given block.

Event	Solidity interface	Go implementation	Description
`ProgramActivated`	Interface	Implementation	Emitted when activating a WASM program
`ProgramLifetimeExtended`	Interface	Implementation	Emitted when extending the expiration date of a WASM program

`ArbWasmCache`

ArbWasmCache (Interface | Implementation) provides helper methods for managing Stylus cache

Precompile address: 0x0000000000000000000000000000000000000072

Method	Solidity interface	Go implementation	Description
`isCacheManager()`	Interface	Implementation	See if the user is a cache manager owner.
`allCacheManagers()`	Interface	Implementation	Retrieve all authorized address managers.
`cacheCodehash()`	Interface	Implementation	Deprecated: replaced with CacheProgram.
`cacheProgram()`	Interface	Implementation	Caches all programs with a codehash equal to the given address. Caller must be a cache manager or chain owner.
`evictCodehash()`	Interface	Implementation	Evicts all programs with the given codehash. Caller must be a cache manager or chain owner.
`codehashIsCached()`	Interface	Implementation	Gets whether a program is cached. Note that the program may be expired.

Event	Solidity interface	Go implementation	Description
`UpdateProgramCache`	Interface	Implementation	Emitted when caching a WASM program

General information of precompiles​

Common precompiles​

Other precompiles​

Precompiles reference​

ArbAddressTable​

ArbAggregator​

ArbBLS​

ArbDebug​

ArbFunctionTable​

ArbGasInfo​

ArbInfo​

ArbosTest​

ArbOwner​

ArbOwnerPublic​

ArbRetryableTx​

ArbStatistics​

ArbSys​

ArbWasm​

ArbWasmCache​

General information of precompiles

Common precompiles

Other precompiles

Precompiles reference

`ArbAddressTable`

`ArbAggregator`

`ArbBLS`

`ArbDebug`

`ArbFunctionTable`

`ArbGasInfo`

`ArbInfo`

`ArbosTest`

`ArbOwner`

`ArbOwnerPublic`

`ArbRetryableTx`

`ArbStatistics`

`ArbSys`

`ArbWasm`

`ArbWasmCache`