Struct Libraries 

pub struct Libraries { /* private fields */ }

External libraries deployed once per distinct bytecode, and the address each linked contract substitutes for its placeholders.

Solidity links a contract against a library by <File>.sol:<Name>, so two files that each carry a copy of the same library — bb writes RelationsLib and ZKTranscriptLib into every verifier it generates — link by different keys. This groups those keys by the hash of the library’s creation code, and that hash is the whole rule: identical bytecode is one deployment, and every contract whose artifact names that bytecode links against it; bytecode that differs is a deployment of its own. No version, release or list of which libraries happen to match takes part — a bb or solc bump that leaves a library identical keeps it shared, one that changes it separates it, and a contract can only ever link the bytes it was compiled against.

Each distinct library lands through the canonical CREATE2 deployer under LIBRARY_SALT, so its address is library_address of its creation code: the same on every chain, and already holding code on a re-run, which is how a library that is deployed is found and reused with no record kept off chain. The deployer is installed if the chain lacks it, as ensure_factory does; there is no plain-CREATE fallback, because an address that is not a function of the code is one a later run cannot find.

Creation code rather than runtime code, because it is what the chain receives and what the address derives from, and equal creation code is equal runtime code.

Implementations

impl Libraries

pub async fn deploy<P: Provider>( provider: &P, artifacts: &Artifacts, contracts: &[(&str, &str)], sender: Option<Address>, ) -> Result<Self>

Deploy every library the (file, contract) artifacts link, once per distinct bytecode, skipping any whose code is already at its address. A library that links libraries of its own has those resolved first. Contracts that link nothing contribute nothing and cost nothing.

sender opts into explicit nonce management (see deploy_contract_from).

pub fn address(&self, file: &str, library: &str) -> Option<Address>

The address <file>.sol:<library> links against, if it is in the set.

pub fn distinct(&self) -> impl Iterator<Item = (B256, Address)> + '_

Every distinct library, as the hash of its creation code and its address. One entry per deployment, however many files name it.

pub fn deployed(&self) -> impl Iterator<Item = Address> + '_

The addresses this call sent a deploy for, as opposed to found.

pub fn link( &self, artifacts: &Artifacts, file: &str, contract: &str, ) -> Result<Bytes>

The creation bytecode of <file>.sol:<contract> with every library it links substituted from the set. Pure: no transaction. Errors when the artifact names a library the set does not hold.

Trait Implementations

impl Clone for Libraries

fn clone(&self) -> Libraries

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for Libraries

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Default for Libraries

fn default() -> Libraries

Returns the “default value” for a type.

impl Eq for Libraries

impl PartialEq for Libraries

fn eq(&self, other: &Libraries) -> bool

Equality operator ==.

fn ne(&self, other: &Rhs) -> bool

Inequality operator !=.

impl StructuralPartialEq for Libraries