feat: Add new transaction builder (#206)

* Add new transaction builder

* remove unnecessary methods

* improvements

* examples

* simplify

* Update bindings

* fmt and clippy

* update years

* improved input and gas handling

* fix doc

* fix test

* rename new fn

* fix gas ownership check

* Remove CustomMoveType and fix some issues

* clippy

* reorganize builder files

* make `Res` a fn

* Split out name and arg fns

* update examples

* add command builder for more convenience

* missed underflow

* fix issues with dropping builder

* revert examples

* add method for adding multiple gas coins

* wizardry

* missed things

* more improvements

* cleanup

* add `transfer_value`

* doc and fix ordering

* improve send_coins

* add missing methods to ffi

* update bindings

* impl traits for more tuples

* rename transfer_iota -> send_iota

* safety and remove unused fn

* impl PTBArguments for inputs

* add effects back to dry run result

* remove anyhow

* fix mutable id

* rename params -> arguments

* clippy

* rename fn

* update bindings

* flip a flag

* another rename

* review

* typo

* fix sdk crate

* distinguish shared and shared mut

* allow passing shared object IDs directly

* rename named_comands

* unsafe comments

* more repr(C)

* remove unnecessary Send bounds

Author: DaughterOfMars

.gitignore

@@ -5,3 +5,4 @@ Cargo.lock
 *.so
 *.dll
 __pycache__
+build

bindings/go/examples/dev_inspect/main.go

@@ -13,180 +13,97 @@ import (
 func main() {
 	client := sdk.GraphQlClientNewDevnet()
 
-	senderAddress, err := sdk.AddressFromHex("0x0")
-	if err != nil {
-		log.Fatalf("Failed to parse sender address: %v", err)
-	}
+	sender, _ := sdk.AddressFromHex("0x0")
 
-	iotaNamesPackageAddress, err := sdk.AddressFromHex("0xb9d617f24c84826bf660a2f4031951678cc80c264aebc4413459fb2a95ada9ba")
-	if err != nil {
-		log.Fatalf("Failed to parse IOTA names package address: %v", err)
-	}
+	iotaNamesPackageAddress, _ := sdk.AddressFromHex("0xb9d617f24c84826bf660a2f4031951678cc80c264aebc4413459fb2a95ada9ba")
 
-	iotaNamesObjectId, err := sdk.ObjectIdFromHex("0x07c59b37bd7d036bf78fa30561a2ab9f7a970837487656ec29466e817f879342")
-	if err != nil {
-		log.Fatalf("Failed to parse IOTA names object ID: %v", err)
-	}
+	iotaNamesObjectId, _ := sdk.ObjectIdFromHex("0x07c59b37bd7d036bf78fa30561a2ab9f7a970837487656ec29466e817f879342")
 
-	stdlibAddress, err := sdk.AddressFromHex("0x1")
-	if err != nil {
-		log.Fatalf("Failed to parse stdlib address: %v", err)
-	}
+	stdlibAddress, _ := sdk.AddressFromHex("0x1")
 
 	name := "name.iota"
 	fmt.Printf("Looking up name: %s\n", name)
 
-	builder := sdk.NewTransactionBuilder()
+	builder := sdk.TransactionBuilderInit(sender, client)
 
 	// Create identifiers
-	iotaNamesModule, err := sdk.NewIdentifier("iota_names")
-	if err != nil {
-		log.Fatalf("Failed to create identifier: %v", err)
-	}
-	registryFn, err := sdk.NewIdentifier("registry")
-	if err != nil {
-		log.Fatalf("Failed to create identifier: %v", err)
-	}
-	nameModule, err := sdk.NewIdentifier("name")
-	if err != nil {
-		log.Fatalf("Failed to create identifier: %v", err)
-	}
-	newFn, err := sdk.NewIdentifier("new")
-	if err != nil {
-		log.Fatalf("Failed to create identifier: %v", err)
-	}
-	lookupFn, err := sdk.NewIdentifier("lookup")
-	if err != nil {
-		log.Fatalf("Failed to create identifier: %v", err)
-	}
-	optionModule, err := sdk.NewIdentifier("option")
-	if err != nil {
-		log.Fatalf("Failed to create identifier: %v", err)
-	}
-	borrowFn, err := sdk.NewIdentifier("borrow")
-	if err != nil {
-		log.Fatalf("Failed to create identifier: %v", err)
-	}
-	nameRecordModule, err := sdk.NewIdentifier("name_record")
-	if err != nil {
-		log.Fatalf("Failed to create identifier: %v", err)
-	}
-	targetAddressFn, err := sdk.NewIdentifier("target_address")
-	if err != nil {
-		log.Fatalf("Failed to create identifier: %v", err)
-	}
-
-	// Create type tags
-	registryName, err := sdk.NewIdentifier("Registry")
-	if err != nil {
-		log.Fatalf("Failed to create identifier: %v", err)
-	}
-	registryType := sdk.NewStructTag(iotaNamesPackageAddress, registryFn, registryName, []*sdk.TypeTag{})
-
-	nameRecordName, err := sdk.NewIdentifier("NameRecord")
-	if err != nil {
-		log.Fatalf("Failed to create identifier: %v", err)
-	}
+	iotaNamesModule, _ := sdk.NewIdentifier("iota_names")
+	nameModule, _ := sdk.NewIdentifier("name")
+	nameNewFn, _ := sdk.NewIdentifier("new")
+	lookupFn, _ := sdk.NewIdentifier("lookup")
+	optionModule, _ := sdk.NewIdentifier("option")
+	borrowFn, _ := sdk.NewIdentifier("borrow")
+	targetAddressFn, _ := sdk.NewIdentifier("target_address")
+	registryModule, _ := sdk.NewIdentifier("registry")
+	registryName, _ := sdk.NewIdentifier("Registry")
+
+	registryType := sdk.NewStructTag(iotaNamesPackageAddress, registryModule, registryName, []*sdk.TypeTag{})
+
+	nameRecordModule, _ := sdk.NewIdentifier("name_record")
+	nameRecordName, _ := sdk.NewIdentifier("NameRecord")
 	nameRecordType := sdk.NewStructTag(iotaNamesPackageAddress, nameRecordModule, nameRecordName, []*sdk.TypeTag{})
 
 	// 1. Get the registry
-	registryInput := builder.Input(sdk.UnresolvedInputNewShared(iotaNamesObjectId, 365644877, true))
-	iotaNames := builder.MoveCall(
-		sdk.Function{
-			Package:  iotaNamesPackageAddress,
-			Module:   iotaNamesModule,
-			Function: registryFn,
-			TypeArgs: []*sdk.TypeTag{sdk.TypeTagNewStruct(registryType)},
-		},
-		[]*sdk.Argument{registryInput},
+	builder.MoveCall(
+		iotaNamesPackageAddress,
+		iotaNamesModule,
+		registryModule,
+		[]*sdk.PtbArgument{sdk.PtbArgumentSharedMut(iotaNamesObjectId)},
+		[]*sdk.TypeTag{sdk.TypeTagNewStruct(registryType)},
+		[]string{"iota_names"},
 	)
 
 	// 2. Create name from string
-	// BCS encode the string: length (as varint) + UTF-8 bytes
-	nameBytes := []byte(name)
-	nameLen := len(nameBytes)
-	var bcsEncodedName []byte
-	if nameLen < 128 {
-		// For strings shorter than 128 bytes, length is encoded as single byte
-		bcsEncodedName = append([]byte{byte(nameLen)}, nameBytes...)
-	} else {
-		// For longer strings, we'd need proper varint encoding
-		// but for this example, the name should be short
-		panic("String too long for simple BCS encoding")
-	}
-	nameInput := builder.Input(sdk.UnresolvedInputNewPure(bcsEncodedName))
-	nameResult := builder.MoveCall(
-		sdk.Function{
-			Package:  iotaNamesPackageAddress,
-			Module:   nameModule,
-			Function: newFn,
-			TypeArgs: []*sdk.TypeTag{},
-		},
-		[]*sdk.Argument{nameInput},
+	builder.MoveCall(
+		iotaNamesPackageAddress,
+		nameModule,
+		nameNewFn,
+		[]*sdk.PtbArgument{sdk.PtbArgumentString(name)},
+		nil,
+		[]string{"name"},
 	)
 
 	// 3. Lookup name record
-	nameRecordOption := builder.MoveCall(
-		sdk.Function{
-			Package:  iotaNamesPackageAddress,
-			Module:   registryFn,
-			Function: lookupFn,
-			TypeArgs: []*sdk.TypeTag{},
-		},
-		[]*sdk.Argument{iotaNames, nameResult},
+	builder.MoveCall(
+		iotaNamesPackageAddress,
+		registryModule,
+		lookupFn,
+		[]*sdk.PtbArgument{sdk.PtbArgumentRes("iota_names"), sdk.PtbArgumentRes("name")},
+		nil,
+		[]string{"name_record_opt"},
 	)
 
 	// 4. Borrow name record from option
-	nameRecord := builder.MoveCall(
-		sdk.Function{
-			Package:  stdlibAddress,
-			Module:   optionModule,
-			Function: borrowFn,
-			TypeArgs: []*sdk.TypeTag{sdk.TypeTagNewStruct(nameRecordType)},
-		},
-		[]*sdk.Argument{nameRecordOption},
+	builder.MoveCall(
+		stdlibAddress,
+		optionModule,
+		borrowFn,
+		[]*sdk.PtbArgument{sdk.PtbArgumentRes("name_record_opt")},
+		[]*sdk.TypeTag{sdk.TypeTagNewStruct(nameRecordType)},
+		[]string{"name_record"},
 	)
 
 	// 5. Get target address from name record
-	targetAddressOption := builder.MoveCall(
-		sdk.Function{
-			Package:  iotaNamesPackageAddress,
-			Module:   nameRecordModule,
-			Function: targetAddressFn,
-			TypeArgs: []*sdk.TypeTag{},
-		},
-		[]*sdk.Argument{nameRecord},
+	builder.MoveCall(
+		iotaNamesPackageAddress,
+		nameRecordModule,
+		targetAddressFn,
+		[]*sdk.PtbArgument{sdk.PtbArgumentRes("name_record")},
+		nil,
+		[]string{"target_address_opt"},
 	)
 
 	// 6. Borrow address from option
 	builder.MoveCall(
-		sdk.Function{
-			Package:  stdlibAddress,
-			Module:   optionModule,
-			Function: borrowFn,
-			TypeArgs: []*sdk.TypeTag{sdk.TypeTagNewAddress()},
-		},
-		[]*sdk.Argument{targetAddressOption},
+		stdlibAddress,
+		optionModule,
+		borrowFn,
+		[]*sdk.PtbArgument{sdk.PtbArgumentRes("target_address_opt")},
+		[]*sdk.TypeTag{sdk.TypeTagNewAddress()},
+		[]string{"target_address"},
 	)
 
-	builder.SetSender(senderAddress)
-	builder.SetGasBudget(50000000)
-	gasPrice, err := client.ReferenceGasPrice(nil)
-	if err.(*sdk.SdkFfiError) != nil {
-		log.Fatalf("Failed to get gas price: %v", err)
-	}
-	if gasPrice == nil {
-		log.Fatalf("Missing reference gas price")
-	}
-	builder.SetGasPrice(*gasPrice)
-
-	txn, err := builder.Finish()
-	if err != nil {
-		log.Fatalf("Failed to create transaction: %v", err)
-	}
-
-	skipChecks := true
-	res, err := client.DryRunTx(txn, &skipChecks)
+	res, err := builder.DryRun(true)
 	if err.(*sdk.SdkFfiError) != nil {
 		log.Fatalf("Failed to dry run transaction: %v", err)
 	}

bindings/go/examples/generic_move_function/main.go

@@ -4,7 +4,6 @@
 package main
 
 import (
-	"encoding/binary"
 	"fmt"
 	"log"
 
@@ -17,64 +16,36 @@ func main() {
 	sender, _ := sdk.AddressFromHex("0x71b4b4f171b4355ff691b7c470579cf1a926f96f724e5f9a30efc4b5f75d085e")
 	gas_coin_id, _ := sdk.ObjectIdFromHex("0xa1d009e8dafe20b1cba05e08aea488aafae1f89d892c3eaef6c0994e155e441a")
 
-	gas_coin_obj, err := client.Object(gas_coin_id, nil)
-	if err.(*sdk.SdkFfiError) != nil {
-		log.Fatalf("Failed to fetch gas coin object: %v", err)
-	}
-	gas_coin := sdk.UnresolvedInputFromObject(*gas_coin_obj).WithOwnedKind()
-
-	reference_gas_price, err := client.ReferenceGasPrice(nil)
-	if err.(*sdk.SdkFfiError) != nil {
-		log.Fatalf("Failed to fetch reference gas price: %v", err)
-	}
-
-	builder := sdk.NewTransactionBuilder()
+	builder := sdk.TransactionBuilderInit(sender, client)
 
 	addr1, _ := sdk.AddressFromHex("0xde49ea53fbadee67d3e35a097cdbea210b659676fc680a0b0c5f11d0763d375e")
 	addr2, _ := sdk.AddressFromHex("0xe512234aa4ef6184c52663f09612b68f040dd0c45de037d96190a071ca5525b3")
 
-	addr1_arg := builder.Input(sdk.UnresolvedInputNewPure(addr1.ToBytes()))
-	addr2_arg := builder.Input(sdk.UnresolvedInputNewPure(addr2.ToBytes()))
-
-	address_type_tag := sdk.TypeTagNewAddress()
-	balance_type_tag := sdk.TypeTagNewU64()
-
-	buf := make([]byte, 8)
-	binary.LittleEndian.PutUint64(buf, 10_000_000)
-	bal1_arg := builder.Input(sdk.UnresolvedInputNewPure(buf))
-	binary.LittleEndian.PutUint64(buf, 20_000_000)
-	bal2_arg := builder.Input(sdk.UnresolvedInputNewPure(buf))
+	builder.MakeMoveVec([]*sdk.PtbArgument{sdk.PtbArgumentAddress(addr1), sdk.PtbArgumentAddress(addr2)}, sdk.TypeTagNewAddress(), "addresses")
+	builder.MakeMoveVec([]*sdk.PtbArgument{sdk.PtbArgumentU64(10_000_000), sdk.PtbArgumentU64(20_000_000)}, sdk.TypeTagNewU64(), "amounts")
 
-	arg1 := builder.MakeMoveVec(&address_type_tag, []*sdk.Argument{addr1_arg, addr2_arg})
-	arg2 := builder.MakeMoveVec(&balance_type_tag, []*sdk.Argument{bal1_arg, bal2_arg})
-
-	package_name, _ := sdk.AddressFromHex("0x2")
+	package_id, _ := sdk.AddressFromHex("0x2")
 	module_name, _ := sdk.NewIdentifier("vec_map")
 	function_name, _ := sdk.NewIdentifier("from_keys_values")
 
-	function := sdk.Function{Package: package_name,
-		Module:   module_name,
-		Function: function_name,
-		TypeArgs: []*sdk.TypeTag{address_type_tag, balance_type_tag},
-	}
-
-	builder.MoveCall(function, []*sdk.Argument{arg1, arg2})
+	builder.MoveCall(
+		package_id,
+		module_name,
+		function_name,
+		[]*sdk.PtbArgument{sdk.PtbArgumentRes("addresses"), sdk.PtbArgumentRes("amounts")},
+		[]*sdk.TypeTag{sdk.TypeTagNewAddress(), sdk.TypeTagNewU64()},
+		nil,
+	)
 
-	builder.SetGasBudget(50_000_000)
-	builder.SetGasPrice(*reference_gas_price)
-	builder.SetSender(sender)
-	builder.AddGasObjects([]*sdk.UnresolvedInput{gas_coin})
+	builder.Gas(gas_coin_id).GasBudget(1000000000)
 
-	txn, err := builder.Finish()
-	if err != nil {
-		log.Fatalf("Failed to create transaction: %v", err)
+	res, err := builder.DryRun(false)
+	if err.(*sdk.SdkFfiError) != nil {
+		log.Fatalf("Failed to call generic Move function: %v", err)
 	}
 
-	skipChecks := false
-	res, err := client.DryRunTx(txn, &skipChecks)
-
 	if res.Error != nil {
-		log.Fatalf("Failed to call generic Move function: %v", err)
+		log.Fatalf("Failed to call generic Move function: %v", *res.Error)
 	}
 
 	fmt.Print("Successfully called generic Move function")