Struct TransactionBuilder

pub struct TransactionBuilder { /* private fields */ }

A builder for creating transactions. Use resolve to finalize the transaction data.

Implementations

impl TransactionBuilder

A transaction builder to build transactions.

pub fn new() -> Self

Create a new transaction builder and initialize its elements to default.

pub fn input(&mut self, i: impl Into<Input>) -> Argument

Make a value available to the transaction as an input.

pub fn gas(&self) -> Argument

Return the argument to be the gas object.

pub fn add_gas_objects<O, I>(&mut self, gas: I)

where O: Into<Input>, I: IntoIterator<Item = O>,

Add one or more gas objects to use to pay for the transaction.

Most commonly the gas can be passed as a reference to an owned/immutable Object, or can created using one of the of the constructors of the unresolved::Input enum, e.g., unresolved::Input::owned.

pub fn set_gas_budget(&mut self, budget: u64)

Set the gas budget for the transaction.

pub fn set_gas_price(&mut self, price: u64)

Set the gas price for the transaction.

pub fn set_sender(&mut self, sender: Address)

Set the sender of the transaction.

pub fn set_sponsor(&mut self, sponsor: Address)

Set the sponsor of the transaction.

pub fn set_expiration(&mut self, epoch: u64)

Set the expiration of the transaction to be a specific epoch.

pub fn move_call( &mut self, function: Function, arguments: Vec<Argument>, ) -> Argument

Call a Move function with the given arguments.

• function is a structured representation of a package::module::function argument, optionally with type arguments.

The return value is a result argument that can be used in subsequent commands. If the move call returns multiple results, you can access them using the [Argument::nested] method.

pub fn transfer_objects(&mut self, objects: Vec<Argument>, address: Argument)

Transfer a list of objects to the given address, without producing any result.

pub fn split_coins( &mut self, coin: Argument, amounts: Vec<Argument>, ) -> Argument

Split a coin by the provided amounts, returning multiple results (as many as there are amounts). To access the results, use the [Argument::nested] method to access the desired coin by its index.

pub fn merge_coins(&mut self, coin: Argument, coins_to_merge: Vec<Argument>)

Merge a list of coins into a single coin, without producing any result.

pub fn make_move_vec( &mut self, type_: Option<TypeTag>, elements: Vec<Argument>, ) -> Argument

Make a move vector from a list of elements. If the elements are not objects, or the vector is empty, a type must be supplied. It returns the Move vector as an argument, that can be used in subsequent commands.

pub fn publish( &mut self, modules: Vec<Vec<u8>>, dependencies: Vec<ObjectId>, ) -> Argument

Publish a list of modules with the given dependencies. The result is the 0x2::package::UpgradeCap Move type. Note that the upgrade capability needs to be handled after this call:

• transfer it to the transaction sender or another address
• burn it
• wrap it for access control
• discard the it to make a package immutable

The arguments required for this command are:

• modules: is the modules’ bytecode to be published
• dependencies: is the list of IDs of the transitive dependencies of the package

pub fn upgrade( &mut self, modules: Vec<Vec<u8>>, dependencies: Vec<ObjectId>, package: ObjectId, ticket: Argument, ) -> Argument

Upgrade a Move package.

• modules: is the modules’ bytecode for the modules to be published
• dependencies: is the list of IDs of the transitive dependencies of the package to be upgraded
• package: is the ID of the current package being upgraded
• ticket: is the upgrade ticket

To get the ticket, you have to call the 0x2::package::authorize_upgrade function, and pass the package ID, the upgrade policy, and package digest.

Examples:

Upgrade a package with some pre-known data.

use sui_graphql_client::Client;
use sui_sdk_types::unresolved;
use sui_transaction_builder::TransactionBuilder;
use sui_transaction_builder::Function;

let mut tx = TransactionBuilder::new();
let package_id = "0x...".parse().unwrap();
let upgrade_cap = tx.input(unresolved::Input::by_id("0x...".parse().unwrap()));
let upgrade_policy = tx.input(Serialized(&0u8));
// the digest of the new package that was compiled
let package_digest: &[u8] = &[
     68, 89, 156, 51, 190, 35, 155, 216, 248, 49, 135, 170, 106, 42, 190, 4, 208, 59, 155,
     89, 74, 63, 70, 95, 207, 78, 227, 22, 136, 146, 57, 79,
];
let digest_arg = tx.input(Serialized(&package_digest));

// we need this ticket to authorize the upgrade
let upgrade_ticket = tx.move_call(
    Function::new(
      "0x2".parse().unwrap(),
       "package".parse().unwrap(),
       "authorize_upgrade".parse().unwrap(),
       vec![],
    ),
    vec![upgrade_cap, upgrade_policy, digest_arg],
  );
// now we can upgrade the package
let upgrade_receipt = tx.upgrade(
     updated_modules,
     deps,
     package_id,
     upgrade_ticket,
);

// commit the upgrade
tx.move_call(
     Function::new(
        "0x2".parse().unwrap(),
        "package".parse().unwrap(),
        "commit_upgrade".parse().unwrap(),
        vec![],
    ),
    vec![upgrade_cap, upgrade_receipt],
);

let client = Client::new_mainnet();
let tx = tx.resolve(&client)?;

pub fn finish(self) -> Result<Transaction, Error>

Assuming everything is resolved, convert this transaction into the resolved form. Returns a [Transaction] if successful, or an Error if not.

Trait Implementations

impl Clone for TransactionBuilder

fn clone(&self) -> TransactionBuilder

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for TransactionBuilder

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

Formats the value using the given formatter.

impl Default for TransactionBuilder

fn default() -> TransactionBuilder

Returns the “default value” for a type.