Transaction Lifecycle

impl SuiGasStatus {
    pub fn new(
        gas_budget: u64,
        gas_price: u64,
        reference_gas_price: u64,
        config: &ProtocolConfig,
    ) -> SuiResult<Self> {
        // gas price must be bigger or equal to reference gas price
        if gas_price < reference_gas_price {
            return Err(UserInputError::GasPriceUnderRGP {
                gas_price,
                reference_gas_price,
            }
            .into());
        }
        if check_for_gas_price_too_high(config.gas_model_version())
            && gas_price >= config.max_gas_price()
        {
            return Err(UserInputError::GasPriceTooHigh {
                max_gas_price: config.max_gas_price(),
            }
            .into());
        }
        Ok(Self::V2(SuiGasStatusV2::new_with_budget(
            gas_budget,
            gas_price,
            reference_gas_price,
            config,
        )))
    }
}

pub trait SuiGasStatusAPI {
    fn is_unmetered(&self) -> bool;
    fn move_gas_status(&self) -> &GasStatus;
    fn move_gas_status_mut(&mut self) -> &mut GasStatus;
    fn bucketize_computation(&mut self, aborted: Option<bool>) -> Result<(), ExecutionError>;
    fn summary(&self) -> GasCostSummary;
    fn gas_budget(&self) -> u64;
    fn gas_price(&self) -> u64;
    fn reference_gas_price(&self) -> u64;
    fn storage_gas_units(&self) -> u64;
    fn storage_rebate(&self) -> u64;
    fn unmetered_storage_rebate(&self) -> u64;
    fn gas_used(&self) -> u64;
    fn charge_storage_read(&mut self, size: usize) -> Result<(), ExecutionError>;
    fn charge_publish_package(&mut self, size: usize) -> Result<(), ExecutionError>;
    fn track_storage_mutation(
        &mut self,
        object_id: ObjectID,
        new_size: usize,
        storage_rebate: u64,
    ) -> u64;
    fn charge_storage_and_rebate(&mut self) -> Result<(), ExecutionError>;
}

/// Summary of the charges in a transaction.
/// Storage is charged independently of computation.
/// There are 3 parts to the storage charges:
/// `storage_cost`: it is the charge of storage at the time the transaction is executed.
///                 The cost of storage is the number of bytes of the objects being mutated
///                 multiplied by a variable storage cost per byte
/// `storage_rebate`: this is the amount a user gets back when manipulating an object.
///                   The `storage_rebate` is the `storage_cost` for an object minus fees.
/// `non_refundable_storage_fee`: not all the value of the object storage cost is
///                               given back to user and there is a small fraction that
///                               is kept by the system. This value tracks that charge.
///
/// When looking at a gas cost summary the amount charged to the user is
/// `computation_cost + storage_cost - storage_rebate`
/// and that is the amount that is deducted from the gas coins.

Total Gas = computation_cost + storage_cost - storage_rebate

where:
  computation_cost = instructions_executed * computation_gas_price
  storage_cost = sum(new_object_sizes * storage_price_per_byte)
  storage_rebate = sum(old_object_rebates) - non_refundable_fee

pub struct ChangeEpoch {
    /// The next (to become) epoch ID
    pub epoch: EpochId,
    /// The protocol version in effect in the new epoch
    pub protocol_version: ProtocolVersion,
    /// The total amount of gas charged for storage during the epoch
    pub storage_charge: u64,
    /// The total amount of gas charged for computation during the epoch
    pub computation_charge: u64,
    /// The amount of storage rebate refunded to the txn senders
    pub storage_rebate: u64,
    /// The non-refundable storage fee
    pub non_refundable_storage_fee: u64,
    /// Unix timestamp when epoch started
    pub epoch_start_timestamp_ms: u64,
}

const txResult = await client.getTransactionBlock({
    digest: 'transaction_digest',
    options: {
        showEffects: true,
        showEvents: true,
        showObjectChanges: true,
    },
});

console.log('Status:', txResult.effects.status);
console.log('Gas used:', txResult.effects.gasUsed);

const tx = new Transaction();
// ... build transaction

const result = await client.signAndExecuteTransaction({
    transaction: tx,
    signer: keypair,
    options: {
        showEffects: true,
        showObjectChanges: true,
    },
});

// Transaction is already finalized here
console.log('Digest:', result.digest);