Struct Contract

pub struct Contract<Code> { /* private fields */ }

Represents a contract that can be deployed either directly (Contract::regular) or through a loader Contract::convert_to_loader. Provides the ability to calculate the ContractId (Contract::contract_id) without needing to deploy the contract. This struct also manages contract code updates with configurables (Contract::with_configurables) and can automatically load storage slots (via Contract::load_from).

Implementations

impl Contract<Regular>

pub fn with_code(self, code: Vec<u8>) -> Self

pub fn with_configurables(self, configurables: impl Into<Configurables>) -> Self

pub fn code(&self) -> Vec<u8>

pub fn contract_id(&self) -> ContractId

pub fn code_root(&self) -> Bytes32

pub fn state_root(&self) -> Bytes32

pub fn load_from( binary_filepath: impl AsRef<Path>, config: LoadConfiguration, ) -> Result<Contract<Regular>>

Loads a contract from a binary file. Salt and storage slots are loaded as well, depending on the configuration provided.

pub fn regular( code: Vec<u8>, salt: Salt, storage_slots: Vec<StorageSlot>, ) -> Contract<Regular>

Creates a regular contract with the given code, salt, and storage slots.

pub async fn deploy( self, account: &impl Account, tx_policies: TxPolicies, ) -> Result<Bech32ContractId>

Deploys a compiled contract to a running node. To deploy a contract, you need an account with enough assets to pay for deployment. This account will also receive the change.

pub async fn deploy_if_not_exists( self, account: &impl Account, tx_policies: TxPolicies, ) -> Result<Bech32ContractId>

Deploys a compiled contract to a running node if a contract with the corresponding ContractId doesn’t exist.

pub fn convert_to_loader( self, max_words_per_blob: usize, ) -> Result<Contract<Loader<BlobsNotUploaded>>>

Converts a regular contract into a loader contract, splitting the code into blobs.

pub async fn smart_deploy( self, account: &impl Account, tx_policies: TxPolicies, max_words_per_blob: usize, ) -> Result<Bech32ContractId>

Deploys the contract either as a regular contract or as a loader contract if it exceeds the size limit.

impl Contract<Loader<BlobsNotUploaded>>

pub fn code(&self) -> Vec<u8>

pub fn contract_id(&self) -> ContractId

pub fn code_root(&self) -> Bytes32

pub fn state_root(&self) -> Bytes32

pub fn loader_from_blobs( blobs: Vec<Blob>, salt: Salt, storage_slots: Vec<StorageSlot>, ) -> Result<Self>

Creates a loader contract for the code found in blobs. Calling deploy on this contract does two things:

1. Uploads the code blobs.
2. Deploys the loader contract.

The loader contract, when executed, will load all the given blobs into memory and delegate the call to the original contract code contained in the blobs.

pub fn blobs(&self) -> &[Blob]

pub fn blob_ids(&self) -> Vec<BlobId>

pub async fn upload_blobs( self, account: &impl Account, tx_policies: TxPolicies, ) -> Result<Contract<Loader<BlobsUploaded>>>

Uploads the blobs associated with this contract. Calling deploy on the result will only deploy the loader contract.

pub async fn deploy( self, account: &impl Account, tx_policies: TxPolicies, ) -> Result<Bech32ContractId>

Deploys the loader contract after uploading the code blobs.

pub async fn deploy_if_not_exists( self, account: &impl Account, tx_policies: TxPolicies, ) -> Result<Bech32ContractId>

Deploys the loader contract after uploading the code blobs, if there is no contract with this ContractId Already.

pub fn revert_to_regular(self) -> Contract<Regular>

Reverts the contract from a loader contract back to a regular contract.

impl Contract<Loader<BlobsUploaded>>

pub fn code(&self) -> Vec<u8>

pub fn contract_id(&self) -> ContractId

pub fn code_root(&self) -> Bytes32

pub fn state_root(&self) -> Bytes32

pub fn compute_roots(&self) -> (ContractId, Bytes32, Bytes32)

pub fn loader_from_blob_ids( blob_ids: Vec<BlobId>, salt: Salt, storage_slots: Vec<StorageSlot>, ) -> Result<Self>

Creates a loader contract using previously uploaded blobs.

The contract code has been uploaded in blobs with BlobIds specified in blob_ids. This will create a loader contract that, when deployed and executed, will load all the specified blobs into memory and delegate the call to the code contained in the blobs.

pub fn blob_ids(&self) -> &[BlobId]

pub async fn deploy( self, account: &impl Account, tx_policies: TxPolicies, ) -> Result<Bech32ContractId>

Deploys the loader contract.

pub async fn deploy_if_not_exists( self, account: &impl Account, tx_policies: TxPolicies, ) -> Result<Bech32ContractId>

impl<T> Contract<T>

pub fn salt(&self) -> Salt

pub fn with_salt(self, salt: impl Into<Salt>) -> Self

pub fn storage_slots(&self) -> &[StorageSlot]

pub fn with_storage_slots(self, storage_slots: Vec<StorageSlot>) -> Self

Trait Implementations

impl<Code: Clone> Clone for Contract<Code>

fn clone(&self) -> Contract<Code>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<Code: Debug> Debug for Contract<Code>

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

Formats the value using the given formatter.

impl<Code: PartialEq> PartialEq for Contract<Code>

fn eq(&self, other: &Contract<Code>) -> bool

Tests for self and other values to be equal, and is used by ==.

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

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<Code> StructuralPartialEq for Contract<Code>