feat: add generate_ed25519_address example

bindings/go/examples/generate_ed25519_address/main.go

@@ -0,0 +1,28 @@
+// Copyright (c) 2025 IOTA Stiftung
+// SPDX-License-Identifier: Apache-2.0
+
+package main
+
+import (
+	"fmt"
+
+	sdk "bindings/iota_sdk_ffi"
+)
+
+func main() {
+	privateKey := sdk.Ed25519PrivateKeyGenerate()
+	publicKey := privateKey.PublicKey()
+	address := publicKey.DeriveAddress()
+	publicKeyBytes := publicKey.ToBytes()
+
+	flaggedPublicKey := append([]byte{byte(sdk.SignatureSchemeEd25519)}, publicKeyBytes...)
+	privateKeyDer, err := privateKey.ToDer()
+	if err != nil {
+		panic(err)
+	}
+
+	fmt.Println("Private Key:", sdk.Base64Encode(privateKeyDer))
+	fmt.Println("Public Key:", sdk.Base64Encode(publicKeyBytes))
+	fmt.Println("Public Key With Flag:", sdk.Base64Encode(flaggedPublicKey))
+	fmt.Println("Address:", address.ToHex())
+}

bindings/kotlin/examples/GenerateEd25519Address.kt

@@ -0,0 +1,19 @@
+// Copyright (c) 2025 IOTA Stiftung
+// SPDX-License-Identifier: Apache-2.0
+
+import iota_sdk.Ed25519PrivateKey
+import iota_sdk.base64Encode
+import kotlin.io.println
+
+fun main() {
+    val privateKey = Ed25519PrivateKey.generate()
+    val publicKey = privateKey.publicKey()
+    val publicKeyBytes = publicKey.toBytes()
+    val flaggedPublicKey = byteArrayOf((publicKey.scheme().ordinal + 1).toByte()) + publicKeyBytes
+    val address = publicKey.deriveAddress()
+
+    println("Private Key: ${base64Encode(privateKey.toDer())}")
+    println("Public Key: ${base64Encode(publicKeyBytes)}")
+    println("Public Key With Flag: ${base64Encode(flaggedPublicKey)}")
+    println("Address: ${address.toHex()}")
+}

bindings/python/examples/generate_ed25519_address.py

@@ -0,0 +1,21 @@
+# Copyright (c) 2025 IOTA Stiftung
+# SPDX-License-Identifier: Apache-2.0
+
+from lib.iota_sdk_ffi import Ed25519PrivateKey, base64_encode
+
+
+def main():
+    private_key = Ed25519PrivateKey.generate()
+    public_key = private_key.public_key()
+    public_key_bytes = public_key.to_bytes()
+    flagged_public_key = bytes([public_key.scheme().value]) + public_key_bytes
+    address = public_key.derive_address()
+
+    print(f"Private Key: {base64_encode(private_key.to_der())}")
+    print(f"Public Key: {base64_encode(public_key_bytes)}")
+    print(f"Public Key With Flag: {base64_encode(flagged_public_key)}")
+    print(f"Address: {address.to_hex()}")
+
+
+if __name__ == "__main__":
+    main()

crates/iota-graphql-client/Cargo.toml

@@ -27,6 +27,7 @@ url = "2.5.3"
 
 [dev-dependencies]
 hex = "0.4.3"
+iota-crypto = { path = "../iota-crypto", features = ["ed25519", "pem"] }
 iota-transaction-builder = { path = "../iota-transaction-builder" }
 iota-types = { package = "iota-sdk-types", path = "../iota-sdk-types", features = ["serde", "rand", "hash"] }
 rand = "0.8.5"

crates/iota-graphql-client/examples/generate_ed25519_address.rs

@@ -0,0 +1,24 @@
+// Copyright (c) 2025 IOTA Stiftung
+// SPDX-License-Identifier: Apache-2.0
+
+use base64ct::{Base64, Encoding};
+use iota_crypto::ed25519::Ed25519PrivateKey;
+use rand::rngs::OsRng;
+
+fn main() {
+    let private_key = Ed25519PrivateKey::generate(OsRng);
+    let public_key = private_key.public_key();
+    let address = public_key.derive_address();
+
+    let mut flagged_public_key = vec![public_key.scheme().to_u8()];
+    flagged_public_key.extend_from_slice(public_key.as_bytes());
+    let encoded_public_key = Base64::encode_string(&flagged_public_key);
+
+    println!(
+        "Private Key: {}",
+        Base64::encode_string(&private_key.to_der().unwrap())
+    );
+    println!("Public Key: {public_key}");
+    println!("Public Key With Flag: {encoded_public_key}");
+    println!("Address: {address}");
+}