diff --git a/bindings/go/examples/prepare_send_iota/main.go b/bindings/go/examples/prepare_send_iota/main.go index 1b55c431a..f7a6c2db0 100644 --- a/bindings/go/examples/prepare_send_iota/main.go +++ b/bindings/go/examples/prepare_send_iota/main.go @@ -36,12 +36,12 @@ func main() { skipChecks := bool(false) res, err := client.DryRunTx(txn, &skipChecks) if err.(*sdk.SdkFfiError) != nil { - log.Fatalf("Failed to send IOTA: %v", err) + log.Fatalf("Dry run failed: %v", err) } if res.Error != nil { - log.Fatalf("Failed to send IOTA: %v", *res.Error) + log.Fatalf("Dry run failed: %v", *res.Error) } - log.Print("Send IOTA dry run was successful!") + log.Print("Dry run successful!") } diff --git a/bindings/go/examples/prepare_send_iota_multi/main.go b/bindings/go/examples/prepare_send_iota_multi/main.go index 4d566da06..6fe79bba2 100644 --- a/bindings/go/examples/prepare_send_iota_multi/main.go +++ b/bindings/go/examples/prepare_send_iota_multi/main.go @@ -58,10 +58,10 @@ func main() { skipChecks := bool(false) res, err := client.DryRunTx(txn, &skipChecks) if err.(*sdk.SdkFfiError) != nil { - log.Fatalf("Failed to dry run send IOTA: %v", err) + log.Fatalf("Dry run failed: %v", err) } if res.Error != nil { - log.Fatalf("Failed to send IOTA: %v", *res.Error) + log.Fatalf("Dry run failed: %v", *res.Error) } - log.Print("Send IOTA dry run was successful!") + log.Print("Dry run successful!") } diff --git a/bindings/go/examples/send_iota/main.go b/bindings/go/examples/send_iota/main.go new file mode 100644 index 000000000..89feb4896 --- /dev/null +++ b/bindings/go/examples/send_iota/main.go @@ -0,0 +1,45 @@ +// Copyright (c) 2025 IOTA Stiftung +// SPDX-License-Identifier: Apache-2.0 + +package main + +import ( + "log" + + sdk "bindings/iota_sdk_ffi" +) + +func main() { + client := sdk.GraphQlClientNewDevnet() + + sender, _ := sdk.AddressFromHex("0x611830d3641a68f94a690dcc25d1f4b0dac948325ac18f6dd32564371735f32c") + recipient, _ := sdk.AddressFromHex("0x0000a4984bd495d4346fa208ddff4f5d5e5ad48c21dec631ddebc99809f16900") + + var amount = uint64(1_000_000_000) + builder := sdk.TransactionBuilderInit(sender, client) + builder.SendIota(recipient, &amount) + + txn, err := builder.Finish() + if err.(*sdk.SdkFfiError) != nil { + log.Fatalf("Failed to create transaction: %v", err) + } + + txnBytes, err := txn.BcsSerialize() + if err != nil { + log.Fatalf("Failed to serialize transaction: %v", err) + } + log.Printf("Signing Digest: %v", sdk.HexEncode(txn.SigningDigest())) + log.Printf("Txn Bytes: %v", sdk.Base64Encode(txnBytes)) + + skipChecks := bool(false) + res, err := client.DryRunTx(txn, &skipChecks) + if err.(*sdk.SdkFfiError) != nil { + log.Fatalf("Dry run failed: %v", err) + } + + if res.Error != nil { + log.Fatalf("Dry run failed: %v", *res.Error) + } + + log.Print("Dry run successful!") +} diff --git a/bindings/kotlin/examples/PrepareSendIota.kt b/bindings/kotlin/examples/PrepareSendIota.kt index bc7760728..d984bba7d 100644 --- a/bindings/kotlin/examples/PrepareSendIota.kt +++ b/bindings/kotlin/examples/PrepareSendIota.kt @@ -38,10 +38,10 @@ fun main() = runBlocking { val res = builder.dryRun() if (res.error != null) { - throw Exception("Failed to send IOTA: ${res.error}") + throw Exception("Dry run failed: ${res.error}") } - println("Send IOTA dry run was successful!") + println("Dry run successful!") } catch (e: Exception) { e.printStackTrace() } diff --git a/bindings/kotlin/examples/PrepareSendIotaMulti.kt b/bindings/kotlin/examples/PrepareSendIotaMulti.kt index c2ef0d8bf..128714478 100644 --- a/bindings/kotlin/examples/PrepareSendIotaMulti.kt +++ b/bindings/kotlin/examples/PrepareSendIotaMulti.kt @@ -62,10 +62,10 @@ fun main() = runBlocking { val res = builder.dryRun() if (res.error != null) { - throw Exception("Failed to send IOTA: ${res.error}") + throw Exception("Dry run failed: ${res.error}") } - println("Send IOTA dry run was successful!") + println("Dry run successful!") } catch (e: Exception) { e.printStackTrace() } diff --git a/bindings/kotlin/examples/SendIota.kt b/bindings/kotlin/examples/SendIota.kt new file mode 100644 index 000000000..740b40145 --- /dev/null +++ b/bindings/kotlin/examples/SendIota.kt @@ -0,0 +1,39 @@ +// Copyright (c) 2025 IOTA Stiftung +// SPDX-License-Identifier: Apache-2.0 + +import iota_sdk.* +import kotlinx.coroutines.runBlocking + +fun main() = runBlocking { + try { + val client = GraphQlClient.newDevnet() + + val sender = + Address.fromHex( + "0x611830d3641a68f94a690dcc25d1f4b0dac948325ac18f6dd32564371735f32c" + ) + val recipient = + Address.fromHex( + "0x0000a4984bd495d4346fa208ddff4f5d5e5ad48c21dec631ddebc99809f16900" + ) + + val builder = TransactionBuilder.init(sender, client) + + builder.sendIota(recipient, 1_000_000_000UL) + + val txn = builder.finish() + + println("Signing Digest: ${hexEncode(txn.signingDigest())}") + println("Txn Bytes: ${base64Encode(txn.bcsSerialize())}") + + val res = builder.dryRun() + + if (res.error != null) { + throw Exception("Dry run failed: ${res.error}") + } + + println("Dry run successful!") + } catch (e: Exception) { + e.printStackTrace() + } +} diff --git a/bindings/python/examples/prepare_send_iota.py b/bindings/python/examples/prepare_send_iota.py index 595dde7ee..1f0ebbc09 100644 --- a/bindings/python/examples/prepare_send_iota.py +++ b/bindings/python/examples/prepare_send_iota.py @@ -10,11 +10,11 @@ async def main(): try: client = GraphQlClient.new_devnet() - from_address = Address.from_hex( + sender = Address.from_hex( "0x611830d3641a68f94a690dcc25d1f4b0dac948325ac18f6dd32564371735f32c" ) - to_address = Address.from_hex( + recipient = Address.from_hex( "0x0000a4984bd495d4346fa208ddff4f5d5e5ad48c21dec631ddebc99809f16900" ) @@ -22,9 +22,9 @@ async def main(): "0xd04077fe3b6fad13b3d4ed0d535b7ca92afcac8f0f2a0e0925fb9f4f0b30c699" ) - builder = await TransactionBuilder.init(from_address, client) + builder = await TransactionBuilder.init(sender, client) builder.transfer_objects( - to_address, + recipient, [PtbArgument.object_id(coin_id)], ) @@ -33,11 +33,12 @@ async def main(): print("Signing Digest:", hex_encode(txn.signing_digest())) print("Txn Bytes:", base64_encode(txn.bcs_serialize())) + print("Sending ") res = await client.dry_run_tx(txn) if res.error is not None: - raise Exception("Failed to send IOTA:", res.error) + raise Exception("Dry run failed:", res.error) - print("Send IOTA dry run was successful!") + print("Dry run successful!") except Exception as e: print(f"Error: {e}") diff --git a/bindings/python/examples/prepare_send_iota_multi.py b/bindings/python/examples/prepare_send_iota_multi.py index 5f4ed5bc6..a8bfa42e8 100644 --- a/bindings/python/examples/prepare_send_iota_multi.py +++ b/bindings/python/examples/prepare_send_iota_multi.py @@ -8,13 +8,10 @@ async def main(): client = GraphQlClient.new_devnet() + sender = Address.from_hex( "0x611830d3641a68f94a690dcc25d1f4b0dac948325ac18f6dd32564371735f32c" ) - coin_id = ObjectId.from_hex( - "0x0b0270ee9d27da0db09651e5f7338dfa32c7ee6441ccefa1f6e305735bcfc7ab" - ) - recipients = [ ( "0x111173a14c3d402c01546c54265c30cc04414c7b7ec1732412bb19066dd49d11", @@ -26,6 +23,10 @@ async def main(): ), ] + coin_id = ObjectId.from_hex( + "0x0b0270ee9d27da0db09651e5f7338dfa32c7ee6441ccefa1f6e305735bcfc7ab" + ) + amounts = [r[1] for r in recipients] labels = [f"coin{i}" for i in range(len(recipients))] @@ -43,9 +44,9 @@ async def main(): res = await client.dry_run_tx(txn) if res.error is not None: - raise Exception(f"Failed to send IOTA: {res.error}") + raise Exception("Dry run failed:", res.error) - print("Send IOTA dry run was successful!") + print("Dry run successful!") if __name__ == "__main__": diff --git a/bindings/python/examples/send_iota.py b/bindings/python/examples/send_iota.py new file mode 100644 index 000000000..39a6aafeb --- /dev/null +++ b/bindings/python/examples/send_iota.py @@ -0,0 +1,39 @@ +# Copyright (c) 2025 IOTA Stiftung +# SPDX-License-Identifier: Apache-2.0 + +from lib.iota_sdk_ffi import * + +import asyncio + + +async def main(): + try: + client = GraphQlClient.new_devnet() + + sender = Address.from_hex( + "0x611830d3641a68f94a690dcc25d1f4b0dac948325ac18f6dd32564371735f32c" + ) + recipient = Address.from_hex( + "0x0000a4984bd495d4346fa208ddff4f5d5e5ad48c21dec631ddebc99809f16900" + ) + + builder = await TransactionBuilder.init(sender, client) + builder.send_iota(recipient, 1_000_000_000) + + txn = await builder.finish() + + print("Signing Digest:", hex_encode(txn.signing_digest())) + print("Txn Bytes:", base64_encode(txn.bcs_serialize())) + + res = await client.dry_run_tx(txn) + if res.error is not None: + raise Exception("Dry run failed:", res.error) + + print("Dry run successful!") + + except Exception as e: + print(f"Error: {e}") + + +if __name__ == "__main__": + asyncio.run(main()) diff --git a/crates/iota-graphql-client/examples/prepare_send_iota.rs b/crates/iota-graphql-client/examples/prepare_send_iota.rs index f4dabf7d7..3c419a74d 100644 --- a/crates/iota-graphql-client/examples/prepare_send_iota.rs +++ b/crates/iota-graphql-client/examples/prepare_send_iota.rs @@ -1,28 +1,24 @@ // Copyright (c) 2025 IOTA Stiftung // SPDX-License-Identifier: Apache-2.0 -use std::str::FromStr; - use base64ct::Encoding; -use eyre::Result; +use eyre::{Result, bail}; use iota_graphql_client::Client; use iota_transaction_builder::TransactionBuilder; -use iota_types::{Address, ObjectId}; +use iota_types::ObjectId; #[tokio::main] async fn main() -> Result<()> { let client = Client::new_devnet(); - let from_address = - Address::from_str("0x611830d3641a68f94a690dcc25d1f4b0dac948325ac18f6dd32564371735f32c")?; - let to_address = - Address::from_str("0x0000a4984bd495d4346fa208ddff4f5d5e5ad48c21dec631ddebc99809f16900")?; + let sender = "0x611830d3641a68f94a690dcc25d1f4b0dac948325ac18f6dd32564371735f32c".parse()?; + let recipient = "0x0000a4984bd495d4346fa208ddff4f5d5e5ad48c21dec631ddebc99809f16900".parse()?; - let mut builder = TransactionBuilder::new(from_address).with_client(client.clone()); + let mut builder = TransactionBuilder::new(sender).with_client(client.clone()); builder.transfer_objects( - to_address, - ObjectId::from_str("0xd04077fe3b6fad13b3d4ed0d535b7ca92afcac8f0f2a0e0925fb9f4f0b30c699")?, + recipient, + "0xd04077fe3b6fad13b3d4ed0d535b7ca92afcac8f0f2a0e0925fb9f4f0b30c699".parse::()?, ); let txn = builder.finish().await?; @@ -36,10 +32,10 @@ async fn main() -> Result<()> { let res = client.dry_run_tx(&txn, false).await?; if let Some(err) = res.error { - eyre::bail!("Failed to send IOTA: {err}"); + bail!("Dry run failed: {err}"); } - println!("Send IOTA dry run was successful!"); + println!("Dry run successful!"); Ok(()) } diff --git a/crates/iota-graphql-client/examples/prepare_send_iota_multi.rs b/crates/iota-graphql-client/examples/prepare_send_iota_multi.rs index d7e026ed6..254fe4404 100644 --- a/crates/iota-graphql-client/examples/prepare_send_iota_multi.rs +++ b/crates/iota-graphql-client/examples/prepare_send_iota_multi.rs @@ -1,23 +1,18 @@ // Copyright (c) 2025 IOTA Stiftung // SPDX-License-Identifier: Apache-2.0 -use std::str::FromStr; - use base64ct::Encoding; -use eyre::Result; +use eyre::{Result, bail}; use iota_graphql_client::Client; use iota_transaction_builder::{TransactionBuilder, res}; -use iota_types::{Address, ObjectId}; +use iota_types::Address; #[tokio::main] async fn main() -> Result<()> { let client = Client::new_devnet(); - let coin = - ObjectId::from_str("0x0b0270ee9d27da0db09651e5f7338dfa32c7ee6441ccefa1f6e305735bcfc7ab")?; - - let sender = - Address::from_str("0x611830d3641a68f94a690dcc25d1f4b0dac948325ac18f6dd32564371735f32c")?; + let coin = "0x0b0270ee9d27da0db09651e5f7338dfa32c7ee6441ccefa1f6e305735bcfc7ab".parse()?; + let sender = "0x611830d3641a68f94a690dcc25d1f4b0dac948325ac18f6dd32564371735f32c".parse()?; // Recipients and amounts let recipients = [ @@ -42,7 +37,7 @@ async fn main() -> Result<()> { // Transfer each split coin to the corresponding recipient for (i, (address, _)) in recipients.iter().enumerate() { - builder.transfer_objects(Address::from_str(address)?, res(&labels[i])); + builder.transfer_objects(Address::from_hex(address)?, res(&labels[i])); } let txn = builder.finish().await?; @@ -56,10 +51,10 @@ async fn main() -> Result<()> { let res = client.dry_run_tx(&txn, false).await?; if let Some(err) = res.error { - eyre::bail!("Failed to send IOTA: {err}"); + bail!("Dry run failed: {err}"); } - println!("Send IOTA dry run was successful!"); + println!("Dry run successful!"); Ok(()) } diff --git a/crates/iota-graphql-client/examples/send_iota.rs b/crates/iota-graphql-client/examples/send_iota.rs new file mode 100644 index 000000000..97ee48234 --- /dev/null +++ b/crates/iota-graphql-client/examples/send_iota.rs @@ -0,0 +1,37 @@ +// Copyright (c) 2025 IOTA Stiftung +// SPDX-License-Identifier: Apache-2.0 + +use base64ct::Encoding; +use eyre::{Result, bail}; +use iota_graphql_client::Client; +use iota_transaction_builder::TransactionBuilder; + +#[tokio::main] +async fn main() -> Result<()> { + let client = Client::new_devnet(); + + let sender = "0x611830d3641a68f94a690dcc25d1f4b0dac948325ac18f6dd32564371735f32c".parse()?; + let recipient = "0x0000a4984bd495d4346fa208ddff4f5d5e5ad48c21dec631ddebc99809f16900".parse()?; + + let mut builder = TransactionBuilder::new(sender).with_client(client.clone()); + + builder.send_iota(recipient, 1_000_000_000); + + let txn = builder.finish().await?; + + println!("Signing Digest: {}", hex::encode(txn.signing_digest())); + println!( + "Txn Bytes: {}", + base64ct::Base64::encode_string(&bcs::to_bytes(&txn)?) + ); + + let res = client.dry_run_tx(&txn, false).await?; + + if let Some(err) = res.error { + bail!("Dry run failed: {err}"); + } + + println!("Dry run successful!"); + + Ok(()) +}