suiptb

package
v0.1.0 Latest Latest
Warning

This package is not in the latest version of its module.

 Go to latest Published: Dec 16, 2024 License: Apache-2.0 Imports: 5 Imported by: 0

README

suiptb

The name suiptb stands for SUI Programmable Transaction Block. The users can build PTB with the ProgrammableTransactionBuilder in this package.

Documentation

Index

Constants

This section is empty.

Variables

View Source 
var (
	SuiSystemMut = CallArg{
		Object: &SuiSystemMutObj,
	}

	SuiSystemMutObj = ObjectArg{
		SharedObject: &SharedObjectArg{
			Id:                   sui.SuiObjectIdSystemState,
			InitialSharedVersion: sui.SuiSystemStateObjectSharedVersion,
			Mutable:              true,
		},
	}
)

Functions

This section is empty.

Types

type Argument 

type Argument struct {
	// The gas coin. The gas coin can only be used by-ref, except for with
	// `TransferObjects`, which can use it by-value.
	GasCoin *sui.EmptyEnum
	// One of the input objects or primitive values (from `ProgrammableTransaction` inputs)
	Input *uint16
	// The result of another transaction (from `ProgrammableTransaction` transactions)
	Result *uint16
	// Like a `Result` but it accesses a nested result. Currently, the only usage of this is to access a
	// value from a Move call with multiple return values.
	NestedResult *NestedResult
}

func (Argument) IsBcsEnum 

func (a Argument) IsBcsEnum()

type BuilderArg 

type BuilderArg struct {
	Object              *sui.ObjectId
	Pure                *[]uint8
	ForcedNonUniquePure *uint
}

type CallArg 

type CallArg struct {
	Pure   *[]byte
	Object *ObjectArg
}

func (CallArg) IsBcsEnum 

func (c CallArg) IsBcsEnum()

type ChangeEpoch 

type ChangeEpoch struct {
	Epoch                   sui.EpochId
	ProtocolVersion         sui.ProtocolVersion
	StorageCharge           uint64
	ComputationCharge       uint64
	StorageRebate           uint64
	NonRefundableStorageFee uint64
	EpochStartTimestampMs   uint64
	SystemPackages          []*struct {
		SequenceNumber sui.SequenceNumber
		Bytes          [][]uint8
		Objects        []*sui.ObjectId
	}
}

type CheckpointTimestamp 

type CheckpointTimestamp uint64

type Command 

type Command struct {
	MoveCall        *ProgrammableMoveCall
	TransferObjects *ProgrammableTransferObjects
	SplitCoins      *ProgrammableSplitCoins
	MergeCoins      *ProgrammableMergeCoins
	// `Publish` publishes a Move package. Returns the upgrade capability object.
	Publish *ProgrammablePublish
	// `MakeMoveVec` constructs a vector of objects that can be passed into a moveCall.
	// This is required as there’s no way to define a vector as an input.
	MakeMoveVec *ProgrammableMakeMoveVec
	// upgrades a Move package
	Upgrade *ProgrammableUpgrade
}

https://sdk.mystenlabs.com/typescript/transaction-building/basics#object-references https://docs.sui.io/concepts/transactions/prog-txn-blocks

func (Command) IsBcsEnum 

func (c Command) IsBcsEnum()

type ConsensusCommitPrologue 

type ConsensusCommitPrologue struct {
	Epoch             uint64
	Round             uint64
	CommitTimestampMs CheckpointTimestamp
}

type GasData 

type GasData struct {
	Payment []*sui.ObjectRef
	Owner   *sui.Address
	Price   uint64
	Budget  uint64
}

type GenesisObject 

type GenesisObject struct {
	RawObject *struct {
		Data  sui.Data
		Owner sui.Owner
	}
}

type GenesisTransaction 

type GenesisTransaction struct {
	Objects []GenesisObject
}

type NestedResult 

type NestedResult struct {
	Cmd    uint16 // command index
	Result uint16 // result index
}

type ObjectArg 

type ObjectArg struct {
	ImmOrOwnedObject *sui.ObjectRef
	SharedObject     *SharedObjectArg
	Receiving        *sui.ObjectRef
}

func (ObjectArg) IsBcsEnum 

func (o ObjectArg) IsBcsEnum()

type ProgrammableMakeMoveVec 

type ProgrammableMakeMoveVec struct {
	Type    *sui.TypeTag `bcs:"optional"`
	Objects []Argument
}

type ProgrammableMergeCoins 

type ProgrammableMergeCoins struct {
	Destination Argument
	Sources     []Argument
}

type ProgrammableMoveCall 

type ProgrammableMoveCall struct {
	Package       *sui.PackageId
	Module        sui.Identifier
	Function      sui.Identifier
	TypeArguments []sui.TypeTag
	Arguments     []Argument
}

type ProgrammablePublish 

type ProgrammablePublish struct {
	Modules      [][]byte
	Dependencies []*sui.ObjectId
}

type ProgrammableSplitCoins 

type ProgrammableSplitCoins struct {
	Coin    Argument
	Amounts []Argument
}

type ProgrammableTransaction 

type ProgrammableTransaction struct {
	Inputs   []CallArg
	Commands []Command
}

ProgrammableTransaction is the packed immediate transaction type which will be encoded into BCS format by 'NewTransactionData()' or 'NewTransactionDataAllowSponsor()'

type ProgrammableTransactionBuilder 

type ProgrammableTransactionBuilder struct {
	Inputs   *indexmap.IndexMap[BuilderArg, CallArg] //maybe has hash clash
	Commands []Command
}

ProgrammableTransactionBuilder calls 'Finish()' to be built into 'ProgrammableTransaction' for following encoding in BCS format

func NewTransactionDataTransactionBuilder 

func NewTransactionDataTransactionBuilder() *ProgrammableTransactionBuilder

func (*ProgrammableTransactionBuilder) Command 

func (p *ProgrammableTransactionBuilder) Command(command Command) Argument

Add command to `ProgrammableTransactionBuilder.Commands`, and return the result in `Argument` type

func (*ProgrammableTransactionBuilder) Finish 

func (p *ProgrammableTransactionBuilder) Finish() ProgrammableTransaction

func (*ProgrammableTransactionBuilder) ForceSeparatePure 

func (p *ProgrammableTransactionBuilder) ForceSeparatePure(value any) (Argument, error)

func (*ProgrammableTransactionBuilder) Input 

func (p *ProgrammableTransactionBuilder) Input(callArg CallArg) (Argument, error)

developers should only use `Pure()`, `MustPure()` and `Obj()` to create PTB Arguments `Input()` is a function for internal usage TODO add explanation for `Input()`

func (*ProgrammableTransactionBuilder) MakeObjVec 

func (p *ProgrammableTransactionBuilder) MakeObjVec(objs []ObjectArg) (Argument, error)

func (*ProgrammableTransactionBuilder) MoveCall 

func (p *ProgrammableTransactionBuilder) MoveCall(
	packageId *sui.PackageId,
	module sui.Identifier,
	function sui.Identifier,
	typeArguments []sui.TypeTag,
	callArgs []CallArg,
) error

construct `move_call` with argument `CallArg` type

func (*ProgrammableTransactionBuilder) MustForceSeparatePure 

func (p *ProgrammableTransactionBuilder) MustForceSeparatePure(value any) Argument

func (*ProgrammableTransactionBuilder) MustObj 

func (p *ProgrammableTransactionBuilder) MustObj(objArg ObjectArg) Argument

func (*ProgrammableTransactionBuilder) MustPure 

func (p *ProgrammableTransactionBuilder) MustPure(value any) Argument

func (*ProgrammableTransactionBuilder) Obj 

func (p *ProgrammableTransactionBuilder) Obj(objArg ObjectArg) (Argument, error)

refer crates/sui-types/src/programmable_transaction_builder.rs

func (*ProgrammableTransactionBuilder) Pay 

func (p *ProgrammableTransactionBuilder) Pay(
	coins []*sui.ObjectRef,
	recipients []*sui.Address,
	amounts []uint64,
) error

merge all given coins into the 1st coin, and pay it with the corresponding amounts to the corresponding recipients

func (*ProgrammableTransactionBuilder) PayAllSui 

func (p *ProgrammableTransactionBuilder) PayAllSui(recipient *sui.Address) error

the gas coin is consumed as the coin to be paid

func (*ProgrammableTransactionBuilder) PaySui 

func (p *ProgrammableTransactionBuilder) PaySui(recipients []*sui.Address, amounts []uint64) error

the gas coin is consumed as the coin to be paid

func (*ProgrammableTransactionBuilder) ProgrammableMoveCall 

func (p *ProgrammableTransactionBuilder) ProgrammableMoveCall(
	packageId *sui.PackageId,
	module sui.Identifier,
	function sui.Identifier,
	typeArguments []sui.TypeTag,
	arguments []Argument,
) Argument

construct `move_call` with argument `Argument` type, and return `Argument`

func (*ProgrammableTransactionBuilder) PublishImmutable 

func (p *ProgrammableTransactionBuilder) PublishImmutable(
	modules [][]byte,
	dependencies []*sui.ObjectId,
) Argument

func (*ProgrammableTransactionBuilder) PublishUpgradeable 

func (p *ProgrammableTransactionBuilder) PublishUpgradeable(
	modules [][]byte,
	dependencies []*sui.ObjectId,
) Argument

func (*ProgrammableTransactionBuilder) Pure 

func (p *ProgrammableTransactionBuilder) Pure(value any) (Argument, error)

func (*ProgrammableTransactionBuilder) TransferArg 

func (p *ProgrammableTransactionBuilder) TransferArg(recipient *sui.Address, arg Argument)

func (*ProgrammableTransactionBuilder) TransferArgs 

func (p *ProgrammableTransactionBuilder) TransferArgs(recipient *sui.Address, args []Argument)

func (*ProgrammableTransactionBuilder) TransferObject 

func (p *ProgrammableTransactionBuilder) TransferObject(recipient *sui.Address, objectRef *sui.ObjectRef) error

func (*ProgrammableTransactionBuilder) TransferSui 

func (p *ProgrammableTransactionBuilder) TransferSui(recipient *sui.Address, amount *uint64) error

func (*ProgrammableTransactionBuilder) Upgrade 

func (p *ProgrammableTransactionBuilder) Upgrade(
	currentPackageObjectId *sui.ObjectId,
	upgradeTicket Argument,
	transitiveDeps []*sui.ObjectId,
	modules [][]byte,
) Argument

type ProgrammableTransferObjects 

type ProgrammableTransferObjects struct {
	Objects []Argument
	Address Argument
}

type ProgrammableUpgrade 

type ProgrammableUpgrade struct {
	Modules      [][]byte
	Dependencies []*sui.ObjectId
	PackageId    *sui.PackageId
	Ticket       Argument
}

type SharedObjectArg 

type SharedObjectArg struct {
	Id                   *sui.ObjectId
	InitialSharedVersion sui.SequenceNumber
	Mutable              bool
}

type TransactionData 

type TransactionData struct {
	V1 *TransactionDataV1
}

func NewTransactionData 

func NewTransactionData(
	sender *sui.Address,
	pt ProgrammableTransaction,
	gasPayment []*sui.ObjectRef,
	gasBudget uint64,
	gasPrice uint64,
) TransactionData

func NewTransactionDataAllowSponsor 

func NewTransactionDataAllowSponsor(
	sender sui.Address,
	pt ProgrammableTransaction,
	gasPayment []*sui.ObjectRef,
	gasBudget uint64,
	gasPrice uint64,
	sponsor *sui.Address,
) TransactionData

This 'TransactionData' will need to be signed by both 'sponsor' and 'sender'

func (TransactionData) IsBcsEnum 

func (t TransactionData) IsBcsEnum()

type TransactionDataV1 

type TransactionDataV1 struct {
	Kind       TransactionKind
	Sender     sui.Address
	GasData    GasData
	Expiration TransactionExpiration
}

type TransactionExpiration 

type TransactionExpiration struct {
	None  *sui.EmptyEnum
	Epoch *sui.EpochId
}

func (TransactionExpiration) IsBcsEnum 

func (t TransactionExpiration) IsBcsEnum()

type TransactionKind 

type TransactionKind struct {
	ProgrammableTransaction *ProgrammableTransaction
	ChangeEpoch             *ChangeEpoch
	Genesis                 *GenesisTransaction
	ConsensusCommitPrologue *ConsensusCommitPrologue
}

func (TransactionKind) IsBcsEnum 

func (t TransactionKind) IsBcsEnum()

Source Files

View all Source files

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL
go.dev uses cookies from Google to deliver and enhance the quality of its services and to analyze traffic. Learn more.