diff --git a/.gitignore b/.gitignore index acfe2dc66..ff4c35bb3 100644 --- a/.gitignore +++ b/.gitignore @@ -7,9 +7,19 @@ node_modules/ .dmypy.json .build .bin/ +.vscode/ .DS_Store +*.idea wheelhouse/ +# Android/Kotlin +.gradle/ +build/ +*.iml +local.properties +gradle-wrapper.jar +*.so + # Insta snapshot testing *.snap.new *.pending-snap diff --git a/README.md b/README.md index fc8f34091..0fdb528d8 100644 --- a/README.md +++ b/README.md @@ -30,6 +30,12 @@ The exported interfaces should be purely functional without any state owned by R ## Contributing +## Build Scripts + +`cargo pkg` will run the build script. For example: `cargo pkg transact kt` builds `algokit_transact` for `kotlin`. + +The scripts are defined in [tools/build_pkgs] for each language. + ### Learning Resources If you are new to Rust or UniFFI, check out the [learning resources document](./docs/contributing/learning_resources.md) diff --git a/crates/algokit_transact/src/address.rs b/crates/algokit_transact/src/address.rs index a5fff1809..50174b19b 100644 --- a/crates/algokit_transact/src/address.rs +++ b/crates/algokit_transact/src/address.rs @@ -65,12 +65,12 @@ impl FromStr for Address { fn from_str(s: &str) -> Result { if s.len() != ALGORAND_ADDRESS_LENGTH { return Err(AlgoKitTransactError::InvalidAddress { - message: "Algorand address must be exactly 58 characters".into(), + err_msg:"Algorand address must be exactly 58 characters".into(), }); } let decoded_address = base32::decode(base32::Alphabet::Rfc4648 { padding: false }, s) .ok_or_else(|| AlgoKitTransactError::InvalidAddress { - message: "Invalid base32 encoding for Algorand address".into(), + err_msg:"Invalid base32 encoding for Algorand address".into(), })?; // Although this is called public key (and it actually is when the account is a `KeyPairAccount`), @@ -80,18 +80,18 @@ impl FromStr for Address { [..ALGORAND_PUBLIC_KEY_BYTE_LENGTH] .try_into() .map_err(|_| AlgoKitTransactError::InvalidAddress { - message: "Could not decode address into 32-byte public key".to_string(), + err_msg:"Could not decode address into 32-byte public key".to_string(), })?; let checksum: [u8; ALGORAND_CHECKSUM_BYTE_LENGTH] = decoded_address [ALGORAND_PUBLIC_KEY_BYTE_LENGTH..] .try_into() .map_err(|_| AlgoKitTransactError::InvalidAddress { - message: "Could not get 4-byte checksum from decoded address".to_string(), + err_msg:"Could not get 4-byte checksum from decoded address".to_string(), })?; if pub_key_to_checksum(&pub_key) != checksum { return Err(AlgoKitTransactError::InvalidAddress { - message: "Checksum is invalid".to_string(), + err_msg:"Checksum is invalid".to_string(), }); } Ok(Address(pub_key)) diff --git a/crates/algokit_transact/src/error.rs b/crates/algokit_transact/src/error.rs index f69db83b7..b838d695f 100644 --- a/crates/algokit_transact/src/error.rs +++ b/crates/algokit_transact/src/error.rs @@ -24,17 +24,17 @@ pub enum AlgoKitTransactError { #[snafu(display("Error ocurred during msgpack decoding: {source}"))] MsgpackDecodingError { source: rmpv::decode::Error }, - #[snafu(display("Unknown transaction type: {message}"))] - UnknownTransactionType { message: String }, + #[snafu(display("Unknown transaction type: {err_msg}"))] + UnknownTransactionType { err_msg: String }, - #[snafu(display("{message}"))] - InputError { message: String }, + #[snafu(display("{err_msg}"))] + InputError { err_msg: String }, - #[snafu(display("{message}"))] - InvalidAddress { message: String }, + #[snafu(display("{err_msg}"))] + InvalidAddress { err_msg: String }, - #[snafu(display("Invalid multisig signature: {message}"))] - InvalidMultisigSignature { message: String }, + #[snafu(display("Invalid multisig signature: {err_msg}"))] + InvalidMultisigSignature { err_msg: String }, } impl From for AlgoKitTransactError { diff --git a/crates/algokit_transact/src/multisig.rs b/crates/algokit_transact/src/multisig.rs index 04ece0fba..cab051fc4 100644 --- a/crates/algokit_transact/src/multisig.rs +++ b/crates/algokit_transact/src/multisig.rs @@ -78,16 +78,16 @@ impl MultisigSignature { ) -> Result { if version == 0 { return Err(AlgoKitTransactError::InvalidMultisigSignature { - message: "Version cannot be zero".to_string(), + err_msg:"Version cannot be zero".to_string(), }); } if subsignatures.is_empty() { return Err(AlgoKitTransactError::InvalidMultisigSignature { - message: "Subsignatures cannot be empty".to_string(), + err_msg:"Subsignatures cannot be empty".to_string(), }); } if threshold == 0 || threshold as usize > subsignatures.len() { - return Err(AlgoKitTransactError::InvalidMultisigSignature { message: "Threshold must be greater than zero and less than or equal to the number of sub-signers".to_string() }); + return Err(AlgoKitTransactError::InvalidMultisigSignature { err_msg:"Threshold must be greater than zero and less than or equal to the number of sub-signers".to_string() }); } Ok(Self { version, @@ -138,7 +138,7 @@ impl MultisigSignature { } if !found { return Err(AlgoKitTransactError::InvalidMultisigSignature { - message: "Address not found in multisig signature".to_string(), + err_msg:"Address not found in multisig signature".to_string(), }); } @@ -161,17 +161,17 @@ impl MultisigSignature { pub fn merge(&self, other: &Self) -> Result { if self.version != other.version { return Err(AlgoKitTransactError::InvalidMultisigSignature { - message: "Cannot merge multisig signatures with different versions".to_string(), + err_msg:"Cannot merge multisig signatures with different versions".to_string(), }); } if self.threshold != other.threshold { return Err(AlgoKitTransactError::InvalidMultisigSignature { - message: "Cannot merge multisig signatures with different thresholds".to_string(), + err_msg:"Cannot merge multisig signatures with different thresholds".to_string(), }); } if self.participants() != other.participants() { return Err(AlgoKitTransactError::InvalidMultisigSignature { - message: "Cannot merge multisig signatures with different participants".to_string(), + err_msg:"Cannot merge multisig signatures with different participants".to_string(), }); } diff --git a/crates/algokit_transact/src/traits.rs b/crates/algokit_transact/src/traits.rs index 423760e5f..16b6a7a87 100644 --- a/crates/algokit_transact/src/traits.rs +++ b/crates/algokit_transact/src/traits.rs @@ -63,7 +63,7 @@ pub trait AlgorandMsgpack: Serialize + for<'de> Deserialize<'de> { fn decode(bytes: &[u8]) -> Result { if bytes.is_empty() { return Err(AlgoKitTransactError::InputError { - message: "attempted to decode 0 bytes".to_string(), + err_msg:"attempted to decode 0 bytes".to_string(), }); } diff --git a/crates/algokit_transact/src/transactions/mod.rs b/crates/algokit_transact/src/transactions/mod.rs index f53b14b7c..506cc3411 100644 --- a/crates/algokit_transact/src/transactions/mod.rs +++ b/crates/algokit_transact/src/transactions/mod.rs @@ -115,7 +115,7 @@ impl Transaction { if let Some(max_fee) = request.max_fee { if calculated_fee > max_fee { return Err(AlgoKitTransactError::InputError { - message: format!( + err_msg:format!( "Transaction fee {} µALGO is greater than max fee {} µALGO", calculated_fee, max_fee ), @@ -207,7 +207,7 @@ impl AlgorandMsgpack for SignedTransaction { Ok(stxn) } _ => Err(AlgoKitTransactError::InputError { - message: format!( + err_msg:format!( "expected signed transaction to be a map, but got a: {:#?}", value.type_id() ), diff --git a/crates/algokit_transact/src/transactions/payment.rs b/crates/algokit_transact/src/transactions/payment.rs index ae38a5b4b..7572e7221 100644 --- a/crates/algokit_transact/src/transactions/payment.rs +++ b/crates/algokit_transact/src/transactions/payment.rs @@ -150,7 +150,7 @@ mod tests { let msg = format!("{}", err); assert!( msg == "Transaction fee 2470 µALGO is greater than max fee 1000 µALGO", - "Unexpected error message: {}", + "Unexpected error err_msg:{}", msg ); } diff --git a/crates/algokit_transact/src/utils.rs b/crates/algokit_transact/src/utils.rs index c42e4f66d..77110e632 100644 --- a/crates/algokit_transact/src/utils.rs +++ b/crates/algokit_transact/src/utils.rs @@ -106,13 +106,13 @@ pub fn hash(bytes: &Vec) -> Byte32 { pub fn compute_group(txs: &[Transaction]) -> Result { if txs.is_empty() { return Err(AlgoKitTransactError::InputError { - message: String::from("Transaction group size cannot be 0"), + err_msg:String::from("Transaction group size cannot be 0"), }); } if txs.len() > MAX_TX_GROUP_SIZE { return Err(AlgoKitTransactError::InputError { - message: format!( + err_msg:format!( "Transaction group size exceeds the max limit of {}", MAX_TX_GROUP_SIZE ), @@ -124,7 +124,7 @@ pub fn compute_group(txs: &[Transaction]) -> Result for AlgoKitTransactError { match e { algokit_transact::AlgoKitTransactError::DecodingError { .. } => { AlgoKitTransactError::DecodingError { - message: e.to_string(), + error_msg: e.to_string(), } } algokit_transact::AlgoKitTransactError::EncodingError { .. } => { AlgoKitTransactError::EncodingError { - message: e.to_string(), + error_msg: e.to_string(), } } algokit_transact::AlgoKitTransactError::MsgpackDecodingError { .. } => { AlgoKitTransactError::DecodingError { - message: e.to_string(), + error_msg: e.to_string(), } } algokit_transact::AlgoKitTransactError::MsgpackEncodingError { .. } => { AlgoKitTransactError::EncodingError { - message: e.to_string(), + error_msg: e.to_string(), } } algokit_transact::AlgoKitTransactError::UnknownTransactionType { .. } => { AlgoKitTransactError::DecodingError { - message: e.to_string(), + error_msg: e.to_string(), } } - algokit_transact::AlgoKitTransactError::InputError { message } => { - AlgoKitTransactError::InputError { message } + algokit_transact::AlgoKitTransactError::InputError { err_msg: message } => { + AlgoKitTransactError::InputError { error_msg: message } } algokit_transact::AlgoKitTransactError::InvalidAddress { .. } => { AlgoKitTransactError::DecodingError { - message: e.to_string(), + error_msg: e.to_string(), } } algokit_transact::AlgoKitTransactError::InvalidMultisigSignature { .. } => { AlgoKitTransactError::DecodingError { - message: e.to_string(), + error_msg: e.to_string(), } } } @@ -118,7 +118,7 @@ impl TryFrom for algokit_transact::KeyPairAccount { let pub_key: [u8; ALGORAND_PUBLIC_KEY_BYTE_LENGTH] = vec_to_array(&value.pub_key, "public key").map_err(|e| { AlgoKitTransactError::DecodingError { - message: format!("Error while decoding a public key: {}", e), + error_msg: format!("Error while decoding a public key: {}", e), } })?; @@ -212,7 +212,7 @@ impl TryFrom for algokit_transact::Transaction { > 1 { return Err(Self::Error::DecodingError { - message: "Multiple transaction type specific fields set".to_string(), + error_msg: "Multiple transaction type specific fields set".to_string(), }); } @@ -393,7 +393,7 @@ impl TryFrom for algokit_transact::SignedTransaction { .map(|sig| vec_to_array(&sig, "signature")) .transpose() .map_err(|e| AlgoKitTransactError::DecodingError { - message: format!( + error_msg: format!( "Error while decoding the signature in a signed transaction: {}", e ), @@ -417,7 +417,7 @@ fn vec_to_array( buf.to_vec() .try_into() .map_err(|_| AlgoKitTransactError::DecodingError { - message: format!( + error_msg: format!( "Expected {} {} bytes but got {} bytes", context, N, @@ -544,7 +544,7 @@ pub fn estimate_transaction_size(transaction: Transaction) -> Result Result for algokit_transact::MultisigSubsignature { .map(|sig| vec_to_array(&sig, "signature")) .transpose() .map_err(|e| AlgoKitTransactError::DecodingError { - message: format!("Error while decoding a subsignature: {}", e), + error_msg:format!("Error while decoding a subsignature: {}", e), })?, }) } @@ -143,7 +143,7 @@ pub fn apply_multisig_subsignature( subsignature .try_into() .map_err(|_| AlgoKitTransactError::EncodingError { - message: format!( + error_msg:format!( "signature should be {} bytes", ALGORAND_SIGNATURE_BYTE_LENGTH ), diff --git a/crates/algokit_transact_ffi/src/transactions/app_call.rs b/crates/algokit_transact_ffi/src/transactions/app_call.rs index f7075a070..a5966b42a 100644 --- a/crates/algokit_transact_ffi/src/transactions/app_call.rs +++ b/crates/algokit_transact_ffi/src/transactions/app_call.rs @@ -99,7 +99,7 @@ impl TryFrom for algokit_transact::AppCallTransactionFields { fn try_from(tx: Transaction) -> Result { if tx.transaction_type != TransactionType::AppCall || tx.app_call.is_none() { return Err(Self::Error::DecodingError { - message: "AppCall call data missing".to_string(), + error_msg:"AppCall call data missing".to_string(), }); } @@ -135,7 +135,7 @@ impl TryFrom for algokit_transact::AppCallTransactionFields { transaction_fields .validate() .map_err(|errors| AlgoKitTransactError::DecodingError { - message: format!("App call validation failed: {}", errors.join("\n")), + error_msg:format!("App call validation failed: {}", errors.join("\n")), })?; Ok(transaction_fields) diff --git a/crates/algokit_transact_ffi/src/transactions/asset_config.rs b/crates/algokit_transact_ffi/src/transactions/asset_config.rs index b962c3482..fbc4eddf4 100644 --- a/crates/algokit_transact_ffi/src/transactions/asset_config.rs +++ b/crates/algokit_transact_ffi/src/transactions/asset_config.rs @@ -139,7 +139,7 @@ impl TryFrom for algokit_transact::AssetConfigTransactionFields { fn try_from(tx: Transaction) -> Result { if tx.transaction_type != TransactionType::AssetConfig || tx.asset_config.is_none() { return Err(Self::Error::DecodingError { - message: "Asset configuration data missing".to_string(), + error_msg:"Asset configuration data missing".to_string(), }); } @@ -170,7 +170,7 @@ impl TryFrom for algokit_transact::AssetConfigTransactionFields { transaction_fields .validate() .map_err(|errors| AlgoKitTransactError::DecodingError { - message: format!("Asset config validation failed: {}", errors.join("\n")), + error_msg:format!("Asset config validation failed: {}", errors.join("\n")), })?; Ok(transaction_fields) diff --git a/crates/algokit_transact_ffi/src/transactions/asset_freeze.rs b/crates/algokit_transact_ffi/src/transactions/asset_freeze.rs index f5f0021fe..d5b1a6f61 100644 --- a/crates/algokit_transact_ffi/src/transactions/asset_freeze.rs +++ b/crates/algokit_transact_ffi/src/transactions/asset_freeze.rs @@ -35,7 +35,7 @@ impl TryFrom for algokit_transact::AssetFreezeTransactionFields { fn try_from(tx: Transaction) -> Result { if tx.transaction_type != TransactionType::AssetFreeze || tx.asset_freeze.is_none() { return Err(Self::Error::DecodingError { - message: "Asset Freeze data missing".to_string(), + error_msg:"Asset Freeze data missing".to_string(), }); } @@ -52,7 +52,7 @@ impl TryFrom for algokit_transact::AssetFreezeTransactionFields { transaction_fields .validate() .map_err(|errors| AlgoKitTransactError::DecodingError { - message: format!("Asset freeze validation failed: {}", errors.join(", ")), + error_msg:format!("Asset freeze validation failed: {}", errors.join(", ")), })?; Ok(transaction_fields) diff --git a/crates/algokit_transact_ffi/src/transactions/asset_transfer.rs b/crates/algokit_transact_ffi/src/transactions/asset_transfer.rs index 8bc32b014..74ee5d316 100644 --- a/crates/algokit_transact_ffi/src/transactions/asset_transfer.rs +++ b/crates/algokit_transact_ffi/src/transactions/asset_transfer.rs @@ -31,7 +31,7 @@ impl TryFrom for algokit_transact::AssetTransferTransactionFields { fn try_from(tx: Transaction) -> Result { if tx.transaction_type != TransactionType::AssetTransfer || tx.asset_transfer.is_none() { return Err(Self::Error::DecodingError { - message: "Asset Transfer data missing".to_string(), + error_msg:"Asset Transfer data missing".to_string(), }); } @@ -53,7 +53,7 @@ impl TryFrom for algokit_transact::AssetTransferTransactionFields { transaction_fields .validate() .map_err(|errors| AlgoKitTransactError::DecodingError { - message: format!("Asset transfer validation failed: {}", errors.join(", ")), + error_msg:format!("Asset transfer validation failed: {}", errors.join(", ")), })?; Ok(transaction_fields) diff --git a/crates/algokit_transact_ffi/src/transactions/key_registration.rs b/crates/algokit_transact_ffi/src/transactions/key_registration.rs index 14edd2ad9..b337ae578 100644 --- a/crates/algokit_transact_ffi/src/transactions/key_registration.rs +++ b/crates/algokit_transact_ffi/src/transactions/key_registration.rs @@ -50,7 +50,7 @@ impl TryFrom for algokit_transact::KeyRegistrationTransactio || tx.key_registration.is_none() { return Err(Self::Error::DecodingError { - message: "Key Registration data missing".to_string(), + error_msg:"Key Registration data missing".to_string(), }); } @@ -80,7 +80,7 @@ impl TryFrom for algokit_transact::KeyRegistrationTransactio transaction_fields .validate() .map_err(|errors| AlgoKitTransactError::DecodingError { - message: format!("Key registration validation failed: {}", errors.join("\n")), + error_msg:format!("Key registration validation failed: {}", errors.join("\n")), })?; Ok(transaction_fields) diff --git a/crates/algokit_transact_ffi/src/transactions/payment.rs b/crates/algokit_transact_ffi/src/transactions/payment.rs index 709992c03..c4475d6e9 100644 --- a/crates/algokit_transact_ffi/src/transactions/payment.rs +++ b/crates/algokit_transact_ffi/src/transactions/payment.rs @@ -25,7 +25,7 @@ impl TryFrom for algokit_transact::PaymentTransactionFields { fn try_from(tx: Transaction) -> Result { if tx.transaction_type != TransactionType::Payment || tx.payment.is_none() { return Err(Self::Error::DecodingError { - message: "Payment data missing".to_string(), + error_msg:"Payment data missing".to_string(), }); } diff --git a/packages/android/algokit_transact/.gitignore b/packages/android/algokit_transact/.gitignore new file mode 100644 index 000000000..58696bd62 --- /dev/null +++ b/packages/android/algokit_transact/.gitignore @@ -0,0 +1,17 @@ +*.iml +.gradle +**/local.properties +**/.idea/caches +**/.idea/libraries +**/.idea/misc.xml +**/.idea/modules.xml +**/.idea/workspace.xml +**/.idea/navEditor.xml +**/.idea/assetWizardSettings.xml +.DS_Store +**/build +**/captures +.externalNativeBuild +.cxx +local.properties + diff --git a/packages/android/algokit_transact/app/.gitignore b/packages/android/algokit_transact/app/.gitignore new file mode 100644 index 000000000..42afabfd2 --- /dev/null +++ b/packages/android/algokit_transact/app/.gitignore @@ -0,0 +1 @@ +/build \ No newline at end of file diff --git a/packages/android/algokit_transact/app/build.gradle.kts b/packages/android/algokit_transact/app/build.gradle.kts new file mode 100644 index 000000000..c35b652ff --- /dev/null +++ b/packages/android/algokit_transact/app/build.gradle.kts @@ -0,0 +1,75 @@ +plugins { + alias(libs.plugins.android.application) + alias(libs.plugins.kotlin.android) + alias(libs.plugins.compose.compiler) +} + +android { + namespace = "com.example.algokit_transact" + compileSdk = 36 + + defaultConfig { + applicationId = "com.example.algokit_transact" + minSdk = 28 + targetSdk = 36 + versionCode = 1 + versionName = "1.0" + + testInstrumentationRunner = "androidx.test.runner.AndroidJUnitRunner" + vectorDrawables { + useSupportLibrary = true + } + } + + buildTypes { + release { + isMinifyEnabled = false + proguardFiles( + getDefaultProguardFile("proguard-android-optimize.txt"), + "proguard-rules.pro" + ) + } + } + compileOptions { + sourceCompatibility = JavaVersion.VERSION_21 + targetCompatibility = JavaVersion.VERSION_21 + } + kotlinOptions { + jvmTarget = "21" + } + buildFeatures { + compose = true + } + composeOptions { + kotlinCompilerExtensionVersion = libs.versions.compose.compiler.get() + } + packaging { + resources { + excludes += "/META-INF/{AL2.0,LGPL2.1}" + } + } +} + +dependencies { + implementation(project(":transact")) + // implementation("com.example.transact:algo-transact-ffi:0.0.1") + implementation(libs.androidx.core.ktx) + implementation(libs.androidx.appcompat) + implementation(libs.material) + + // Compose dependencies + implementation(platform(libs.androidx.compose.bom)) + implementation(libs.androidx.compose.ui) + implementation(libs.androidx.compose.ui.graphics) + implementation(libs.androidx.compose.ui.tooling.preview) + implementation(libs.androidx.compose.material3) + implementation(libs.androidx.activity.compose) + implementation(libs.androidx.lifecycle.runtime.compose) + debugImplementation(libs.androidx.compose.ui.tooling) + + testImplementation(libs.junit) + androidTestImplementation(libs.androidx.junit) + androidTestImplementation(libs.androidx.espresso.core) + androidTestImplementation(platform(libs.androidx.compose.bom)) + androidTestImplementation(libs.androidx.compose.ui.test.junit4) +} diff --git a/packages/android/algokit_transact/app/proguard-rules.pro b/packages/android/algokit_transact/app/proguard-rules.pro new file mode 100644 index 000000000..481bb4348 --- /dev/null +++ b/packages/android/algokit_transact/app/proguard-rules.pro @@ -0,0 +1,21 @@ +# Add project specific ProGuard rules here. +# You can control the set of applied configuration files using the +# proguardFiles setting in build.gradle. +# +# For more details, see +# http://developer.android.com/guide/developing/tools/proguard.html + +# If your project uses WebView with JS, uncomment the following +# and specify the fully qualified class name to the JavaScript interface +# class: +#-keepclassmembers class fqcn.of.javascript.interface.for.webview { +# public *; +#} + +# Uncomment this to preserve the line number information for +# debugging stack traces. +#-keepattributes SourceFile,LineNumberTable + +# If you keep the line number information, uncomment this to +# hide the original source file name. +#-renamesourcefileattribute SourceFile \ No newline at end of file diff --git a/packages/android/algokit_transact/app/src/androidTest/kotlin/com/example/algokit_transact/ExampleInstrumentedTest.kt b/packages/android/algokit_transact/app/src/androidTest/kotlin/com/example/algokit_transact/ExampleInstrumentedTest.kt new file mode 100644 index 000000000..ad1d4415e --- /dev/null +++ b/packages/android/algokit_transact/app/src/androidTest/kotlin/com/example/algokit_transact/ExampleInstrumentedTest.kt @@ -0,0 +1,24 @@ +package com.example.algokit_transact + +import androidx.test.platform.app.InstrumentationRegistry +import androidx.test.ext.junit.runners.AndroidJUnit4 + +import org.junit.Test +import org.junit.runner.RunWith + +import org.junit.Assert.* + +/** + * Instrumented test, which will execute on an Android device. + * + * See [testing documentation](http://d.android.com/tools/testing). + */ +@RunWith(AndroidJUnit4::class) +class ExampleInstrumentedTest { + @Test + fun useAppContext() { + // Context of the app under test. + val appContext = InstrumentationRegistry.getInstrumentation().targetContext + assertEquals("com.example.algokit_transact", appContext.packageName) + } +} \ No newline at end of file diff --git a/packages/android/algokit_transact/app/src/main/AndroidManifest.xml b/packages/android/algokit_transact/app/src/main/AndroidManifest.xml new file mode 100644 index 000000000..93949a971 --- /dev/null +++ b/packages/android/algokit_transact/app/src/main/AndroidManifest.xml @@ -0,0 +1,29 @@ + + + + + + + + + + + + + + + \ No newline at end of file diff --git a/packages/android/algokit_transact/app/src/main/kotlin/com.example.algokit_transact/MainActivity.kt b/packages/android/algokit_transact/app/src/main/kotlin/com.example.algokit_transact/MainActivity.kt new file mode 100644 index 000000000..302c6e6d5 --- /dev/null +++ b/packages/android/algokit_transact/app/src/main/kotlin/com.example.algokit_transact/MainActivity.kt @@ -0,0 +1,74 @@ +package com.example.algokit_transact + +import android.os.Bundle +import androidx.activity.ComponentActivity +import androidx.activity.compose.setContent +import androidx.compose.foundation.layout.Box +import androidx.compose.foundation.layout.fillMaxSize +import androidx.compose.material3.MaterialTheme +import androidx.compose.material3.Surface +import androidx.compose.material3.Text +import androidx.compose.runtime.Composable +import androidx.compose.ui.Alignment +import androidx.compose.ui.Modifier +import androidx.compose.ui.tooling.preview.Preview +import com.example.transact.TransactApi + +class MainActivity : ComponentActivity() { + override fun onCreate(savedInstanceState: Bundle?) { + super.onCreate(savedInstanceState) + setContent { + HelloWorldTheme { + // A surface container using the 'background' color from the theme + Surface( + modifier = Modifier.fillMaxSize(), + color = MaterialTheme.colorScheme.background + ) { + val address = TransactApi() + .getPubKeyFromAddress("YVRRLLVBX54N44WG4EZJWPXXA6RROAU5TLHB4XHCMZFVZBVCB6KSDWDSEQ") + Greeting(address.toString()) + } + } + } + } +} + +@Composable +fun Greeting(name: String, modifier: Modifier = Modifier) { + Box( + modifier = Modifier.fillMaxSize(), + contentAlignment = Alignment.Center + ) { + Text( + text = "Hello $name!", + modifier = modifier, + style = MaterialTheme.typography.headlineMedium + ) + } +} + +@Composable +fun HelloWorldTheme( + darkTheme: Boolean = false, + content: @Composable () -> Unit +) { + val colorScheme = when { + darkTheme -> MaterialTheme.colorScheme.copy( + surface = MaterialTheme.colorScheme.surfaceVariant + ) + else -> MaterialTheme.colorScheme + } + MaterialTheme( + colorScheme = colorScheme, + typography = MaterialTheme.typography, + content = content + ) +} + +@Preview(showBackground = true) +@Composable +fun GreetingPreview() { + HelloWorldTheme { + Greeting("Android") + } +} diff --git a/packages/android/algokit_transact/app/src/main/res/drawable/ic_launcher_background.xml b/packages/android/algokit_transact/app/src/main/res/drawable/ic_launcher_background.xml new file mode 100644 index 000000000..07d5da9cb --- /dev/null +++ b/packages/android/algokit_transact/app/src/main/res/drawable/ic_launcher_background.xml @@ -0,0 +1,170 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/packages/android/algokit_transact/app/src/main/res/drawable/ic_launcher_foreground.xml b/packages/android/algokit_transact/app/src/main/res/drawable/ic_launcher_foreground.xml new file mode 100644 index 000000000..2b068d114 --- /dev/null +++ b/packages/android/algokit_transact/app/src/main/res/drawable/ic_launcher_foreground.xml @@ -0,0 +1,30 @@ + + + + + + + + + + + \ No newline at end of file diff --git a/packages/android/algokit_transact/app/src/main/res/mipmap-anydpi-v26/ic_launcher.xml b/packages/android/algokit_transact/app/src/main/res/mipmap-anydpi-v26/ic_launcher.xml new file mode 100644 index 000000000..6f3b755bf --- /dev/null +++ b/packages/android/algokit_transact/app/src/main/res/mipmap-anydpi-v26/ic_launcher.xml @@ -0,0 +1,6 @@ + + + + + + \ No newline at end of file diff --git a/packages/android/algokit_transact/app/src/main/res/mipmap-anydpi-v26/ic_launcher_round.xml b/packages/android/algokit_transact/app/src/main/res/mipmap-anydpi-v26/ic_launcher_round.xml new file mode 100644 index 000000000..6f3b755bf --- /dev/null +++ b/packages/android/algokit_transact/app/src/main/res/mipmap-anydpi-v26/ic_launcher_round.xml @@ -0,0 +1,6 @@ + + + + + + \ No newline at end of file diff --git a/packages/android/algokit_transact/app/src/main/res/mipmap-hdpi/ic_launcher.webp b/packages/android/algokit_transact/app/src/main/res/mipmap-hdpi/ic_launcher.webp new file mode 100644 index 000000000..c209e78ec Binary files /dev/null and b/packages/android/algokit_transact/app/src/main/res/mipmap-hdpi/ic_launcher.webp differ diff --git a/packages/android/algokit_transact/app/src/main/res/mipmap-hdpi/ic_launcher_round.webp b/packages/android/algokit_transact/app/src/main/res/mipmap-hdpi/ic_launcher_round.webp new file mode 100644 index 000000000..b2dfe3d1b Binary files /dev/null and b/packages/android/algokit_transact/app/src/main/res/mipmap-hdpi/ic_launcher_round.webp differ diff --git a/packages/android/algokit_transact/app/src/main/res/mipmap-mdpi/ic_launcher.webp b/packages/android/algokit_transact/app/src/main/res/mipmap-mdpi/ic_launcher.webp new file mode 100644 index 000000000..4f0f1d64e Binary files /dev/null and b/packages/android/algokit_transact/app/src/main/res/mipmap-mdpi/ic_launcher.webp differ diff --git a/packages/android/algokit_transact/app/src/main/res/mipmap-mdpi/ic_launcher_round.webp b/packages/android/algokit_transact/app/src/main/res/mipmap-mdpi/ic_launcher_round.webp new file mode 100644 index 000000000..62b611da0 Binary files /dev/null and b/packages/android/algokit_transact/app/src/main/res/mipmap-mdpi/ic_launcher_round.webp differ diff --git a/packages/android/algokit_transact/app/src/main/res/mipmap-xhdpi/ic_launcher.webp b/packages/android/algokit_transact/app/src/main/res/mipmap-xhdpi/ic_launcher.webp new file mode 100644 index 000000000..948a3070f Binary files /dev/null and b/packages/android/algokit_transact/app/src/main/res/mipmap-xhdpi/ic_launcher.webp differ diff --git a/packages/android/algokit_transact/app/src/main/res/mipmap-xhdpi/ic_launcher_round.webp b/packages/android/algokit_transact/app/src/main/res/mipmap-xhdpi/ic_launcher_round.webp new file mode 100644 index 000000000..1b9a6956b Binary files /dev/null and b/packages/android/algokit_transact/app/src/main/res/mipmap-xhdpi/ic_launcher_round.webp differ diff --git a/packages/android/algokit_transact/app/src/main/res/mipmap-xxhdpi/ic_launcher.webp b/packages/android/algokit_transact/app/src/main/res/mipmap-xxhdpi/ic_launcher.webp new file mode 100644 index 000000000..28d4b77f9 Binary files /dev/null and b/packages/android/algokit_transact/app/src/main/res/mipmap-xxhdpi/ic_launcher.webp differ diff --git a/packages/android/algokit_transact/app/src/main/res/mipmap-xxhdpi/ic_launcher_round.webp b/packages/android/algokit_transact/app/src/main/res/mipmap-xxhdpi/ic_launcher_round.webp new file mode 100644 index 000000000..9287f5083 Binary files /dev/null and b/packages/android/algokit_transact/app/src/main/res/mipmap-xxhdpi/ic_launcher_round.webp differ diff --git a/packages/android/algokit_transact/app/src/main/res/mipmap-xxxhdpi/ic_launcher.webp b/packages/android/algokit_transact/app/src/main/res/mipmap-xxxhdpi/ic_launcher.webp new file mode 100644 index 000000000..aa7d6427e Binary files /dev/null and b/packages/android/algokit_transact/app/src/main/res/mipmap-xxxhdpi/ic_launcher.webp differ diff --git a/packages/android/algokit_transact/app/src/main/res/mipmap-xxxhdpi/ic_launcher_round.webp b/packages/android/algokit_transact/app/src/main/res/mipmap-xxxhdpi/ic_launcher_round.webp new file mode 100644 index 000000000..9126ae37c Binary files /dev/null and b/packages/android/algokit_transact/app/src/main/res/mipmap-xxxhdpi/ic_launcher_round.webp differ diff --git a/packages/android/algokit_transact/app/src/main/res/values-night/themes.xml b/packages/android/algokit_transact/app/src/main/res/values-night/themes.xml new file mode 100644 index 000000000..d099a13f3 --- /dev/null +++ b/packages/android/algokit_transact/app/src/main/res/values-night/themes.xml @@ -0,0 +1,16 @@ + + + + \ No newline at end of file diff --git a/packages/android/algokit_transact/app/src/main/res/values/colors.xml b/packages/android/algokit_transact/app/src/main/res/values/colors.xml new file mode 100644 index 000000000..f8c6127d3 --- /dev/null +++ b/packages/android/algokit_transact/app/src/main/res/values/colors.xml @@ -0,0 +1,10 @@ + + + #FFBB86FC + #FF6200EE + #FF3700B3 + #FF03DAC5 + #FF018786 + #FF000000 + #FFFFFFFF + \ No newline at end of file diff --git a/packages/android/algokit_transact/app/src/main/res/values/strings.xml b/packages/android/algokit_transact/app/src/main/res/values/strings.xml new file mode 100644 index 000000000..10b595183 --- /dev/null +++ b/packages/android/algokit_transact/app/src/main/res/values/strings.xml @@ -0,0 +1,3 @@ + + algokit_transact + \ No newline at end of file diff --git a/packages/android/algokit_transact/app/src/main/res/values/themes.xml b/packages/android/algokit_transact/app/src/main/res/values/themes.xml new file mode 100644 index 000000000..617f5e9b2 --- /dev/null +++ b/packages/android/algokit_transact/app/src/main/res/values/themes.xml @@ -0,0 +1,16 @@ + + + + \ No newline at end of file diff --git a/packages/android/algokit_transact/app/src/main/res/xml/backup_rules.xml b/packages/android/algokit_transact/app/src/main/res/xml/backup_rules.xml new file mode 100644 index 000000000..4df925582 --- /dev/null +++ b/packages/android/algokit_transact/app/src/main/res/xml/backup_rules.xml @@ -0,0 +1,13 @@ + + + + \ No newline at end of file diff --git a/packages/android/algokit_transact/app/src/main/res/xml/data_extraction_rules.xml b/packages/android/algokit_transact/app/src/main/res/xml/data_extraction_rules.xml new file mode 100644 index 000000000..9ee9997b0 --- /dev/null +++ b/packages/android/algokit_transact/app/src/main/res/xml/data_extraction_rules.xml @@ -0,0 +1,19 @@ + + + + + + + \ No newline at end of file diff --git a/packages/android/algokit_transact/app/src/test/kotlin/com/example/algokit_transact/ExampleUnitTest.kt b/packages/android/algokit_transact/app/src/test/kotlin/com/example/algokit_transact/ExampleUnitTest.kt new file mode 100644 index 000000000..9aad49b49 --- /dev/null +++ b/packages/android/algokit_transact/app/src/test/kotlin/com/example/algokit_transact/ExampleUnitTest.kt @@ -0,0 +1,17 @@ +package com.example.algokit_transact + +import org.junit.Test + +import org.junit.Assert.* + +/** + * Example local unit test, which will execute on the development machine (host). + * + * See [testing documentation](http://d.android.com/tools/testing). + */ +class ExampleUnitTest { + @Test + fun addition_isCorrect() { + assertEquals(4, 2 + 2) + } +} \ No newline at end of file diff --git a/packages/android/algokit_transact/build.gradle.kts b/packages/android/algokit_transact/build.gradle.kts new file mode 100644 index 000000000..a81b2692c --- /dev/null +++ b/packages/android/algokit_transact/build.gradle.kts @@ -0,0 +1,7 @@ +// Top-level build file where you can add configuration options common to all sub-projects/modules. +plugins { + alias(libs.plugins.android.application) apply false + alias(libs.plugins.kotlin.android) apply false + alias(libs.plugins.android.library) apply false + alias(libs.plugins.compose.compiler) apply false +} \ No newline at end of file diff --git a/packages/android/algokit_transact/gradle.properties b/packages/android/algokit_transact/gradle.properties new file mode 100644 index 000000000..20e2a0152 --- /dev/null +++ b/packages/android/algokit_transact/gradle.properties @@ -0,0 +1,23 @@ +# Project-wide Gradle settings. +# IDE (e.g. Android Studio) users: +# Gradle settings configured through the IDE *will override* +# any settings specified in this file. +# For more details on how to configure your build environment visit +# http://www.gradle.org/docs/current/userguide/build_environment.html +# Specifies the JVM arguments used for the daemon process. +# The setting is particularly useful for tweaking memory settings. +org.gradle.jvmargs=-Xmx2048m -Dfile.encoding=UTF-8 +# When configured, Gradle will run in incubating parallel mode. +# This option should only be used with decoupled projects. For more details, visit +# https://developer.android.com/r/tools/gradle-multi-project-decoupled-projects +# org.gradle.parallel=true +# AndroidX package structure to make it clearer which packages are bundled with the +# Android operating system, and which are packaged with your app's APK +# https://developer.android.com/topic/libraries/support-library/androidx-rn +android.useAndroidX=true +# Kotlin code style for this project: "official" or "obsolete": +kotlin.code.style=official +# Enables namespacing of each library's R class so that its R class includes only the +# resources declared in the library itself and none from the library's dependencies, +# thereby reducing the size of the R class for that library +android.nonTransitiveRClass=true \ No newline at end of file diff --git a/packages/android/algokit_transact/gradle/libs.versions.toml b/packages/android/algokit_transact/gradle/libs.versions.toml new file mode 100644 index 000000000..b95db5d7d --- /dev/null +++ b/packages/android/algokit_transact/gradle/libs.versions.toml @@ -0,0 +1,41 @@ +[versions] +agp = "8.12.3" +kotlin = "2.2.20" +coreKtx = "1.17.0" +junit = "4.13.2" +junitVersion = "1.3.0" +espressoCore = "3.7.0" +appcompat = "1.7.1" +kotlinxCoroutinesCore = "1.10.2" +material = "1.13.0" +compose-bom = "2025.09.00" +compose-compiler = "2.0.21" +activity-compose = "1.11.0" +lifecycle-runtime-compose = "2.9.4" + +[libraries] +androidx-core-ktx = { group = "androidx.core", name = "core-ktx", version.ref = "coreKtx" } +junit = { group = "junit", name = "junit", version.ref = "junit" } +androidx-junit = { group = "androidx.test.ext", name = "junit", version.ref = "junitVersion" } +androidx-espresso-core = { group = "androidx.test.espresso", name = "espresso-core", version.ref = "espressoCore" } +androidx-appcompat = { group = "androidx.appcompat", name = "appcompat", version.ref = "appcompat" } +kotlinx-coroutines-core = { module = "org.jetbrains.kotlinx:kotlinx-coroutines-core", version.ref = "kotlinxCoroutinesCore" } +material = { group = "com.google.android.material", name = "material", version.ref = "material" } + +# Compose dependencies +androidx-compose-bom = { group = "androidx.compose", name = "compose-bom", version.ref = "compose-bom" } +androidx-compose-ui = { group = "androidx.compose.ui", name = "ui" } +androidx-compose-ui-graphics = { group = "androidx.compose.ui", name = "ui-graphics" } +androidx-compose-ui-tooling-preview = { group = "androidx.compose.ui", name = "ui-tooling-preview" } +androidx-compose-material3 = { group = "androidx.compose.material3", name = "material3" } +androidx-compose-ui-tooling = { group = "androidx.compose.ui", name = "ui-tooling" } +androidx-compose-ui-test-junit4 = { group = "androidx.compose.ui", name = "ui-test-junit4" } +androidx-activity-compose = { group = "androidx.activity", name = "activity-compose", version.ref = "activity-compose" } +androidx-lifecycle-runtime-compose = { group = "androidx.lifecycle", name = "lifecycle-runtime-compose", version.ref = "lifecycle-runtime-compose" } + +[plugins] +android-application = { id = "com.android.application", version.ref = "agp" } +android-library = { id = "com.android.library", version.ref = "agp" } +kotlin-android = { id = "org.jetbrains.kotlin.android", version.ref = "kotlin" } +compose-compiler = { id = "org.jetbrains.kotlin.plugin.compose", version.ref = "kotlin" } + diff --git a/packages/android/algokit_transact/gradle/wrapper/gradle-wrapper.jar b/packages/android/algokit_transact/gradle/wrapper/gradle-wrapper.jar new file mode 100644 index 000000000..a4b76b953 Binary files /dev/null and b/packages/android/algokit_transact/gradle/wrapper/gradle-wrapper.jar differ diff --git a/packages/android/algokit_transact/gradle/wrapper/gradle-wrapper.properties b/packages/android/algokit_transact/gradle/wrapper/gradle-wrapper.properties new file mode 100644 index 000000000..db6d989f5 --- /dev/null +++ b/packages/android/algokit_transact/gradle/wrapper/gradle-wrapper.properties @@ -0,0 +1,6 @@ +#Wed May 07 17:07:13 EDT 2025 +distributionBase=GRADLE_USER_HOME +distributionPath=wrapper/dists +distributionUrl=https\://services.gradle.org/distributions/gradle-8.14.3-bin.zip +zipStoreBase=GRADLE_USER_HOME +zipStorePath=wrapper/dists diff --git a/packages/android/algokit_transact/gradlew b/packages/android/algokit_transact/gradlew new file mode 100755 index 000000000..4f906e0c8 --- /dev/null +++ b/packages/android/algokit_transact/gradlew @@ -0,0 +1,185 @@ +#!/usr/bin/env sh + +# +# Copyright 2015 the original author or authors. +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# https://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. +# + +############################################################################## +## +## Gradle start up script for UN*X +## +############################################################################## + +# Attempt to set APP_HOME +# Resolve links: $0 may be a link +PRG="$0" +# Need this for relative symlinks. +while [ -h "$PRG" ] ; do + ls=`ls -ld "$PRG"` + link=`expr "$ls" : '.*-> \(.*\)$'` + if expr "$link" : '/.*' > /dev/null; then + PRG="$link" + else + PRG=`dirname "$PRG"`"/$link" + fi +done +SAVED="`pwd`" +cd "`dirname \"$PRG\"`/" >/dev/null +APP_HOME="`pwd -P`" +cd "$SAVED" >/dev/null + +APP_NAME="Gradle" +APP_BASE_NAME=`basename "$0"` + +# Add default JVM options here. You can also use JAVA_OPTS and GRADLE_OPTS to pass JVM options to this script. +DEFAULT_JVM_OPTS='"-Xmx64m" "-Xms64m"' + +# Use the maximum available, or set MAX_FD != -1 to use that value. +MAX_FD="maximum" + +warn () { + echo "$*" +} + +die () { + echo + echo "$*" + echo + exit 1 +} + +# OS specific support (must be 'true' or 'false'). +cygwin=false +msys=false +darwin=false +nonstop=false +case "`uname`" in + CYGWIN* ) + cygwin=true + ;; + Darwin* ) + darwin=true + ;; + MINGW* ) + msys=true + ;; + NONSTOP* ) + nonstop=true + ;; +esac + +CLASSPATH=$APP_HOME/gradle/wrapper/gradle-wrapper.jar + + +# Determine the Java command to use to start the JVM. +if [ -n "$JAVA_HOME" ] ; then + if [ -x "$JAVA_HOME/jre/sh/java" ] ; then + # IBM's JDK on AIX uses strange locations for the executables + JAVACMD="$JAVA_HOME/jre/sh/java" + else + JAVACMD="$JAVA_HOME/bin/java" + fi + if [ ! -x "$JAVACMD" ] ; then + die "ERROR: JAVA_HOME is set to an invalid directory: $JAVA_HOME + +Please set the JAVA_HOME variable in your environment to match the +location of your Java installation." + fi +else + JAVACMD="java" + which java >/dev/null 2>&1 || die "ERROR: JAVA_HOME is not set and no 'java' command could be found in your PATH. + +Please set the JAVA_HOME variable in your environment to match the +location of your Java installation." +fi + +# Increase the maximum file descriptors if we can. +if [ "$cygwin" = "false" -a "$darwin" = "false" -a "$nonstop" = "false" ] ; then + MAX_FD_LIMIT=`ulimit -H -n` + if [ $? -eq 0 ] ; then + if [ "$MAX_FD" = "maximum" -o "$MAX_FD" = "max" ] ; then + MAX_FD="$MAX_FD_LIMIT" + fi + ulimit -n $MAX_FD + if [ $? -ne 0 ] ; then + warn "Could not set maximum file descriptor limit: $MAX_FD" + fi + else + warn "Could not query maximum file descriptor limit: $MAX_FD_LIMIT" + fi +fi + +# For Darwin, add options to specify how the application appears in the dock +if $darwin; then + GRADLE_OPTS="$GRADLE_OPTS \"-Xdock:name=$APP_NAME\" \"-Xdock:icon=$APP_HOME/media/gradle.icns\"" +fi + +# For Cygwin or MSYS, switch paths to Windows format before running java +if [ "$cygwin" = "true" -o "$msys" = "true" ] ; then + APP_HOME=`cygpath --path --mixed "$APP_HOME"` + CLASSPATH=`cygpath --path --mixed "$CLASSPATH"` + + JAVACMD=`cygpath --unix "$JAVACMD"` + + # We build the pattern for arguments to be converted via cygpath + ROOTDIRSRAW=`find -L / -maxdepth 1 -mindepth 1 -type d 2>/dev/null` + SEP="" + for dir in $ROOTDIRSRAW ; do + ROOTDIRS="$ROOTDIRS$SEP$dir" + SEP="|" + done + OURCYGPATTERN="(^($ROOTDIRS))" + # Add a user-defined pattern to the cygpath arguments + if [ "$GRADLE_CYGPATTERN" != "" ] ; then + OURCYGPATTERN="$OURCYGPATTERN|($GRADLE_CYGPATTERN)" + fi + # Now convert the arguments - kludge to limit ourselves to /bin/sh + i=0 + for arg in "$@" ; do + CHECK=`echo "$arg"|egrep -c "$OURCYGPATTERN" -` + CHECK2=`echo "$arg"|egrep -c "^-"` ### Determine if an option + + if [ $CHECK -ne 0 ] && [ $CHECK2 -eq 0 ] ; then ### Added a condition + eval `echo args$i`=`cygpath --path --ignore --mixed "$arg"` + else + eval `echo args$i`="\"$arg\"" + fi + i=`expr $i + 1` + done + case $i in + 0) set -- ;; + 1) set -- "$args0" ;; + 2) set -- "$args0" "$args1" ;; + 3) set -- "$args0" "$args1" "$args2" ;; + 4) set -- "$args0" "$args1" "$args2" "$args3" ;; + 5) set -- "$args0" "$args1" "$args2" "$args3" "$args4" ;; + 6) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" ;; + 7) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" "$args6" ;; + 8) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" "$args6" "$args7" ;; + 9) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" "$args6" "$args7" "$args8" ;; + esac +fi + +# Escape application args +save () { + for i do printf %s\\n "$i" | sed "s/'/'\\\\''/g;1s/^/'/;\$s/\$/' \\\\/" ; done + echo " " +} +APP_ARGS=`save "$@"` + +# Collect all arguments for the java command, following the shell quoting and substitution rules +eval set -- $DEFAULT_JVM_OPTS $JAVA_OPTS $GRADLE_OPTS "\"-Dorg.gradle.appname=$APP_BASE_NAME\"" -classpath "\"$CLASSPATH\"" org.gradle.wrapper.GradleWrapperMain "$APP_ARGS" + +exec "$JAVACMD" "$@" diff --git a/packages/android/algokit_transact/gradlew.bat b/packages/android/algokit_transact/gradlew.bat new file mode 100644 index 000000000..ac1b06f93 --- /dev/null +++ b/packages/android/algokit_transact/gradlew.bat @@ -0,0 +1,89 @@ +@rem +@rem Copyright 2015 the original author or authors. +@rem +@rem Licensed under the Apache License, Version 2.0 (the "License"); +@rem you may not use this file except in compliance with the License. +@rem You may obtain a copy of the License at +@rem +@rem https://www.apache.org/licenses/LICENSE-2.0 +@rem +@rem Unless required by applicable law or agreed to in writing, software +@rem distributed under the License is distributed on an "AS IS" BASIS, +@rem WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +@rem See the License for the specific language governing permissions and +@rem limitations under the License. +@rem + +@if "%DEBUG%" == "" @echo off +@rem ########################################################################## +@rem +@rem Gradle startup script for Windows +@rem +@rem ########################################################################## + +@rem Set local scope for the variables with windows NT shell +if "%OS%"=="Windows_NT" setlocal + +set DIRNAME=%~dp0 +if "%DIRNAME%" == "" set DIRNAME=. +set APP_BASE_NAME=%~n0 +set APP_HOME=%DIRNAME% + +@rem Resolve any "." and ".." in APP_HOME to make it shorter. +for %%i in ("%APP_HOME%") do set APP_HOME=%%~fi + +@rem Add default JVM options here. You can also use JAVA_OPTS and GRADLE_OPTS to pass JVM options to this script. +set DEFAULT_JVM_OPTS="-Xmx64m" "-Xms64m" + +@rem Find java.exe +if defined JAVA_HOME goto findJavaFromJavaHome + +set JAVA_EXE=java.exe +%JAVA_EXE% -version >NUL 2>&1 +if "%ERRORLEVEL%" == "0" goto execute + +echo. +echo ERROR: JAVA_HOME is not set and no 'java' command could be found in your PATH. +echo. +echo Please set the JAVA_HOME variable in your environment to match the +echo location of your Java installation. + +goto fail + +:findJavaFromJavaHome +set JAVA_HOME=%JAVA_HOME:"=% +set JAVA_EXE=%JAVA_HOME%/bin/java.exe + +if exist "%JAVA_EXE%" goto execute + +echo. +echo ERROR: JAVA_HOME is set to an invalid directory: %JAVA_HOME% +echo. +echo Please set the JAVA_HOME variable in your environment to match the +echo location of your Java installation. + +goto fail + +:execute +@rem Setup the command line + +set CLASSPATH=%APP_HOME%\gradle\wrapper\gradle-wrapper.jar + + +@rem Execute Gradle +"%JAVA_EXE%" %DEFAULT_JVM_OPTS% %JAVA_OPTS% %GRADLE_OPTS% "-Dorg.gradle.appname=%APP_BASE_NAME%" -classpath "%CLASSPATH%" org.gradle.wrapper.GradleWrapperMain %* + +:end +@rem End local scope for the variables with windows NT shell +if "%ERRORLEVEL%"=="0" goto mainEnd + +:fail +rem Set variable GRADLE_EXIT_CONSOLE if you need the _script_ return code instead of +rem the _cmd.exe /c_ return code! +if not "" == "%GRADLE_EXIT_CONSOLE%" exit 1 +exit /b 1 + +:mainEnd +if "%OS%"=="Windows_NT" endlocal + +:omega diff --git a/packages/android/algokit_transact/settings.gradle.kts b/packages/android/algokit_transact/settings.gradle.kts new file mode 100644 index 000000000..b1201a849 --- /dev/null +++ b/packages/android/algokit_transact/settings.gradle.kts @@ -0,0 +1,26 @@ +pluginManagement { + repositories { + google { + content { + includeGroupByRegex("com\\.android.*") + includeGroupByRegex("com\\.google.*") + includeGroupByRegex("androidx.*") + } + } + mavenCentral() + gradlePluginPortal() + } +} +dependencyResolutionManagement { + repositoriesMode.set(RepositoriesMode.FAIL_ON_PROJECT_REPOS) + repositories { + mavenLocal() + google() + mavenCentral() + } +} + +rootProject.name = "algokit_transact" +include(":app") +include(":transact") + \ No newline at end of file diff --git a/packages/android/algokit_transact/transact/.gitignore b/packages/android/algokit_transact/transact/.gitignore new file mode 100644 index 000000000..42afabfd2 --- /dev/null +++ b/packages/android/algokit_transact/transact/.gitignore @@ -0,0 +1 @@ +/build \ No newline at end of file diff --git a/packages/android/algokit_transact/transact/build.gradle.kts b/packages/android/algokit_transact/transact/build.gradle.kts new file mode 100644 index 000000000..0101b6963 --- /dev/null +++ b/packages/android/algokit_transact/transact/build.gradle.kts @@ -0,0 +1,68 @@ +plugins { + alias(libs.plugins.android.library) + alias(libs.plugins.kotlin.android) + `maven-publish` +} + +android { + namespace = "com.example.transact" + compileSdk = 36 + ndkVersion = "29.0.13113456" + + defaultConfig { + minSdk = 28 + ndk { + abiFilters += listOf("arm64-v8a", "armeabi-v7a", "x86_64") + } + testInstrumentationRunner = "androidx.test.runner.AndroidJUnitRunner" + consumerProguardFiles("consumer-rules.pro") + } + + buildTypes { + release { + isMinifyEnabled = false + proguardFiles( + getDefaultProguardFile("proguard-android-optimize.txt"), + "proguard-rules.pro" + ) + } + } + compileOptions { + sourceCompatibility = JavaVersion.VERSION_21 + targetCompatibility = JavaVersion.VERSION_21 + } + kotlinOptions { + jvmTarget = "21" + } + publishing { + singleVariant("release") { + withSourcesJar() + withJavadocJar() + } + } +} + +dependencies { + implementation("net.java.dev.jna:jna:5.17.0@aar") + implementation(libs.kotlinx.coroutines.core) + implementation(libs.androidx.core.ktx) + implementation(libs.androidx.appcompat) + implementation(libs.material) + testImplementation(libs.junit) + androidTestImplementation(libs.androidx.junit) + androidTestImplementation(libs.androidx.espresso.core) +} + +publishing { + publications { + register("release") { + groupId = "com.example.transact" + artifactId = "algo-transact-ffi" + version = "0.0.2" + + afterEvaluate { + from(components["release"]) + } + } + } +} diff --git a/packages/android/algokit_transact/transact/consumer-rules.pro b/packages/android/algokit_transact/transact/consumer-rules.pro new file mode 100644 index 000000000..e69de29bb diff --git a/packages/android/algokit_transact/transact/proguard-rules.pro b/packages/android/algokit_transact/transact/proguard-rules.pro new file mode 100644 index 000000000..481bb4348 --- /dev/null +++ b/packages/android/algokit_transact/transact/proguard-rules.pro @@ -0,0 +1,21 @@ +# Add project specific ProGuard rules here. +# You can control the set of applied configuration files using the +# proguardFiles setting in build.gradle. +# +# For more details, see +# http://developer.android.com/guide/developing/tools/proguard.html + +# If your project uses WebView with JS, uncomment the following +# and specify the fully qualified class name to the JavaScript interface +# class: +#-keepclassmembers class fqcn.of.javascript.interface.for.webview { +# public *; +#} + +# Uncomment this to preserve the line number information for +# debugging stack traces. +#-keepattributes SourceFile,LineNumberTable + +# If you keep the line number information, uncomment this to +# hide the original source file name. +#-renamesourcefileattribute SourceFile \ No newline at end of file diff --git a/packages/android/algokit_transact/transact/src/androidTest/kotlin/com/example/transact/ExampleInstrumentedTest.kt b/packages/android/algokit_transact/transact/src/androidTest/kotlin/com/example/transact/ExampleInstrumentedTest.kt new file mode 100644 index 000000000..afd2e8a2c --- /dev/null +++ b/packages/android/algokit_transact/transact/src/androidTest/kotlin/com/example/transact/ExampleInstrumentedTest.kt @@ -0,0 +1,24 @@ +package com.example.transact + +import androidx.test.platform.app.InstrumentationRegistry +import androidx.test.ext.junit.runners.AndroidJUnit4 + +import org.junit.Test +import org.junit.runner.RunWith + +import org.junit.Assert.* + +/** + * Instrumented test, which will execute on an Android device. + * + * See [testing documentation](http://d.android.com/tools/testing). + */ +@RunWith(AndroidJUnit4::class) +class ExampleInstrumentedTest { + @Test + fun useAppContext() { + // Context of the app under test. + val appContext = InstrumentationRegistry.getInstrumentation().targetContext + assertEquals("com.example.transact.test", appContext.packageName) + } +} \ No newline at end of file diff --git a/packages/android/algokit_transact/transact/src/main/AndroidManifest.xml b/packages/android/algokit_transact/transact/src/main/AndroidManifest.xml new file mode 100644 index 000000000..a5918e68a --- /dev/null +++ b/packages/android/algokit_transact/transact/src/main/AndroidManifest.xml @@ -0,0 +1,4 @@ + + + + \ No newline at end of file diff --git a/packages/android/algokit_transact/transact/src/main/kotlin/com/example/transact/TransactApi.kt b/packages/android/algokit_transact/transact/src/main/kotlin/com/example/transact/TransactApi.kt new file mode 100644 index 000000000..02246b67c --- /dev/null +++ b/packages/android/algokit_transact/transact/src/main/kotlin/com/example/transact/TransactApi.kt @@ -0,0 +1,35 @@ +package com.example.transact + +import android.R.attr.publicKey +import android.location.Address +import uniffi.algokit_transact_ffi.Transaction +import uniffi.algokit_transact_ffi.addressFromPublicKey +import uniffi.algokit_transact_ffi.publicKeyFromAddress + +class TransactApi { + companion object { + init { + try { + System.loadLibrary("algokit_transact_ffi") + } catch (e: UnsatisfiedLinkError) { + throw RuntimeException("Failed to load native library: ${e.message}", e) + } + } + } + + fun createAddressFromPubKey(publicKey: ByteArray): String { + return addressFromPublicKey(publicKey) + } + + fun getPubKeyFromAddress(address: String): ByteArray { + return publicKeyFromAddress(address) + } + + fun encodeTransaction(transaction: Transaction): ByteArray { + return encodeTransaction(transaction) + } + + fun decodeTransaction(bytes: ByteArray): Transaction { + return decodeTransaction(bytes) + } +} diff --git a/packages/android/algokit_transact/transact/src/main/kotlin/uniffi/algokit_transact_ffi/algokit_transact_ffi.kt b/packages/android/algokit_transact/transact/src/main/kotlin/uniffi/algokit_transact_ffi/algokit_transact_ffi.kt new file mode 100644 index 000000000..456184039 --- /dev/null +++ b/packages/android/algokit_transact/transact/src/main/kotlin/uniffi/algokit_transact_ffi/algokit_transact_ffi.kt @@ -0,0 +1,3899 @@ +// This file was autogenerated by some hot garbage in the `uniffi` crate. +// Trust me, you don't want to mess with it! + +@file:Suppress("NAME_SHADOWING") + +package uniffi.algokit_transact_ffi + +// Common helper code. +// +// Ideally this would live in a separate .kt file where it can be unittested etc +// in isolation, and perhaps even published as a re-useable package. +// +// However, it's important that the details of how this helper code works (e.g. the +// way that different builtin types are passed across the FFI) exactly match what's +// expected by the Rust code on the other side of the interface. In practice right +// now that means coming from the exact some version of `uniffi` that was used to +// compile the Rust component. The easiest way to ensure this is to bundle the Kotlin +// helpers directly inline like we're doing here. + +import android.location.Address +import com.sun.jna.Callback +import com.sun.jna.Library +import com.sun.jna.Native +import com.sun.jna.Pointer +import com.sun.jna.Structure +import com.sun.jna.ptr.* +import java.nio.ByteBuffer +import java.nio.ByteOrder +import java.nio.CharBuffer +import java.nio.charset.CodingErrorAction +import java.util.concurrent.ConcurrentHashMap +import java.util.concurrent.atomic.AtomicLong + +// This is a helper for safely working with byte buffers returned from the Rust code. +// A rust-owned buffer is represented by its capacity, its current length, and a +// pointer to the underlying data. + +/** + * @suppress + */ +@Structure.FieldOrder("capacity", "len", "data") +open class RustBuffer : Structure() { + // Note: `capacity` and `len` are actually `ULong` values, but JVM only supports signed values. + // When dealing with these fields, make sure to call `toULong()`. + @JvmField var capacity: Long = 0 + + @JvmField var len: Long = 0 + + @JvmField var data: Pointer? = null + + class ByValue : + RustBuffer(), + Structure.ByValue + + class ByReference : + RustBuffer(), + Structure.ByReference + + internal fun setValue(other: RustBuffer) { + capacity = other.capacity + len = other.len + data = other.data + } + + companion object { + internal fun alloc(size: ULong = 0UL) = + uniffiRustCall { status -> + // Note: need to convert the size to a `Long` value to make this work with JVM. + UniffiLib.INSTANCE.ffi_algokit_transact_ffi_rustbuffer_alloc(size.toLong(), status) + }.also { + if (it.data == null) { + throw RuntimeException("RustBuffer.alloc() returned null data pointer (size=$size)") + } + } + + internal fun create( + capacity: ULong, + len: ULong, + data: Pointer?, + ): RustBuffer.ByValue { + var buf = RustBuffer.ByValue() + buf.capacity = capacity.toLong() + buf.len = len.toLong() + buf.data = data + return buf + } + + internal fun free(buf: RustBuffer.ByValue) = + uniffiRustCall { status -> + UniffiLib.INSTANCE.ffi_algokit_transact_ffi_rustbuffer_free(buf, status) + } + } + + @Suppress("TooGenericExceptionThrown") + fun asByteBuffer() = + this.data?.getByteBuffer(0, this.len.toLong())?.also { + it.order(ByteOrder.BIG_ENDIAN) + } +} + +/** + * The equivalent of the `*mut RustBuffer` type. + * Required for callbacks taking in an out pointer. + * + * Size is the sum of all values in the struct. + * + * @suppress + */ +class RustBufferByReference : ByReference(16) { + /** + * Set the pointed-to `RustBuffer` to the given value. + */ + fun setValue(value: RustBuffer.ByValue) { + // NOTE: The offsets are as they are in the C-like struct. + val pointer = getPointer() + pointer.setLong(0, value.capacity) + pointer.setLong(8, value.len) + pointer.setPointer(16, value.data) + } + + /** + * Get a `RustBuffer.ByValue` from this reference. + */ + fun getValue(): RustBuffer.ByValue { + val pointer = getPointer() + val value = RustBuffer.ByValue() + value.writeField("capacity", pointer.getLong(0)) + value.writeField("len", pointer.getLong(8)) + value.writeField("data", pointer.getLong(16)) + + return value + } +} + +// This is a helper for safely passing byte references into the rust code. +// It's not actually used at the moment, because there aren't many things that you +// can take a direct pointer to in the JVM, and if we're going to copy something +// then we might as well copy it into a `RustBuffer`. But it's here for API +// completeness. + +@Structure.FieldOrder("len", "data") +internal open class ForeignBytes : Structure() { + @JvmField var len: Int = 0 + + @JvmField var data: Pointer? = null + + class ByValue : + ForeignBytes(), + Structure.ByValue +} + +/** + * The FfiConverter interface handles converter types to and from the FFI + * + * All implementing objects should be public to support external types. When a + * type is external we need to import it's FfiConverter. + * + * @suppress + */ +public interface FfiConverter { + // Convert an FFI type to a Kotlin type + fun lift(value: FfiType): KotlinType + + // Convert an Kotlin type to an FFI type + fun lower(value: KotlinType): FfiType + + // Read a Kotlin type from a `ByteBuffer` + fun read(buf: ByteBuffer): KotlinType + + // Calculate bytes to allocate when creating a `RustBuffer` + // + // This must return at least as many bytes as the write() function will + // write. It can return more bytes than needed, for example when writing + // Strings we can't know the exact bytes needed until we the UTF-8 + // encoding, so we pessimistically allocate the largest size possible (3 + // bytes per codepoint). Allocating extra bytes is not really a big deal + // because the `RustBuffer` is short-lived. + fun allocationSize(value: KotlinType): ULong + + // Write a Kotlin type to a `ByteBuffer` + fun write( + value: KotlinType, + buf: ByteBuffer, + ) + + // Lower a value into a `RustBuffer` + // + // This method lowers a value into a `RustBuffer` rather than the normal + // FfiType. It's used by the callback interface code. Callback interface + // returns are always serialized into a `RustBuffer` regardless of their + // normal FFI type. + fun lowerIntoRustBuffer(value: KotlinType): RustBuffer.ByValue { + val rbuf = RustBuffer.alloc(allocationSize(value)) + try { + val bbuf = + rbuf.data!!.getByteBuffer(0, rbuf.capacity).also { + it.order(ByteOrder.BIG_ENDIAN) + } + write(value, bbuf) + rbuf.writeField("len", bbuf.position().toLong()) + return rbuf + } catch (e: Throwable) { + RustBuffer.free(rbuf) + throw e + } + } + + // Lift a value from a `RustBuffer`. + // + // This here mostly because of the symmetry with `lowerIntoRustBuffer()`. + // It's currently only used by the `FfiConverterRustBuffer` class below. + fun liftFromRustBuffer(rbuf: RustBuffer.ByValue): KotlinType { + val byteBuf = rbuf.asByteBuffer()!! + try { + val item = read(byteBuf) + if (byteBuf.hasRemaining()) { + throw RuntimeException("junk remaining in buffer after lifting, something is very wrong!!") + } + return item + } finally { + RustBuffer.free(rbuf) + } + } +} + +/** + * FfiConverter that uses `RustBuffer` as the FfiType + * + * @suppress + */ +public interface FfiConverterRustBuffer : FfiConverter { + override fun lift(value: RustBuffer.ByValue) = liftFromRustBuffer(value) + + override fun lower(value: KotlinType) = lowerIntoRustBuffer(value) +} +// A handful of classes and functions to support the generated data structures. +// This would be a good candidate for isolating in its own ffi-support lib. + +internal const val UNIFFI_CALL_SUCCESS = 0.toByte() +internal const val UNIFFI_CALL_ERROR = 1.toByte() +internal const val UNIFFI_CALL_UNEXPECTED_ERROR = 2.toByte() + +@Structure.FieldOrder("code", "error_buf") +internal open class UniffiRustCallStatus : Structure() { + @JvmField var code: Byte = 0 + + @JvmField var error_buf: RustBuffer.ByValue = RustBuffer.ByValue() + + class ByValue : + UniffiRustCallStatus(), + Structure.ByValue + + fun isSuccess(): Boolean = code == UNIFFI_CALL_SUCCESS + + fun isError(): Boolean = code == UNIFFI_CALL_ERROR + + fun isPanic(): Boolean = code == UNIFFI_CALL_UNEXPECTED_ERROR + + companion object { + fun create( + code: Byte, + errorBuf: RustBuffer.ByValue, + ): UniffiRustCallStatus.ByValue { + val callStatus = UniffiRustCallStatus.ByValue() + callStatus.code = code + callStatus.error_buf = errorBuf + return callStatus + } + } +} + +class InternalException( + message: String, +) : kotlin.Exception(message) + +/** + * Each top-level error class has a companion object that can lift the error from the call status's rust buffer + * + * @suppress + */ +interface UniffiRustCallStatusErrorHandler { + fun lift(error_buf: RustBuffer.ByValue): E +} + +// Helpers for calling Rust +// In practice we usually need to be synchronized to call this safely, so it doesn't +// synchronize itself + +// Call a rust function that returns a Result<>. Pass in the Error class companion that corresponds to the Err +private inline fun uniffiRustCallWithError( + errorHandler: UniffiRustCallStatusErrorHandler, + callback: (UniffiRustCallStatus) -> U, +): U { + var status = UniffiRustCallStatus() + val return_value = callback(status) + uniffiCheckCallStatus(errorHandler, status) + return return_value +} + +// Check UniffiRustCallStatus and throw an error if the call wasn't successful +private fun uniffiCheckCallStatus( + errorHandler: UniffiRustCallStatusErrorHandler, + status: UniffiRustCallStatus, +) { + if (status.isSuccess()) { + return + } else if (status.isError()) { + throw errorHandler.lift(status.error_buf) + } else if (status.isPanic()) { + // when the rust code sees a panic, it tries to construct a rustbuffer + // with the message. but if that code panics, then it just sends back + // an empty buffer. + if (status.error_buf.len > 0) { + throw InternalException(FfiConverterString.lift(status.error_buf)) + } else { + throw InternalException("Rust panic") + } + } else { + throw InternalException("Unknown rust call status: $status.code") + } +} + +/** + * UniffiRustCallStatusErrorHandler implementation for times when we don't expect a CALL_ERROR + * + * @suppress + */ +object UniffiNullRustCallStatusErrorHandler : UniffiRustCallStatusErrorHandler { + override fun lift(error_buf: RustBuffer.ByValue): InternalException { + RustBuffer.free(error_buf) + return InternalException("Unexpected CALL_ERROR") + } +} + +// Call a rust function that returns a plain value +private inline fun uniffiRustCall(callback: (UniffiRustCallStatus) -> U): U = + uniffiRustCallWithError(UniffiNullRustCallStatusErrorHandler, callback) + +internal inline fun uniffiTraitInterfaceCall( + callStatus: UniffiRustCallStatus, + makeCall: () -> T, + writeReturn: (T) -> Unit, +) { + try { + writeReturn(makeCall()) + } catch (e: kotlin.Exception) { + callStatus.code = UNIFFI_CALL_UNEXPECTED_ERROR + callStatus.error_buf = FfiConverterString.lower(e.toString()) + } +} + +internal inline fun uniffiTraitInterfaceCallWithError( + callStatus: UniffiRustCallStatus, + makeCall: () -> T, + writeReturn: (T) -> Unit, + lowerError: (E) -> RustBuffer.ByValue, +) { + try { + writeReturn(makeCall()) + } catch (e: kotlin.Exception) { + if (e is E) { + callStatus.code = UNIFFI_CALL_ERROR + callStatus.error_buf = lowerError(e) + } else { + callStatus.code = UNIFFI_CALL_UNEXPECTED_ERROR + callStatus.error_buf = FfiConverterString.lower(e.toString()) + } + } +} + +// Map handles to objects +// +// This is used pass an opaque 64-bit handle representing a foreign object to the Rust code. +internal class UniffiHandleMap { + private val map = ConcurrentHashMap() + private val counter = + java.util.concurrent.atomic + .AtomicLong(0) + + val size: Int + get() = map.size + + // Insert a new object into the handle map and get a handle for it + fun insert(obj: T): Long { + val handle = counter.getAndAdd(1) + map.put(handle, obj) + return handle + } + + // Get an object from the handle map + fun get(handle: Long): T = map.get(handle) ?: throw InternalException("UniffiHandleMap.get: Invalid handle") + + // Remove an entry from the handlemap and get the Kotlin object back + fun remove(handle: Long): T = map.remove(handle) ?: throw InternalException("UniffiHandleMap: Invalid handle") +} + +// Contains loading, initialization code, +// and the FFI Function declarations in a com.sun.jna.Library. +@Synchronized +private fun findLibraryName(componentName: String): String { + val libOverride = System.getProperty("uniffi.component.$componentName.libraryOverride") + if (libOverride != null) { + return libOverride + } + return "algokit_transact_ffi" +} + +private inline fun loadIndirect(componentName: String): Lib = + Native.load(findLibraryName(componentName), Lib::class.java) + +// Define FFI callback types +internal interface UniffiRustFutureContinuationCallback : com.sun.jna.Callback { + fun callback( + `data`: Long, + `pollResult`: Byte, + ) +} + +internal interface UniffiForeignFutureFree : com.sun.jna.Callback { + fun callback(`handle`: Long) +} + +internal interface UniffiCallbackInterfaceFree : com.sun.jna.Callback { + fun callback(`handle`: Long) +} + +@Structure.FieldOrder("handle", "free") +internal open class UniffiForeignFuture( + @JvmField internal var `handle`: Long = 0.toLong(), + @JvmField internal var `free`: UniffiForeignFutureFree? = null, +) : Structure() { + class UniffiByValue( + `handle`: Long = 0.toLong(), + `free`: UniffiForeignFutureFree? = null, + ) : UniffiForeignFuture(`handle`, `free`), + Structure.ByValue + + internal fun uniffiSetValue(other: UniffiForeignFuture) { + `handle` = other.`handle` + `free` = other.`free` + } +} + +@Structure.FieldOrder("returnValue", "callStatus") +internal open class UniffiForeignFutureStructU8( + @JvmField internal var `returnValue`: Byte = 0.toByte(), + @JvmField internal var `callStatus`: UniffiRustCallStatus.ByValue = UniffiRustCallStatus.ByValue(), +) : Structure() { + class UniffiByValue( + `returnValue`: Byte = 0.toByte(), + `callStatus`: UniffiRustCallStatus.ByValue = UniffiRustCallStatus.ByValue(), + ) : UniffiForeignFutureStructU8(`returnValue`, `callStatus`), + Structure.ByValue + + internal fun uniffiSetValue(other: UniffiForeignFutureStructU8) { + `returnValue` = other.`returnValue` + `callStatus` = other.`callStatus` + } +} + +internal interface UniffiForeignFutureCompleteU8 : com.sun.jna.Callback { + fun callback( + `callbackData`: Long, + `result`: UniffiForeignFutureStructU8.UniffiByValue, + ) +} + +@Structure.FieldOrder("returnValue", "callStatus") +internal open class UniffiForeignFutureStructI8( + @JvmField internal var `returnValue`: Byte = 0.toByte(), + @JvmField internal var `callStatus`: UniffiRustCallStatus.ByValue = UniffiRustCallStatus.ByValue(), +) : Structure() { + class UniffiByValue( + `returnValue`: Byte = 0.toByte(), + `callStatus`: UniffiRustCallStatus.ByValue = UniffiRustCallStatus.ByValue(), + ) : UniffiForeignFutureStructI8(`returnValue`, `callStatus`), + Structure.ByValue + + internal fun uniffiSetValue(other: UniffiForeignFutureStructI8) { + `returnValue` = other.`returnValue` + `callStatus` = other.`callStatus` + } +} + +internal interface UniffiForeignFutureCompleteI8 : com.sun.jna.Callback { + fun callback( + `callbackData`: Long, + `result`: UniffiForeignFutureStructI8.UniffiByValue, + ) +} + +@Structure.FieldOrder("returnValue", "callStatus") +internal open class UniffiForeignFutureStructU16( + @JvmField internal var `returnValue`: Short = 0.toShort(), + @JvmField internal var `callStatus`: UniffiRustCallStatus.ByValue = UniffiRustCallStatus.ByValue(), +) : Structure() { + class UniffiByValue( + `returnValue`: Short = 0.toShort(), + `callStatus`: UniffiRustCallStatus.ByValue = UniffiRustCallStatus.ByValue(), + ) : UniffiForeignFutureStructU16(`returnValue`, `callStatus`), + Structure.ByValue + + internal fun uniffiSetValue(other: UniffiForeignFutureStructU16) { + `returnValue` = other.`returnValue` + `callStatus` = other.`callStatus` + } +} + +internal interface UniffiForeignFutureCompleteU16 : com.sun.jna.Callback { + fun callback( + `callbackData`: Long, + `result`: UniffiForeignFutureStructU16.UniffiByValue, + ) +} + +@Structure.FieldOrder("returnValue", "callStatus") +internal open class UniffiForeignFutureStructI16( + @JvmField internal var `returnValue`: Short = 0.toShort(), + @JvmField internal var `callStatus`: UniffiRustCallStatus.ByValue = UniffiRustCallStatus.ByValue(), +) : Structure() { + class UniffiByValue( + `returnValue`: Short = 0.toShort(), + `callStatus`: UniffiRustCallStatus.ByValue = UniffiRustCallStatus.ByValue(), + ) : UniffiForeignFutureStructI16(`returnValue`, `callStatus`), + Structure.ByValue + + internal fun uniffiSetValue(other: UniffiForeignFutureStructI16) { + `returnValue` = other.`returnValue` + `callStatus` = other.`callStatus` + } +} + +internal interface UniffiForeignFutureCompleteI16 : com.sun.jna.Callback { + fun callback( + `callbackData`: Long, + `result`: UniffiForeignFutureStructI16.UniffiByValue, + ) +} + +@Structure.FieldOrder("returnValue", "callStatus") +internal open class UniffiForeignFutureStructU32( + @JvmField internal var `returnValue`: Int = 0, + @JvmField internal var `callStatus`: UniffiRustCallStatus.ByValue = UniffiRustCallStatus.ByValue(), +) : Structure() { + class UniffiByValue( + `returnValue`: Int = 0, + `callStatus`: UniffiRustCallStatus.ByValue = UniffiRustCallStatus.ByValue(), + ) : UniffiForeignFutureStructU32(`returnValue`, `callStatus`), + Structure.ByValue + + internal fun uniffiSetValue(other: UniffiForeignFutureStructU32) { + `returnValue` = other.`returnValue` + `callStatus` = other.`callStatus` + } +} + +internal interface UniffiForeignFutureCompleteU32 : com.sun.jna.Callback { + fun callback( + `callbackData`: Long, + `result`: UniffiForeignFutureStructU32.UniffiByValue, + ) +} + +@Structure.FieldOrder("returnValue", "callStatus") +internal open class UniffiForeignFutureStructI32( + @JvmField internal var `returnValue`: Int = 0, + @JvmField internal var `callStatus`: UniffiRustCallStatus.ByValue = UniffiRustCallStatus.ByValue(), +) : Structure() { + class UniffiByValue( + `returnValue`: Int = 0, + `callStatus`: UniffiRustCallStatus.ByValue = UniffiRustCallStatus.ByValue(), + ) : UniffiForeignFutureStructI32(`returnValue`, `callStatus`), + Structure.ByValue + + internal fun uniffiSetValue(other: UniffiForeignFutureStructI32) { + `returnValue` = other.`returnValue` + `callStatus` = other.`callStatus` + } +} + +internal interface UniffiForeignFutureCompleteI32 : com.sun.jna.Callback { + fun callback( + `callbackData`: Long, + `result`: UniffiForeignFutureStructI32.UniffiByValue, + ) +} + +@Structure.FieldOrder("returnValue", "callStatus") +internal open class UniffiForeignFutureStructU64( + @JvmField internal var `returnValue`: Long = 0.toLong(), + @JvmField internal var `callStatus`: UniffiRustCallStatus.ByValue = UniffiRustCallStatus.ByValue(), +) : Structure() { + class UniffiByValue( + `returnValue`: Long = 0.toLong(), + `callStatus`: UniffiRustCallStatus.ByValue = UniffiRustCallStatus.ByValue(), + ) : UniffiForeignFutureStructU64(`returnValue`, `callStatus`), + Structure.ByValue + + internal fun uniffiSetValue(other: UniffiForeignFutureStructU64) { + `returnValue` = other.`returnValue` + `callStatus` = other.`callStatus` + } +} + +internal interface UniffiForeignFutureCompleteU64 : com.sun.jna.Callback { + fun callback( + `callbackData`: Long, + `result`: UniffiForeignFutureStructU64.UniffiByValue, + ) +} + +@Structure.FieldOrder("returnValue", "callStatus") +internal open class UniffiForeignFutureStructI64( + @JvmField internal var `returnValue`: Long = 0.toLong(), + @JvmField internal var `callStatus`: UniffiRustCallStatus.ByValue = UniffiRustCallStatus.ByValue(), +) : Structure() { + class UniffiByValue( + `returnValue`: Long = 0.toLong(), + `callStatus`: UniffiRustCallStatus.ByValue = UniffiRustCallStatus.ByValue(), + ) : UniffiForeignFutureStructI64(`returnValue`, `callStatus`), + Structure.ByValue + + internal fun uniffiSetValue(other: UniffiForeignFutureStructI64) { + `returnValue` = other.`returnValue` + `callStatus` = other.`callStatus` + } +} + +internal interface UniffiForeignFutureCompleteI64 : com.sun.jna.Callback { + fun callback( + `callbackData`: Long, + `result`: UniffiForeignFutureStructI64.UniffiByValue, + ) +} + +@Structure.FieldOrder("returnValue", "callStatus") +internal open class UniffiForeignFutureStructF32( + @JvmField internal var `returnValue`: Float = 0.0f, + @JvmField internal var `callStatus`: UniffiRustCallStatus.ByValue = UniffiRustCallStatus.ByValue(), +) : Structure() { + class UniffiByValue( + `returnValue`: Float = 0.0f, + `callStatus`: UniffiRustCallStatus.ByValue = UniffiRustCallStatus.ByValue(), + ) : UniffiForeignFutureStructF32(`returnValue`, `callStatus`), + Structure.ByValue + + internal fun uniffiSetValue(other: UniffiForeignFutureStructF32) { + `returnValue` = other.`returnValue` + `callStatus` = other.`callStatus` + } +} + +internal interface UniffiForeignFutureCompleteF32 : com.sun.jna.Callback { + fun callback( + `callbackData`: Long, + `result`: UniffiForeignFutureStructF32.UniffiByValue, + ) +} + +@Structure.FieldOrder("returnValue", "callStatus") +internal open class UniffiForeignFutureStructF64( + @JvmField internal var `returnValue`: Double = 0.0, + @JvmField internal var `callStatus`: UniffiRustCallStatus.ByValue = UniffiRustCallStatus.ByValue(), +) : Structure() { + class UniffiByValue( + `returnValue`: Double = 0.0, + `callStatus`: UniffiRustCallStatus.ByValue = UniffiRustCallStatus.ByValue(), + ) : UniffiForeignFutureStructF64(`returnValue`, `callStatus`), + Structure.ByValue + + internal fun uniffiSetValue(other: UniffiForeignFutureStructF64) { + `returnValue` = other.`returnValue` + `callStatus` = other.`callStatus` + } +} + +internal interface UniffiForeignFutureCompleteF64 : com.sun.jna.Callback { + fun callback( + `callbackData`: Long, + `result`: UniffiForeignFutureStructF64.UniffiByValue, + ) +} + +@Structure.FieldOrder("returnValue", "callStatus") +internal open class UniffiForeignFutureStructPointer( + @JvmField internal var `returnValue`: Pointer = Pointer.NULL, + @JvmField internal var `callStatus`: UniffiRustCallStatus.ByValue = UniffiRustCallStatus.ByValue(), +) : Structure() { + class UniffiByValue( + `returnValue`: Pointer = Pointer.NULL, + `callStatus`: UniffiRustCallStatus.ByValue = UniffiRustCallStatus.ByValue(), + ) : UniffiForeignFutureStructPointer(`returnValue`, `callStatus`), + Structure.ByValue + + internal fun uniffiSetValue(other: UniffiForeignFutureStructPointer) { + `returnValue` = other.`returnValue` + `callStatus` = other.`callStatus` + } +} + +internal interface UniffiForeignFutureCompletePointer : com.sun.jna.Callback { + fun callback( + `callbackData`: Long, + `result`: UniffiForeignFutureStructPointer.UniffiByValue, + ) +} + +@Structure.FieldOrder("returnValue", "callStatus") +internal open class UniffiForeignFutureStructRustBuffer( + @JvmField internal var `returnValue`: RustBuffer.ByValue = RustBuffer.ByValue(), + @JvmField internal var `callStatus`: UniffiRustCallStatus.ByValue = UniffiRustCallStatus.ByValue(), +) : Structure() { + class UniffiByValue( + `returnValue`: RustBuffer.ByValue = RustBuffer.ByValue(), + `callStatus`: UniffiRustCallStatus.ByValue = UniffiRustCallStatus.ByValue(), + ) : UniffiForeignFutureStructRustBuffer(`returnValue`, `callStatus`), + Structure.ByValue + + internal fun uniffiSetValue(other: UniffiForeignFutureStructRustBuffer) { + `returnValue` = other.`returnValue` + `callStatus` = other.`callStatus` + } +} + +internal interface UniffiForeignFutureCompleteRustBuffer : com.sun.jna.Callback { + fun callback( + `callbackData`: Long, + `result`: UniffiForeignFutureStructRustBuffer.UniffiByValue, + ) +} + +@Structure.FieldOrder("callStatus") +internal open class UniffiForeignFutureStructVoid( + @JvmField internal var `callStatus`: UniffiRustCallStatus.ByValue = UniffiRustCallStatus.ByValue(), +) : Structure() { + class UniffiByValue( + `callStatus`: UniffiRustCallStatus.ByValue = UniffiRustCallStatus.ByValue(), + ) : UniffiForeignFutureStructVoid(`callStatus`), + Structure.ByValue + + internal fun uniffiSetValue(other: UniffiForeignFutureStructVoid) { + `callStatus` = other.`callStatus` + } +} + +internal interface UniffiForeignFutureCompleteVoid : com.sun.jna.Callback { + fun callback( + `callbackData`: Long, + `result`: UniffiForeignFutureStructVoid.UniffiByValue, + ) +} + +// For large crates we prevent `MethodTooLargeException` (see #2340) +// N.B. the name of the extension is very misleading, since it is +// rather `InterfaceTooLargeException`, caused by too many methods +// in the interface for large crates. +// +// By splitting the otherwise huge interface into two parts +// * UniffiLib +// * IntegrityCheckingUniffiLib (this) +// we allow for ~2x as many methods in the UniffiLib interface. +// +// The `ffi_uniffi_contract_version` method and all checksum methods are put +// into `IntegrityCheckingUniffiLib` and these methods are called only once, +// when the library is loaded. +internal interface IntegrityCheckingUniffiLib : Library { + // Integrity check functions only + fun uniffi_algokit_transact_ffi_checksum_func_address_from_multisig_signature(): Short + + fun uniffi_algokit_transact_ffi_checksum_func_address_from_public_key(): Short + + fun uniffi_algokit_transact_ffi_checksum_func_apply_multisig_subsignature(): Short + + fun uniffi_algokit_transact_ffi_checksum_func_assign_fee(): Short + + fun uniffi_algokit_transact_ffi_checksum_func_calculate_fee(): Short + + fun uniffi_algokit_transact_ffi_checksum_func_decode_signed_transaction(): Short + + fun uniffi_algokit_transact_ffi_checksum_func_decode_signed_transactions(): Short + + fun uniffi_algokit_transact_ffi_checksum_func_decode_transaction(): Short + + fun uniffi_algokit_transact_ffi_checksum_func_decode_transactions(): Short + + fun uniffi_algokit_transact_ffi_checksum_func_encode_signed_transaction(): Short + + fun uniffi_algokit_transact_ffi_checksum_func_encode_signed_transactions(): Short + + fun uniffi_algokit_transact_ffi_checksum_func_encode_transaction(): Short + + fun uniffi_algokit_transact_ffi_checksum_func_encode_transaction_raw(): Short + + fun uniffi_algokit_transact_ffi_checksum_func_encode_transactions(): Short + + fun uniffi_algokit_transact_ffi_checksum_func_estimate_transaction_size(): Short + + fun uniffi_algokit_transact_ffi_checksum_func_get_algorand_constant(): Short + + fun uniffi_algokit_transact_ffi_checksum_func_get_encoded_transaction_type(): Short + + fun uniffi_algokit_transact_ffi_checksum_func_get_transaction_id(): Short + + fun uniffi_algokit_transact_ffi_checksum_func_get_transaction_id_raw(): Short + + fun uniffi_algokit_transact_ffi_checksum_func_group_transactions(): Short + + fun uniffi_algokit_transact_ffi_checksum_func_merge_multisignatures(): Short + + fun uniffi_algokit_transact_ffi_checksum_func_new_multisig_signature(): Short + + fun uniffi_algokit_transact_ffi_checksum_func_participants_from_multisig_signature(): Short + + fun uniffi_algokit_transact_ffi_checksum_func_public_key_from_address(): Short + + fun ffi_algokit_transact_ffi_uniffi_contract_version(): Int +} + +// A JNA Library to expose the extern-C FFI definitions. +// This is an implementation detail which will be called internally by the public API. +internal interface UniffiLib : Library { + companion object { + internal val INSTANCE: UniffiLib by lazy { + val componentName = "algokit_transact_ffi" + // For large crates we prevent `MethodTooLargeException` (see #2340) + // N.B. the name of the extension is very misleading, since it is + // rather `InterfaceTooLargeException`, caused by too many methods + // in the interface for large crates. + // + // By splitting the otherwise huge interface into two parts + // * UniffiLib (this) + // * IntegrityCheckingUniffiLib + // And all checksum methods are put into `IntegrityCheckingUniffiLib` + // we allow for ~2x as many methods in the UniffiLib interface. + // + // Thus we first load the library with `loadIndirect` as `IntegrityCheckingUniffiLib` + // so that we can (optionally!) call `uniffiCheckApiChecksums`... + loadIndirect(componentName) + .also { lib: IntegrityCheckingUniffiLib -> + uniffiCheckContractApiVersion(lib) + uniffiCheckApiChecksums(lib) + } + // ... and then we load the library as `UniffiLib` + // N.B. we cannot use `loadIndirect` once and then try to cast it to `UniffiLib` + // => results in `java.lang.ClassCastException: com.sun.proxy.$Proxy cannot be cast to ...` + // error. So we must call `loadIndirect` twice. For crates large enough + // to trigger this issue, the performance impact is negligible, running on + // a macOS M1 machine the `loadIndirect` call takes ~50ms. + val lib = loadIndirect(componentName) + // No need to check the contract version and checksums, since + // we already did that with `IntegrityCheckingUniffiLib` above. + // Loading of library with integrity check done. + lib + } + } + + // FFI functions + fun uniffi_algokit_transact_ffi_fn_func_address_from_multisig_signature( + `multisigSignature`: RustBuffer.ByValue, + uniffi_out_err: UniffiRustCallStatus, + ): RustBuffer.ByValue + + fun uniffi_algokit_transact_ffi_fn_func_address_from_public_key( + `publicKey`: RustBuffer.ByValue, + uniffi_out_err: UniffiRustCallStatus, + ): RustBuffer.ByValue + + fun uniffi_algokit_transact_ffi_fn_func_apply_multisig_subsignature( + `multisigSignature`: RustBuffer.ByValue, + `participant`: RustBuffer.ByValue, + `subsignature`: RustBuffer.ByValue, + uniffi_out_err: UniffiRustCallStatus, + ): RustBuffer.ByValue + + fun uniffi_algokit_transact_ffi_fn_func_assign_fee( + `transaction`: RustBuffer.ByValue, + `feeParams`: RustBuffer.ByValue, + uniffi_out_err: UniffiRustCallStatus, + ): RustBuffer.ByValue + + fun uniffi_algokit_transact_ffi_fn_func_calculate_fee( + `transaction`: RustBuffer.ByValue, + `feeParams`: RustBuffer.ByValue, + uniffi_out_err: UniffiRustCallStatus, + ): Long + + fun uniffi_algokit_transact_ffi_fn_func_decode_signed_transaction( + `encodedSignedTransaction`: RustBuffer.ByValue, + uniffi_out_err: UniffiRustCallStatus, + ): RustBuffer.ByValue + + fun uniffi_algokit_transact_ffi_fn_func_decode_signed_transactions( + `encodedSignedTransactions`: RustBuffer.ByValue, + uniffi_out_err: UniffiRustCallStatus, + ): RustBuffer.ByValue + + fun uniffi_algokit_transact_ffi_fn_func_decode_transaction( + `encodedTx`: RustBuffer.ByValue, + uniffi_out_err: UniffiRustCallStatus, + ): RustBuffer.ByValue + + fun uniffi_algokit_transact_ffi_fn_func_decode_transactions( + `encodedTxs`: RustBuffer.ByValue, + uniffi_out_err: UniffiRustCallStatus, + ): RustBuffer.ByValue + + fun uniffi_algokit_transact_ffi_fn_func_encode_signed_transaction( + `signedTransaction`: RustBuffer.ByValue, + uniffi_out_err: UniffiRustCallStatus, + ): RustBuffer.ByValue + + fun uniffi_algokit_transact_ffi_fn_func_encode_signed_transactions( + `signedTransactions`: RustBuffer.ByValue, + uniffi_out_err: UniffiRustCallStatus, + ): RustBuffer.ByValue + + fun uniffi_algokit_transact_ffi_fn_func_encode_transaction( + `transaction`: RustBuffer.ByValue, + uniffi_out_err: UniffiRustCallStatus, + ): RustBuffer.ByValue + + fun uniffi_algokit_transact_ffi_fn_func_encode_transaction_raw( + `transaction`: RustBuffer.ByValue, + uniffi_out_err: UniffiRustCallStatus, + ): RustBuffer.ByValue + + fun uniffi_algokit_transact_ffi_fn_func_encode_transactions( + `transactions`: RustBuffer.ByValue, + uniffi_out_err: UniffiRustCallStatus, + ): RustBuffer.ByValue + + fun uniffi_algokit_transact_ffi_fn_func_estimate_transaction_size( + `transaction`: RustBuffer.ByValue, + uniffi_out_err: UniffiRustCallStatus, + ): Long + + fun uniffi_algokit_transact_ffi_fn_func_get_algorand_constant( + `constant`: RustBuffer.ByValue, + uniffi_out_err: UniffiRustCallStatus, + ): Long + + fun uniffi_algokit_transact_ffi_fn_func_get_encoded_transaction_type( + `encodedTransaction`: RustBuffer.ByValue, + uniffi_out_err: UniffiRustCallStatus, + ): RustBuffer.ByValue + + fun uniffi_algokit_transact_ffi_fn_func_get_transaction_id( + `transaction`: RustBuffer.ByValue, + uniffi_out_err: UniffiRustCallStatus, + ): RustBuffer.ByValue + + fun uniffi_algokit_transact_ffi_fn_func_get_transaction_id_raw( + `transaction`: RustBuffer.ByValue, + uniffi_out_err: UniffiRustCallStatus, + ): RustBuffer.ByValue + + fun uniffi_algokit_transact_ffi_fn_func_group_transactions( + `transactions`: RustBuffer.ByValue, + uniffi_out_err: UniffiRustCallStatus, + ): RustBuffer.ByValue + + fun uniffi_algokit_transact_ffi_fn_func_merge_multisignatures( + `multisigSignatureA`: RustBuffer.ByValue, + `multisigSignatureB`: RustBuffer.ByValue, + uniffi_out_err: UniffiRustCallStatus, + ): RustBuffer.ByValue + + fun uniffi_algokit_transact_ffi_fn_func_new_multisig_signature( + `version`: Byte, + `threshold`: Byte, + `participants`: RustBuffer.ByValue, + uniffi_out_err: UniffiRustCallStatus, + ): RustBuffer.ByValue + + fun uniffi_algokit_transact_ffi_fn_func_participants_from_multisig_signature( + `multisigSignature`: RustBuffer.ByValue, + uniffi_out_err: UniffiRustCallStatus, + ): RustBuffer.ByValue + + fun uniffi_algokit_transact_ffi_fn_func_public_key_from_address( + `address`: RustBuffer.ByValue, + uniffi_out_err: UniffiRustCallStatus, + ): RustBuffer.ByValue + + fun ffi_algokit_transact_ffi_rustbuffer_alloc( + `size`: Long, + uniffi_out_err: UniffiRustCallStatus, + ): RustBuffer.ByValue + + fun ffi_algokit_transact_ffi_rustbuffer_from_bytes( + `bytes`: ForeignBytes.ByValue, + uniffi_out_err: UniffiRustCallStatus, + ): RustBuffer.ByValue + + fun ffi_algokit_transact_ffi_rustbuffer_free( + `buf`: RustBuffer.ByValue, + uniffi_out_err: UniffiRustCallStatus, + ): Unit + + fun ffi_algokit_transact_ffi_rustbuffer_reserve( + `buf`: RustBuffer.ByValue, + `additional`: Long, + uniffi_out_err: UniffiRustCallStatus, + ): RustBuffer.ByValue + + fun ffi_algokit_transact_ffi_rust_future_poll_u8( + `handle`: Long, + `callback`: UniffiRustFutureContinuationCallback, + `callbackData`: Long, + ): Unit + + fun ffi_algokit_transact_ffi_rust_future_cancel_u8(`handle`: Long): Unit + + fun ffi_algokit_transact_ffi_rust_future_free_u8(`handle`: Long): Unit + + fun ffi_algokit_transact_ffi_rust_future_complete_u8( + `handle`: Long, + uniffi_out_err: UniffiRustCallStatus, + ): Byte + + fun ffi_algokit_transact_ffi_rust_future_poll_i8( + `handle`: Long, + `callback`: UniffiRustFutureContinuationCallback, + `callbackData`: Long, + ): Unit + + fun ffi_algokit_transact_ffi_rust_future_cancel_i8(`handle`: Long): Unit + + fun ffi_algokit_transact_ffi_rust_future_free_i8(`handle`: Long): Unit + + fun ffi_algokit_transact_ffi_rust_future_complete_i8( + `handle`: Long, + uniffi_out_err: UniffiRustCallStatus, + ): Byte + + fun ffi_algokit_transact_ffi_rust_future_poll_u16( + `handle`: Long, + `callback`: UniffiRustFutureContinuationCallback, + `callbackData`: Long, + ): Unit + + fun ffi_algokit_transact_ffi_rust_future_cancel_u16(`handle`: Long): Unit + + fun ffi_algokit_transact_ffi_rust_future_free_u16(`handle`: Long): Unit + + fun ffi_algokit_transact_ffi_rust_future_complete_u16( + `handle`: Long, + uniffi_out_err: UniffiRustCallStatus, + ): Short + + fun ffi_algokit_transact_ffi_rust_future_poll_i16( + `handle`: Long, + `callback`: UniffiRustFutureContinuationCallback, + `callbackData`: Long, + ): Unit + + fun ffi_algokit_transact_ffi_rust_future_cancel_i16(`handle`: Long): Unit + + fun ffi_algokit_transact_ffi_rust_future_free_i16(`handle`: Long): Unit + + fun ffi_algokit_transact_ffi_rust_future_complete_i16( + `handle`: Long, + uniffi_out_err: UniffiRustCallStatus, + ): Short + + fun ffi_algokit_transact_ffi_rust_future_poll_u32( + `handle`: Long, + `callback`: UniffiRustFutureContinuationCallback, + `callbackData`: Long, + ): Unit + + fun ffi_algokit_transact_ffi_rust_future_cancel_u32(`handle`: Long): Unit + + fun ffi_algokit_transact_ffi_rust_future_free_u32(`handle`: Long): Unit + + fun ffi_algokit_transact_ffi_rust_future_complete_u32( + `handle`: Long, + uniffi_out_err: UniffiRustCallStatus, + ): Int + + fun ffi_algokit_transact_ffi_rust_future_poll_i32( + `handle`: Long, + `callback`: UniffiRustFutureContinuationCallback, + `callbackData`: Long, + ): Unit + + fun ffi_algokit_transact_ffi_rust_future_cancel_i32(`handle`: Long): Unit + + fun ffi_algokit_transact_ffi_rust_future_free_i32(`handle`: Long): Unit + + fun ffi_algokit_transact_ffi_rust_future_complete_i32( + `handle`: Long, + uniffi_out_err: UniffiRustCallStatus, + ): Int + + fun ffi_algokit_transact_ffi_rust_future_poll_u64( + `handle`: Long, + `callback`: UniffiRustFutureContinuationCallback, + `callbackData`: Long, + ): Unit + + fun ffi_algokit_transact_ffi_rust_future_cancel_u64(`handle`: Long): Unit + + fun ffi_algokit_transact_ffi_rust_future_free_u64(`handle`: Long): Unit + + fun ffi_algokit_transact_ffi_rust_future_complete_u64( + `handle`: Long, + uniffi_out_err: UniffiRustCallStatus, + ): Long + + fun ffi_algokit_transact_ffi_rust_future_poll_i64( + `handle`: Long, + `callback`: UniffiRustFutureContinuationCallback, + `callbackData`: Long, + ): Unit + + fun ffi_algokit_transact_ffi_rust_future_cancel_i64(`handle`: Long): Unit + + fun ffi_algokit_transact_ffi_rust_future_free_i64(`handle`: Long): Unit + + fun ffi_algokit_transact_ffi_rust_future_complete_i64( + `handle`: Long, + uniffi_out_err: UniffiRustCallStatus, + ): Long + + fun ffi_algokit_transact_ffi_rust_future_poll_f32( + `handle`: Long, + `callback`: UniffiRustFutureContinuationCallback, + `callbackData`: Long, + ): Unit + + fun ffi_algokit_transact_ffi_rust_future_cancel_f32(`handle`: Long): Unit + + fun ffi_algokit_transact_ffi_rust_future_free_f32(`handle`: Long): Unit + + fun ffi_algokit_transact_ffi_rust_future_complete_f32( + `handle`: Long, + uniffi_out_err: UniffiRustCallStatus, + ): Float + + fun ffi_algokit_transact_ffi_rust_future_poll_f64( + `handle`: Long, + `callback`: UniffiRustFutureContinuationCallback, + `callbackData`: Long, + ): Unit + + fun ffi_algokit_transact_ffi_rust_future_cancel_f64(`handle`: Long): Unit + + fun ffi_algokit_transact_ffi_rust_future_free_f64(`handle`: Long): Unit + + fun ffi_algokit_transact_ffi_rust_future_complete_f64( + `handle`: Long, + uniffi_out_err: UniffiRustCallStatus, + ): Double + + fun ffi_algokit_transact_ffi_rust_future_poll_pointer( + `handle`: Long, + `callback`: UniffiRustFutureContinuationCallback, + `callbackData`: Long, + ): Unit + + fun ffi_algokit_transact_ffi_rust_future_cancel_pointer(`handle`: Long): Unit + + fun ffi_algokit_transact_ffi_rust_future_free_pointer(`handle`: Long): Unit + + fun ffi_algokit_transact_ffi_rust_future_complete_pointer( + `handle`: Long, + uniffi_out_err: UniffiRustCallStatus, + ): Pointer + + fun ffi_algokit_transact_ffi_rust_future_poll_rust_buffer( + `handle`: Long, + `callback`: UniffiRustFutureContinuationCallback, + `callbackData`: Long, + ): Unit + + fun ffi_algokit_transact_ffi_rust_future_cancel_rust_buffer(`handle`: Long): Unit + + fun ffi_algokit_transact_ffi_rust_future_free_rust_buffer(`handle`: Long): Unit + + fun ffi_algokit_transact_ffi_rust_future_complete_rust_buffer( + `handle`: Long, + uniffi_out_err: UniffiRustCallStatus, + ): RustBuffer.ByValue + + fun ffi_algokit_transact_ffi_rust_future_poll_void( + `handle`: Long, + `callback`: UniffiRustFutureContinuationCallback, + `callbackData`: Long, + ): Unit + + fun ffi_algokit_transact_ffi_rust_future_cancel_void(`handle`: Long): Unit + + fun ffi_algokit_transact_ffi_rust_future_free_void(`handle`: Long): Unit + + fun ffi_algokit_transact_ffi_rust_future_complete_void( + `handle`: Long, + uniffi_out_err: UniffiRustCallStatus, + ): Unit +} + +private fun uniffiCheckContractApiVersion(lib: IntegrityCheckingUniffiLib) { + // Get the bindings contract version from our ComponentInterface + val bindings_contract_version = 29 + // Get the scaffolding contract version by calling the into the dylib + val scaffolding_contract_version = lib.ffi_algokit_transact_ffi_uniffi_contract_version() + if (bindings_contract_version != scaffolding_contract_version) { + throw RuntimeException("UniFFI contract version mismatch: try cleaning and rebuilding your project") + } +} + +@Suppress("UNUSED_PARAMETER") +private fun uniffiCheckApiChecksums(lib: IntegrityCheckingUniffiLib) { + if (lib.uniffi_algokit_transact_ffi_checksum_func_address_from_multisig_signature() != 51026.toShort()) { + throw RuntimeException("UniFFI API checksum mismatch: try cleaning and rebuilding your project") + } + if (lib.uniffi_algokit_transact_ffi_checksum_func_address_from_public_key() != 10716.toShort()) { + throw RuntimeException("UniFFI API checksum mismatch: try cleaning and rebuilding your project") + } + if (lib.uniffi_algokit_transact_ffi_checksum_func_apply_multisig_subsignature() != 42634.toShort()) { + throw RuntimeException("UniFFI API checksum mismatch: try cleaning and rebuilding your project") + } + if (lib.uniffi_algokit_transact_ffi_checksum_func_assign_fee() != 35003.toShort()) { + throw RuntimeException("UniFFI API checksum mismatch: try cleaning and rebuilding your project") + } + if (lib.uniffi_algokit_transact_ffi_checksum_func_calculate_fee() != 7537.toShort()) { + throw RuntimeException("UniFFI API checksum mismatch: try cleaning and rebuilding your project") + } + if (lib.uniffi_algokit_transact_ffi_checksum_func_decode_signed_transaction() != 43569.toShort()) { + throw RuntimeException("UniFFI API checksum mismatch: try cleaning and rebuilding your project") + } + if (lib.uniffi_algokit_transact_ffi_checksum_func_decode_signed_transactions() != 62888.toShort()) { + throw RuntimeException("UniFFI API checksum mismatch: try cleaning and rebuilding your project") + } + if (lib.uniffi_algokit_transact_ffi_checksum_func_decode_transaction() != 56405.toShort()) { + throw RuntimeException("UniFFI API checksum mismatch: try cleaning and rebuilding your project") + } + if (lib.uniffi_algokit_transact_ffi_checksum_func_decode_transactions() != 26956.toShort()) { + throw RuntimeException("UniFFI API checksum mismatch: try cleaning and rebuilding your project") + } + if (lib.uniffi_algokit_transact_ffi_checksum_func_encode_signed_transaction() != 47064.toShort()) { + throw RuntimeException("UniFFI API checksum mismatch: try cleaning and rebuilding your project") + } + if (lib.uniffi_algokit_transact_ffi_checksum_func_encode_signed_transactions() != 1956.toShort()) { + throw RuntimeException("UniFFI API checksum mismatch: try cleaning and rebuilding your project") + } + if (lib.uniffi_algokit_transact_ffi_checksum_func_encode_transaction() != 11275.toShort()) { + throw RuntimeException("UniFFI API checksum mismatch: try cleaning and rebuilding your project") + } + if (lib.uniffi_algokit_transact_ffi_checksum_func_encode_transaction_raw() != 384.toShort()) { + throw RuntimeException("UniFFI API checksum mismatch: try cleaning and rebuilding your project") + } + if (lib.uniffi_algokit_transact_ffi_checksum_func_encode_transactions() != 59611.toShort()) { + throw RuntimeException("UniFFI API checksum mismatch: try cleaning and rebuilding your project") + } + if (lib.uniffi_algokit_transact_ffi_checksum_func_estimate_transaction_size() != 60858.toShort()) { + throw RuntimeException("UniFFI API checksum mismatch: try cleaning and rebuilding your project") + } + if (lib.uniffi_algokit_transact_ffi_checksum_func_get_algorand_constant() != 49400.toShort()) { + throw RuntimeException("UniFFI API checksum mismatch: try cleaning and rebuilding your project") + } + if (lib.uniffi_algokit_transact_ffi_checksum_func_get_encoded_transaction_type() != 42551.toShort()) { + throw RuntimeException("UniFFI API checksum mismatch: try cleaning and rebuilding your project") + } + if (lib.uniffi_algokit_transact_ffi_checksum_func_get_transaction_id() != 10957.toShort()) { + throw RuntimeException("UniFFI API checksum mismatch: try cleaning and rebuilding your project") + } + if (lib.uniffi_algokit_transact_ffi_checksum_func_get_transaction_id_raw() != 48975.toShort()) { + throw RuntimeException("UniFFI API checksum mismatch: try cleaning and rebuilding your project") + } + if (lib.uniffi_algokit_transact_ffi_checksum_func_group_transactions() != 18193.toShort()) { + throw RuntimeException("UniFFI API checksum mismatch: try cleaning and rebuilding your project") + } + if (lib.uniffi_algokit_transact_ffi_checksum_func_merge_multisignatures() != 58688.toShort()) { + throw RuntimeException("UniFFI API checksum mismatch: try cleaning and rebuilding your project") + } + if (lib.uniffi_algokit_transact_ffi_checksum_func_new_multisig_signature() != 29314.toShort()) { + throw RuntimeException("UniFFI API checksum mismatch: try cleaning and rebuilding your project") + } + if (lib.uniffi_algokit_transact_ffi_checksum_func_participants_from_multisig_signature() != 25095.toShort()) { + throw RuntimeException("UniFFI API checksum mismatch: try cleaning and rebuilding your project") + } + if (lib.uniffi_algokit_transact_ffi_checksum_func_public_key_from_address() != 58152.toShort()) { + throw RuntimeException("UniFFI API checksum mismatch: try cleaning and rebuilding your project") + } +} + +/** + * @suppress + */ +public fun uniffiEnsureInitialized() { + UniffiLib.INSTANCE +} + +// Async support + +// Public interface members begin here. + +// Interface implemented by anything that can contain an object reference. +// +// Such types expose a `destroy()` method that must be called to cleanly +// dispose of the contained objects. Failure to call this method may result +// in memory leaks. +// +// The easiest way to ensure this method is called is to use the `.use` +// helper method to execute a block and destroy the object at the end. +interface Disposable { + fun destroy() + + companion object { + fun destroy(vararg args: Any?) { + for (arg in args) { + when (arg) { + is Disposable -> arg.destroy() + is ArrayList<*> -> { + for (idx in arg.indices) { + val element = arg[idx] + if (element is Disposable) { + element.destroy() + } + } + } + is Map<*, *> -> { + for (element in arg.values) { + if (element is Disposable) { + element.destroy() + } + } + } + is Iterable<*> -> { + for (element in arg) { + if (element is Disposable) { + element.destroy() + } + } + } + } + } + } + } +} + +/** + * @suppress + */ +inline fun T.use(block: (T) -> R) = + try { + block(this) + } finally { + try { + // N.B. our implementation is on the nullable type `Disposable?`. + this?.destroy() + } catch (e: Throwable) { + // swallow + } + } + +/** + * Used to instantiate an interface without an actual pointer, for fakes in tests, mostly. + * + * @suppress + * */ +object NoPointer + +/** + * @suppress + */ +public object FfiConverterUByte : FfiConverter { + override fun lift(value: Byte): UByte = value.toUByte() + + override fun read(buf: ByteBuffer): UByte = lift(buf.get()) + + override fun lower(value: UByte): Byte = value.toByte() + + override fun allocationSize(value: UByte) = 1UL + + override fun write( + value: UByte, + buf: ByteBuffer, + ) { + buf.put(value.toByte()) + } +} + +/** + * @suppress + */ +public object FfiConverterUInt : FfiConverter { + override fun lift(value: Int): UInt = value.toUInt() + + override fun read(buf: ByteBuffer): UInt = lift(buf.getInt()) + + override fun lower(value: UInt): Int = value.toInt() + + override fun allocationSize(value: UInt) = 4UL + + override fun write( + value: UInt, + buf: ByteBuffer, + ) { + buf.putInt(value.toInt()) + } +} + +/** + * @suppress + */ +public object FfiConverterULong : FfiConverter { + override fun lift(value: Long): ULong = value.toULong() + + override fun read(buf: ByteBuffer): ULong = lift(buf.getLong()) + + override fun lower(value: ULong): Long = value.toLong() + + override fun allocationSize(value: ULong) = 8UL + + override fun write( + value: ULong, + buf: ByteBuffer, + ) { + buf.putLong(value.toLong()) + } +} + +/** + * @suppress + */ +public object FfiConverterBoolean : FfiConverter { + override fun lift(value: Byte): Boolean = value.toInt() != 0 + + override fun read(buf: ByteBuffer): Boolean = lift(buf.get()) + + override fun lower(value: Boolean): Byte = if (value) 1.toByte() else 0.toByte() + + override fun allocationSize(value: Boolean) = 1UL + + override fun write( + value: Boolean, + buf: ByteBuffer, + ) { + buf.put(lower(value)) + } +} + +/** + * @suppress + */ +public object FfiConverterString : FfiConverter { + // Note: we don't inherit from FfiConverterRustBuffer, because we use a + // special encoding when lowering/lifting. We can use `RustBuffer.len` to + // store our length and avoid writing it out to the buffer. + override fun lift(value: RustBuffer.ByValue): String { + try { + val byteArr = ByteArray(value.len.toInt()) + value.asByteBuffer()!!.get(byteArr) + return byteArr.toString(Charsets.UTF_8) + } finally { + RustBuffer.free(value) + } + } + + override fun read(buf: ByteBuffer): String { + val len = buf.getInt() + val byteArr = ByteArray(len) + buf.get(byteArr) + return byteArr.toString(Charsets.UTF_8) + } + + fun toUtf8(value: String): ByteBuffer { + // Make sure we don't have invalid UTF-16, check for lone surrogates. + return Charsets.UTF_8.newEncoder().run { + onMalformedInput(CodingErrorAction.REPORT) + encode(CharBuffer.wrap(value)) + } + } + + override fun lower(value: String): RustBuffer.ByValue { + val byteBuf = toUtf8(value) + // Ideally we'd pass these bytes to `ffi_bytebuffer_from_bytes`, but doing so would require us + // to copy them into a JNA `Memory`. So we might as well directly copy them into a `RustBuffer`. + val rbuf = RustBuffer.alloc(byteBuf.limit().toULong()) + rbuf.asByteBuffer()!!.put(byteBuf) + return rbuf + } + + // We aren't sure exactly how many bytes our string will be once it's UTF-8 + // encoded. Allocate 3 bytes per UTF-16 code unit which will always be + // enough. + override fun allocationSize(value: String): ULong { + val sizeForLength = 4UL + val sizeForString = value.length.toULong() * 3UL + return sizeForLength + sizeForString + } + + override fun write( + value: String, + buf: ByteBuffer, + ) { + val byteBuf = toUtf8(value) + buf.putInt(byteBuf.limit()) + buf.put(byteBuf) + } +} + +/** + * @suppress + */ +public object FfiConverterByteArray : FfiConverterRustBuffer { + override fun read(buf: ByteBuffer): ByteArray { + val len = buf.getInt() + val byteArr = ByteArray(len) + buf.get(byteArr) + return byteArr + } + + override fun allocationSize(value: ByteArray): ULong = 4UL + value.size.toULong() + + override fun write( + value: ByteArray, + buf: ByteBuffer, + ) { + buf.putInt(value.size) + buf.put(value) + } +} + +/** + * Represents an app call transaction that interacts with Algorand Smart Contracts. + * + * App call transactions are used to create, update, delete, opt-in to, + * close out of, or clear state from Algorand applications (smart contracts). + */ +data class AppCallTransactionFields( + /** + * ID of the app being called. + * + * Set this to 0 to indicate an app creation call. + */ + var `appId`: kotlin.ULong, + /** + * Defines what additional actions occur with the transaction. + */ + var `onComplete`: OnApplicationComplete, + /** + * Logic executed for every app call transaction, except when + * on-completion is set to "clear". + * + * Approval programs may reject the transaction. + * Only required for app creation and update transactions. + */ + var `approvalProgram`: kotlin.ByteArray? = null, + /** + * Logic executed for app call transactions with on-completion set to "clear". + * + * Clear state programs cannot reject the transaction. + * Only required for app creation and update transactions. + */ + var `clearStateProgram`: kotlin.ByteArray? = null, + /** + * Holds the maximum number of global state values. + * + * Only required for app creation transactions. + * This cannot be changed after creation. + */ + var `globalStateSchema`: StateSchema? = null, + /** + * Holds the maximum number of local state values. + * + * Only required for app creation transactions. + * This cannot be changed after creation. + */ + var `localStateSchema`: StateSchema? = null, + /** + * Number of additional pages allocated to the app's approval + * and clear state programs. + * + * Each extra program page is 2048 bytes. The sum of approval program + * and clear state program may not exceed 2048*(1+extra_program_pages) bytes. + * Currently, the maximum value is 3. + * This cannot be changed after creation. + */ + var `extraProgramPages`: kotlin.UInt? = null, + /** + * Transaction specific arguments available in the app's + * approval program and clear state program. + */ + var `args`: List? = null, + /** + * List of accounts in addition to the sender that may be accessed + * from the app's approval program and clear state program. + */ + var `accountReferences`: List? = null, + /** + * List of apps in addition to the current app that may be called + * from the app's approval program and clear state program. + */ + var `appReferences`: List? = null, + /** + * Lists the assets whose parameters may be accessed by this app's + * approval program and clear state program. + * + * The access is read-only. + */ + var `assetReferences`: List? = null, + /** + * The boxes that should be made available for the runtime of the program. + */ + var `boxReferences`: List? = null, +) { + companion object +} + +/** + * @suppress + */ +public object FfiConverterTypeAppCallTransactionFields : FfiConverterRustBuffer { + override fun read(buf: ByteBuffer): AppCallTransactionFields = + AppCallTransactionFields( + FfiConverterULong.read(buf), + FfiConverterTypeOnApplicationComplete.read(buf), + FfiConverterOptionalByteArray.read(buf), + FfiConverterOptionalByteArray.read(buf), + FfiConverterOptionalTypeStateSchema.read(buf), + FfiConverterOptionalTypeStateSchema.read(buf), + FfiConverterOptionalUInt.read(buf), + FfiConverterOptionalSequenceByteArray.read(buf), + FfiConverterOptionalSequenceString.read(buf), + FfiConverterOptionalSequenceULong.read(buf), + FfiConverterOptionalSequenceULong.read(buf), + FfiConverterOptionalSequenceTypeBoxReference.read(buf), + ) + + override fun allocationSize(value: AppCallTransactionFields) = + ( + FfiConverterULong.allocationSize(value.`appId`) + + FfiConverterTypeOnApplicationComplete.allocationSize(value.`onComplete`) + + FfiConverterOptionalByteArray.allocationSize(value.`approvalProgram`) + + FfiConverterOptionalByteArray.allocationSize(value.`clearStateProgram`) + + FfiConverterOptionalTypeStateSchema.allocationSize(value.`globalStateSchema`) + + FfiConverterOptionalTypeStateSchema.allocationSize(value.`localStateSchema`) + + FfiConverterOptionalUInt.allocationSize(value.`extraProgramPages`) + + FfiConverterOptionalSequenceByteArray.allocationSize(value.`args`) + + FfiConverterOptionalSequenceString.allocationSize(value.`accountReferences`) + + FfiConverterOptionalSequenceULong.allocationSize(value.`appReferences`) + + FfiConverterOptionalSequenceULong.allocationSize(value.`assetReferences`) + + FfiConverterOptionalSequenceTypeBoxReference.allocationSize(value.`boxReferences`) + ) + + override fun write( + value: AppCallTransactionFields, + buf: ByteBuffer, + ) { + FfiConverterULong.write(value.`appId`, buf) + FfiConverterTypeOnApplicationComplete.write(value.`onComplete`, buf) + FfiConverterOptionalByteArray.write(value.`approvalProgram`, buf) + FfiConverterOptionalByteArray.write(value.`clearStateProgram`, buf) + FfiConverterOptionalTypeStateSchema.write(value.`globalStateSchema`, buf) + FfiConverterOptionalTypeStateSchema.write(value.`localStateSchema`, buf) + FfiConverterOptionalUInt.write(value.`extraProgramPages`, buf) + FfiConverterOptionalSequenceByteArray.write(value.`args`, buf) + FfiConverterOptionalSequenceString.write(value.`accountReferences`, buf) + FfiConverterOptionalSequenceULong.write(value.`appReferences`, buf) + FfiConverterOptionalSequenceULong.write(value.`assetReferences`, buf) + FfiConverterOptionalSequenceTypeBoxReference.write(value.`boxReferences`, buf) + } +} + +/** + * Parameters to define an asset config transaction. + * + * For asset creation, the asset ID field must be 0. + * For asset reconfiguration, the asset ID field must be set. Only fields manager, reserve, freeze, and clawback can be set. + * For asset destroy, the asset ID field must be set, all other fields must not be set. + * + * **Note:** The manager, reserve, freeze, and clawback addresses + * are immutably empty if they are not set. If manager is not set then + * all fields are immutable from that point forward. + */ +data class AssetConfigTransactionFields( + /** + * ID of the asset to operate on. + * + * For asset creation, this must be 0. + * For asset reconfiguration this is the ID of the existing asset to be reconfigured, + * For asset destroy this is the ID of the existing asset to be destroyed. + */ + var `assetId`: kotlin.ULong, + /** + * The total amount of the smallest divisible (decimal) unit to create. + * + * Required when creating a new asset. + * For example, if creating a asset with 2 decimals and wanting a total supply of 100 units, this value should be 10000. + * + * This field can only be specified upon asset creation. + */ + var `total`: kotlin.ULong? = null, + /** + * The amount of decimal places the asset should have. + * + * If unspecified then the asset will be in whole units (i.e. `0`). + * * If 0, the asset is not divisible; + * * If 1, the base unit of the asset is in tenths; + * * If 2, the base unit of the asset is in hundredths; + * * If 3, the base unit of the asset is in thousandths; + * + * and so on up to 19 decimal places. + * + * This field can only be specified upon asset creation. + */ + var `decimals`: kotlin.UInt? = null, + /** + * Whether the asset is frozen by default for all accounts. + * Defaults to `false`. + * + * If `true` then for anyone apart from the creator to hold the + * asset it needs to be unfrozen per account using an asset freeze + * transaction from the `freeze` account, which must be set on creation. + * + * This field can only be specified upon asset creation. + */ + var `defaultFrozen`: kotlin.Boolean? = null, + /** + * The optional name of the asset. + * + * Max size is 32 bytes. + * + * This field can only be specified upon asset creation. + */ + var `assetName`: kotlin.String? = null, + /** + * The optional name of the unit of this asset (e.g. ticker name). + * + * Max size is 8 bytes. + * + * This field can only be specified upon asset creation. + */ + var `unitName`: kotlin.String? = null, + /** + * Specifies an optional URL where more information about the asset can be retrieved (e.g. metadata). + * + * Max size is 96 bytes. + * + * This field can only be specified upon asset creation. + */ + var `url`: kotlin.String? = null, + /** + * 32-byte hash of some metadata that is relevant to your asset and/or asset holders. + * + * The format of this metadata is up to the application. + * + * This field can only be specified upon asset creation. + */ + var `metadataHash`: kotlin.ByteArray? = null, + /** + * The address of the optional account that can manage the configuration of the asset and destroy it. + * + * The fields it can change are `manager`, `reserve`, `clawback`, and `freeze`. + * + * If not set or set to the Zero address the asset becomes permanently immutable. + */ + var `manager`: kotlin.String? = null, + /** + * The address of the optional account that holds the reserve (uncirculated supply) units of the asset. + * + * This address has no specific authority in the protocol itself and is informational only. + * + * Some standards like [ARC-19](https://github.com/algorandfoundation/ARCs/blob/main/ARCs/arc-0019.md) + * rely on this field to hold meaningful data. + * + * It can be used in the case where you want to signal to holders of your asset that the uncirculated units + * of the asset reside in an account that is different from the default creator account. + * + * If not set or set to the Zero address is permanently empty. + */ + var `reserve`: kotlin.String? = null, + /** + * The address of the optional account that can be used to freeze or unfreeze holdings of this asset for any account. + * + * If empty, freezing is not permitted. + * + * If not set or set to the Zero address is permanently empty. + */ + var `freeze`: kotlin.String? = null, + /** + * The address of the optional account that can clawback holdings of this asset from any account. + * + * **This field should be used with caution** as the clawback account has the ability to **unconditionally take assets from any account**. + * + * If empty, clawback is not permitted. + * + * If not set or set to the Zero address is permanently empty. + */ + var `clawback`: kotlin.String? = null, +) { + companion object +} + +/** + * @suppress + */ +public object FfiConverterTypeAssetConfigTransactionFields : FfiConverterRustBuffer { + override fun read(buf: ByteBuffer): AssetConfigTransactionFields = + AssetConfigTransactionFields( + FfiConverterULong.read(buf), + FfiConverterOptionalULong.read(buf), + FfiConverterOptionalUInt.read(buf), + FfiConverterOptionalBoolean.read(buf), + FfiConverterOptionalString.read(buf), + FfiConverterOptionalString.read(buf), + FfiConverterOptionalString.read(buf), + FfiConverterOptionalByteArray.read(buf), + FfiConverterOptionalString.read(buf), + FfiConverterOptionalString.read(buf), + FfiConverterOptionalString.read(buf), + FfiConverterOptionalString.read(buf), + ) + + override fun allocationSize(value: AssetConfigTransactionFields) = + ( + FfiConverterULong.allocationSize(value.`assetId`) + + FfiConverterOptionalULong.allocationSize(value.`total`) + + FfiConverterOptionalUInt.allocationSize(value.`decimals`) + + FfiConverterOptionalBoolean.allocationSize(value.`defaultFrozen`) + + FfiConverterOptionalString.allocationSize(value.`assetName`) + + FfiConverterOptionalString.allocationSize(value.`unitName`) + + FfiConverterOptionalString.allocationSize(value.`url`) + + FfiConverterOptionalByteArray.allocationSize(value.`metadataHash`) + + FfiConverterOptionalString.allocationSize(value.`manager`) + + FfiConverterOptionalString.allocationSize(value.`reserve`) + + FfiConverterOptionalString.allocationSize(value.`freeze`) + + FfiConverterOptionalString.allocationSize(value.`clawback`) + ) + + override fun write( + value: AssetConfigTransactionFields, + buf: ByteBuffer, + ) { + FfiConverterULong.write(value.`assetId`, buf) + FfiConverterOptionalULong.write(value.`total`, buf) + FfiConverterOptionalUInt.write(value.`decimals`, buf) + FfiConverterOptionalBoolean.write(value.`defaultFrozen`, buf) + FfiConverterOptionalString.write(value.`assetName`, buf) + FfiConverterOptionalString.write(value.`unitName`, buf) + FfiConverterOptionalString.write(value.`url`, buf) + FfiConverterOptionalByteArray.write(value.`metadataHash`, buf) + FfiConverterOptionalString.write(value.`manager`, buf) + FfiConverterOptionalString.write(value.`reserve`, buf) + FfiConverterOptionalString.write(value.`freeze`, buf) + FfiConverterOptionalString.write(value.`clawback`, buf) + } +} + +/** + * Represents an asset freeze transaction that freezes or unfreezes asset holdings. + * + * Asset freeze transactions are used by the asset freeze account to control + * whether a specific account can transfer a particular asset. + */ +data class AssetFreezeTransactionFields( + /** + * The ID of the asset being frozen/unfrozen. + */ + var `assetId`: kotlin.ULong, + /** + * The target account whose asset holdings will be affected. + */ + var `freezeTarget`: kotlin.String, + /** + * The new freeze status. + * + * `true` to freeze the asset holdings (prevent transfers), + * `false` to unfreeze the asset holdings (allow transfers). + */ + var `frozen`: kotlin.Boolean, +) { + companion object +} + +/** + * @suppress + */ +public object FfiConverterTypeAssetFreezeTransactionFields : FfiConverterRustBuffer { + override fun read(buf: ByteBuffer): AssetFreezeTransactionFields = + AssetFreezeTransactionFields( + FfiConverterULong.read(buf), + FfiConverterString.read(buf), + FfiConverterBoolean.read(buf), + ) + + override fun allocationSize(value: AssetFreezeTransactionFields) = + ( + FfiConverterULong.allocationSize(value.`assetId`) + + FfiConverterString.allocationSize(value.`freezeTarget`) + + FfiConverterBoolean.allocationSize(value.`frozen`) + ) + + override fun write( + value: AssetFreezeTransactionFields, + buf: ByteBuffer, + ) { + FfiConverterULong.write(value.`assetId`, buf) + FfiConverterString.write(value.`freezeTarget`, buf) + FfiConverterBoolean.write(value.`frozen`, buf) + } +} + +data class AssetTransferTransactionFields( + var `assetId`: kotlin.ULong, + var `amount`: kotlin.ULong, + var `receiver`: kotlin.String, + var `assetSender`: kotlin.String? = null, + var `closeRemainderTo`: kotlin.String? = null, +) { + companion object +} + +/** + * @suppress + */ +public object FfiConverterTypeAssetTransferTransactionFields : FfiConverterRustBuffer { + override fun read(buf: ByteBuffer): AssetTransferTransactionFields = + AssetTransferTransactionFields( + FfiConverterULong.read(buf), + FfiConverterULong.read(buf), + FfiConverterString.read(buf), + FfiConverterOptionalString.read(buf), + FfiConverterOptionalString.read(buf), + ) + + override fun allocationSize(value: AssetTransferTransactionFields) = + ( + FfiConverterULong.allocationSize(value.`assetId`) + + FfiConverterULong.allocationSize(value.`amount`) + + FfiConverterString.allocationSize(value.`receiver`) + + FfiConverterOptionalString.allocationSize(value.`assetSender`) + + FfiConverterOptionalString.allocationSize(value.`closeRemainderTo`) + ) + + override fun write( + value: AssetTransferTransactionFields, + buf: ByteBuffer, + ) { + FfiConverterULong.write(value.`assetId`, buf) + FfiConverterULong.write(value.`amount`, buf) + FfiConverterString.write(value.`receiver`, buf) + FfiConverterOptionalString.write(value.`assetSender`, buf) + FfiConverterOptionalString.write(value.`closeRemainderTo`, buf) + } +} + +/** + * Box reference for app call transactions. + * + * References a specific box that should be made available for the runtime + * of the program. + */ +data class BoxReference( + /** + * App ID that owns the box. + * A value of 0 indicates the current app. + */ + var `appId`: kotlin.ULong, + /** + * Name of the box. + */ + var `name`: kotlin.ByteArray, +) { + companion object +} + +/** + * @suppress + */ +public object FfiConverterTypeBoxReference : FfiConverterRustBuffer { + override fun read(buf: ByteBuffer): BoxReference = + BoxReference( + FfiConverterULong.read(buf), + FfiConverterByteArray.read(buf), + ) + + override fun allocationSize(value: BoxReference) = + ( + FfiConverterULong.allocationSize(value.`appId`) + + FfiConverterByteArray.allocationSize(value.`name`) + ) + + override fun write( + value: BoxReference, + buf: ByteBuffer, + ) { + FfiConverterULong.write(value.`appId`, buf) + FfiConverterByteArray.write(value.`name`, buf) + } +} + +data class FeeParams( + var `feePerByte`: kotlin.ULong, + var `minFee`: kotlin.ULong, + var `extraFee`: kotlin.ULong? = null, + var `maxFee`: kotlin.ULong? = null, +) { + companion object +} + +/** + * @suppress + */ +public object FfiConverterTypeFeeParams : FfiConverterRustBuffer { + override fun read(buf: ByteBuffer): FeeParams = + FeeParams( + FfiConverterULong.read(buf), + FfiConverterULong.read(buf), + FfiConverterOptionalULong.read(buf), + FfiConverterOptionalULong.read(buf), + ) + + override fun allocationSize(value: FeeParams) = + ( + FfiConverterULong.allocationSize(value.`feePerByte`) + + FfiConverterULong.allocationSize(value.`minFee`) + + FfiConverterOptionalULong.allocationSize(value.`extraFee`) + + FfiConverterOptionalULong.allocationSize(value.`maxFee`) + ) + + override fun write( + value: FeeParams, + buf: ByteBuffer, + ) { + FfiConverterULong.write(value.`feePerByte`, buf) + FfiConverterULong.write(value.`minFee`, buf) + FfiConverterOptionalULong.write(value.`extraFee`, buf) + FfiConverterOptionalULong.write(value.`maxFee`, buf) + } +} + +data class KeyPairAccount( + var `pubKey`: kotlin.ByteArray, +) { + companion object +} + +/** + * @suppress + */ +public object FfiConverterTypeKeyPairAccount : FfiConverterRustBuffer { + override fun read(buf: ByteBuffer): KeyPairAccount = + KeyPairAccount( + FfiConverterByteArray.read(buf), + ) + + override fun allocationSize(value: KeyPairAccount) = + ( + FfiConverterByteArray.allocationSize(value.`pubKey`) + ) + + override fun write( + value: KeyPairAccount, + buf: ByteBuffer, + ) { + FfiConverterByteArray.write(value.`pubKey`, buf) + } +} + +data class KeyRegistrationTransactionFields( + /** + * Root participation public key (32 bytes) + */ + var `voteKey`: kotlin.ByteArray? = null, + /** + * VRF public key (32 bytes) + */ + var `selectionKey`: kotlin.ByteArray? = null, + /** + * State proof key (64 bytes) + */ + var `stateProofKey`: kotlin.ByteArray? = null, + /** + * First round for which the participation key is valid + */ + var `voteFirst`: kotlin.ULong? = null, + /** + * Last round for which the participation key is valid + */ + var `voteLast`: kotlin.ULong? = null, + /** + * Key dilution for the 2-level participation key + */ + var `voteKeyDilution`: kotlin.ULong? = null, + /** + * Mark account as non-reward earning + */ + var `nonParticipation`: kotlin.Boolean? = null, +) { + companion object +} + +/** + * @suppress + */ +public object FfiConverterTypeKeyRegistrationTransactionFields : FfiConverterRustBuffer { + override fun read(buf: ByteBuffer): KeyRegistrationTransactionFields = + KeyRegistrationTransactionFields( + FfiConverterOptionalByteArray.read(buf), + FfiConverterOptionalByteArray.read(buf), + FfiConverterOptionalByteArray.read(buf), + FfiConverterOptionalULong.read(buf), + FfiConverterOptionalULong.read(buf), + FfiConverterOptionalULong.read(buf), + FfiConverterOptionalBoolean.read(buf), + ) + + override fun allocationSize(value: KeyRegistrationTransactionFields) = + ( + FfiConverterOptionalByteArray.allocationSize(value.`voteKey`) + + FfiConverterOptionalByteArray.allocationSize(value.`selectionKey`) + + FfiConverterOptionalByteArray.allocationSize(value.`stateProofKey`) + + FfiConverterOptionalULong.allocationSize(value.`voteFirst`) + + FfiConverterOptionalULong.allocationSize(value.`voteLast`) + + FfiConverterOptionalULong.allocationSize(value.`voteKeyDilution`) + + FfiConverterOptionalBoolean.allocationSize(value.`nonParticipation`) + ) + + override fun write( + value: KeyRegistrationTransactionFields, + buf: ByteBuffer, + ) { + FfiConverterOptionalByteArray.write(value.`voteKey`, buf) + FfiConverterOptionalByteArray.write(value.`selectionKey`, buf) + FfiConverterOptionalByteArray.write(value.`stateProofKey`, buf) + FfiConverterOptionalULong.write(value.`voteFirst`, buf) + FfiConverterOptionalULong.write(value.`voteLast`, buf) + FfiConverterOptionalULong.write(value.`voteKeyDilution`, buf) + FfiConverterOptionalBoolean.write(value.`nonParticipation`, buf) + } +} + +/** + * Representation of an Algorand multisignature signature. + */ +data class MultisigSignature( + /** + * Multisig version. + */ + var `version`: kotlin.UByte, + /** + * Minimum number of signatures required. + */ + var `threshold`: kotlin.UByte, + /** + * List of subsignatures for each participant. + */ + var `subsignatures`: List, +) { + companion object +} + +/** + * @suppress + */ +public object FfiConverterTypeMultisigSignature : FfiConverterRustBuffer { + override fun read(buf: ByteBuffer): MultisigSignature = + MultisigSignature( + FfiConverterUByte.read(buf), + FfiConverterUByte.read(buf), + FfiConverterSequenceTypeMultisigSubsignature.read(buf), + ) + + override fun allocationSize(value: MultisigSignature) = + ( + FfiConverterUByte.allocationSize(value.`version`) + + FfiConverterUByte.allocationSize(value.`threshold`) + + FfiConverterSequenceTypeMultisigSubsignature.allocationSize(value.`subsignatures`) + ) + + override fun write( + value: MultisigSignature, + buf: ByteBuffer, + ) { + FfiConverterUByte.write(value.`version`, buf) + FfiConverterUByte.write(value.`threshold`, buf) + FfiConverterSequenceTypeMultisigSubsignature.write(value.`subsignatures`, buf) + } +} + +/** + * Representation of a single subsignature in a multisignature transaction. + * + * Each subsignature contains the participant's address and an optional signature. + */ +data class MultisigSubsignature( + /** + * Address of the participant. + */ + var `address`: kotlin.String, + /** + * Optional signature bytes for the participant. + */ + var `signature`: kotlin.ByteArray? = null, +) { + companion object +} + +/** + * @suppress + */ +public object FfiConverterTypeMultisigSubsignature : FfiConverterRustBuffer { + override fun read(buf: ByteBuffer): MultisigSubsignature = + MultisigSubsignature( + FfiConverterString.read(buf), + FfiConverterOptionalByteArray.read(buf), + ) + + override fun allocationSize(value: MultisigSubsignature) = + ( + FfiConverterString.allocationSize(value.`address`) + + FfiConverterOptionalByteArray.allocationSize(value.`signature`) + ) + + override fun write( + value: MultisigSubsignature, + buf: ByteBuffer, + ) { + FfiConverterString.write(value.`address`, buf) + FfiConverterOptionalByteArray.write(value.`signature`, buf) + } +} + +data class PaymentTransactionFields( + var `receiver`: kotlin.String, + var `amount`: kotlin.ULong, + var `closeRemainderTo`: kotlin.String? = null, +) { + companion object +} + +/** + * @suppress + */ +public object FfiConverterTypePaymentTransactionFields : FfiConverterRustBuffer { + override fun read(buf: ByteBuffer): PaymentTransactionFields = + PaymentTransactionFields( + FfiConverterString.read(buf), + FfiConverterULong.read(buf), + FfiConverterOptionalString.read(buf), + ) + + override fun allocationSize(value: PaymentTransactionFields) = + ( + FfiConverterString.allocationSize(value.`receiver`) + + FfiConverterULong.allocationSize(value.`amount`) + + FfiConverterOptionalString.allocationSize(value.`closeRemainderTo`) + ) + + override fun write( + value: PaymentTransactionFields, + buf: ByteBuffer, + ) { + FfiConverterString.write(value.`receiver`, buf) + FfiConverterULong.write(value.`amount`, buf) + FfiConverterOptionalString.write(value.`closeRemainderTo`, buf) + } +} + +data class SignedTransaction( + /** + * The transaction that has been signed. + */ + var `transaction`: Transaction, + /** + * Optional Ed25519 signature authorizing the transaction. + */ + var `signature`: kotlin.ByteArray? = null, + /** + * Optional auth address applicable if the transaction sender is a rekeyed account. + */ + var `authAddress`: kotlin.String? = null, + /** + * Optional multisig signature if the transaction is a multisig transaction. + */ + var `multisignature`: MultisigSignature? = null, +) { + companion object +} + +/** + * @suppress + */ +public object FfiConverterTypeSignedTransaction : FfiConverterRustBuffer { + override fun read(buf: ByteBuffer): SignedTransaction = + SignedTransaction( + FfiConverterTypeTransaction.read(buf), + FfiConverterOptionalByteArray.read(buf), + FfiConverterOptionalString.read(buf), + FfiConverterOptionalTypeMultisigSignature.read(buf), + ) + + override fun allocationSize(value: SignedTransaction) = + ( + FfiConverterTypeTransaction.allocationSize(value.`transaction`) + + FfiConverterOptionalByteArray.allocationSize(value.`signature`) + + FfiConverterOptionalString.allocationSize(value.`authAddress`) + + FfiConverterOptionalTypeMultisigSignature.allocationSize(value.`multisignature`) + ) + + override fun write( + value: SignedTransaction, + buf: ByteBuffer, + ) { + FfiConverterTypeTransaction.write(value.`transaction`, buf) + FfiConverterOptionalByteArray.write(value.`signature`, buf) + FfiConverterOptionalString.write(value.`authAddress`, buf) + FfiConverterOptionalTypeMultisigSignature.write(value.`multisignature`, buf) + } +} + +/** + * Schema for app state storage. + * + * Defines the maximum number of values that may be stored in app + * key/value storage for both global and local state. + */ +data class StateSchema( + /** + * Maximum number of integer values that may be stored. + */ + var `numUints`: kotlin.UInt, + /** + * Maximum number of byte slice values that may be stored. + */ + var `numByteSlices`: kotlin.UInt, +) { + companion object +} + +/** + * @suppress + */ +public object FfiConverterTypeStateSchema : FfiConverterRustBuffer { + override fun read(buf: ByteBuffer): StateSchema = + StateSchema( + FfiConverterUInt.read(buf), + FfiConverterUInt.read(buf), + ) + + override fun allocationSize(value: StateSchema) = + ( + FfiConverterUInt.allocationSize(value.`numUints`) + + FfiConverterUInt.allocationSize(value.`numByteSlices`) + ) + + override fun write( + value: StateSchema, + buf: ByteBuffer, + ) { + FfiConverterUInt.write(value.`numUints`, buf) + FfiConverterUInt.write(value.`numByteSlices`, buf) + } +} + +data class Transaction( + /** + * The type of transaction + */ + var `transactionType`: TransactionType, + /** + * The sender of the transaction + */ + var `sender`: kotlin.String, + /** + * Optional transaction fee in microALGO. + * + * If not set, the fee will be interpreted as 0 by the network. + */ + var `fee`: kotlin.ULong? = null, + var `firstValid`: kotlin.ULong, + var `lastValid`: kotlin.ULong, + var `genesisHash`: kotlin.ByteArray?, + var `genesisId`: kotlin.String?, + var `note`: kotlin.ByteArray? = null, + var `rekeyTo`: kotlin.String? = null, + var `lease`: kotlin.ByteArray? = null, + var `group`: kotlin.ByteArray? = null, + var `payment`: PaymentTransactionFields? = null, + var `assetTransfer`: AssetTransferTransactionFields? = null, + var `assetConfig`: AssetConfigTransactionFields? = null, + var `appCall`: AppCallTransactionFields? = null, + var `keyRegistration`: KeyRegistrationTransactionFields? = null, + var `assetFreeze`: AssetFreezeTransactionFields? = null, +) { + companion object +} + +/** + * @suppress + */ +public object FfiConverterTypeTransaction : FfiConverterRustBuffer { + override fun read(buf: ByteBuffer): Transaction = + Transaction( + FfiConverterTypeTransactionType.read(buf), + FfiConverterString.read(buf), + FfiConverterOptionalULong.read(buf), + FfiConverterULong.read(buf), + FfiConverterULong.read(buf), + FfiConverterOptionalByteArray.read(buf), + FfiConverterOptionalString.read(buf), + FfiConverterOptionalByteArray.read(buf), + FfiConverterOptionalString.read(buf), + FfiConverterOptionalByteArray.read(buf), + FfiConverterOptionalByteArray.read(buf), + FfiConverterOptionalTypePaymentTransactionFields.read(buf), + FfiConverterOptionalTypeAssetTransferTransactionFields.read(buf), + FfiConverterOptionalTypeAssetConfigTransactionFields.read(buf), + FfiConverterOptionalTypeAppCallTransactionFields.read(buf), + FfiConverterOptionalTypeKeyRegistrationTransactionFields.read(buf), + FfiConverterOptionalTypeAssetFreezeTransactionFields.read(buf), + ) + + override fun allocationSize(value: Transaction) = + ( + FfiConverterTypeTransactionType.allocationSize(value.`transactionType`) + + FfiConverterString.allocationSize(value.`sender`) + + FfiConverterOptionalULong.allocationSize(value.`fee`) + + FfiConverterULong.allocationSize(value.`firstValid`) + + FfiConverterULong.allocationSize(value.`lastValid`) + + FfiConverterOptionalByteArray.allocationSize(value.`genesisHash`) + + FfiConverterOptionalString.allocationSize(value.`genesisId`) + + FfiConverterOptionalByteArray.allocationSize(value.`note`) + + FfiConverterOptionalString.allocationSize(value.`rekeyTo`) + + FfiConverterOptionalByteArray.allocationSize(value.`lease`) + + FfiConverterOptionalByteArray.allocationSize(value.`group`) + + FfiConverterOptionalTypePaymentTransactionFields.allocationSize(value.`payment`) + + FfiConverterOptionalTypeAssetTransferTransactionFields.allocationSize(value.`assetTransfer`) + + FfiConverterOptionalTypeAssetConfigTransactionFields.allocationSize(value.`assetConfig`) + + FfiConverterOptionalTypeAppCallTransactionFields.allocationSize(value.`appCall`) + + FfiConverterOptionalTypeKeyRegistrationTransactionFields.allocationSize(value.`keyRegistration`) + + FfiConverterOptionalTypeAssetFreezeTransactionFields.allocationSize(value.`assetFreeze`) + ) + + override fun write( + value: Transaction, + buf: ByteBuffer, + ) { + FfiConverterTypeTransactionType.write(value.`transactionType`, buf) + FfiConverterString.write(value.`sender`, buf) + FfiConverterOptionalULong.write(value.`fee`, buf) + FfiConverterULong.write(value.`firstValid`, buf) + FfiConverterULong.write(value.`lastValid`, buf) + FfiConverterOptionalByteArray.write(value.`genesisHash`, buf) + FfiConverterOptionalString.write(value.`genesisId`, buf) + FfiConverterOptionalByteArray.write(value.`note`, buf) + FfiConverterOptionalString.write(value.`rekeyTo`, buf) + FfiConverterOptionalByteArray.write(value.`lease`, buf) + FfiConverterOptionalByteArray.write(value.`group`, buf) + FfiConverterOptionalTypePaymentTransactionFields.write(value.`payment`, buf) + FfiConverterOptionalTypeAssetTransferTransactionFields.write(value.`assetTransfer`, buf) + FfiConverterOptionalTypeAssetConfigTransactionFields.write(value.`assetConfig`, buf) + FfiConverterOptionalTypeAppCallTransactionFields.write(value.`appCall`, buf) + FfiConverterOptionalTypeKeyRegistrationTransactionFields.write(value.`keyRegistration`, buf) + FfiConverterOptionalTypeAssetFreezeTransactionFields.write(value.`assetFreeze`, buf) + } +} + +sealed class AlgoKitTransactException : kotlin.Exception() { + class EncodingException( + val `errorMsg`: kotlin.String, + ) : AlgoKitTransactException() { + override val message + get() = "errorMsg=${ `errorMsg` }" + } + + class DecodingException( + val `errorMsg`: kotlin.String, + ) : AlgoKitTransactException() { + override val message + get() = "errorMsg=${ `errorMsg` }" + } + + class InputException( + val `errorMsg`: kotlin.String, + ) : AlgoKitTransactException() { + override val message + get() = "errorMsg=${ `errorMsg` }" + } + + class MsgPackException( + val `errorMsg`: kotlin.String, + ) : AlgoKitTransactException() { + override val message + get() = "errorMsg=${ `errorMsg` }" + } + + companion object ErrorHandler : UniffiRustCallStatusErrorHandler { + override fun lift(error_buf: RustBuffer.ByValue): AlgoKitTransactException = FfiConverterTypeAlgoKitTransactError.lift(error_buf) + } +} + +/** + * @suppress + */ +public object FfiConverterTypeAlgoKitTransactError : FfiConverterRustBuffer { + override fun read(buf: ByteBuffer): AlgoKitTransactException = + when (buf.getInt()) { + 1 -> + AlgoKitTransactException.EncodingException( + FfiConverterString.read(buf), + ) + 2 -> + AlgoKitTransactException.DecodingException( + FfiConverterString.read(buf), + ) + 3 -> + AlgoKitTransactException.InputException( + FfiConverterString.read(buf), + ) + 4 -> + AlgoKitTransactException.MsgPackException( + FfiConverterString.read(buf), + ) + else -> throw RuntimeException("invalid error enum value, something is very wrong!!") + } + + override fun allocationSize(value: AlgoKitTransactException): ULong = + when (value) { + is AlgoKitTransactException.EncodingException -> ( + // Add the size for the Int that specifies the variant plus the size needed for all fields + 4UL + + FfiConverterString.allocationSize(value.`errorMsg`) + ) + is AlgoKitTransactException.DecodingException -> ( + // Add the size for the Int that specifies the variant plus the size needed for all fields + 4UL + + FfiConverterString.allocationSize(value.`errorMsg`) + ) + is AlgoKitTransactException.InputException -> ( + // Add the size for the Int that specifies the variant plus the size needed for all fields + 4UL + + FfiConverterString.allocationSize(value.`errorMsg`) + ) + is AlgoKitTransactException.MsgPackException -> ( + // Add the size for the Int that specifies the variant plus the size needed for all fields + 4UL + + FfiConverterString.allocationSize(value.`errorMsg`) + ) + } + + override fun write( + value: AlgoKitTransactException, + buf: ByteBuffer, + ) { + when (value) { + is AlgoKitTransactException.EncodingException -> { + buf.putInt(1) + FfiConverterString.write(value.`errorMsg`, buf) + Unit + } + is AlgoKitTransactException.DecodingException -> { + buf.putInt(2) + FfiConverterString.write(value.`errorMsg`, buf) + Unit + } + is AlgoKitTransactException.InputException -> { + buf.putInt(3) + FfiConverterString.write(value.`errorMsg`, buf) + Unit + } + is AlgoKitTransactException.MsgPackException -> { + buf.putInt(4) + FfiConverterString.write(value.`errorMsg`, buf) + Unit + } + }.let { /* this makes the `when` an expression, which ensures it is exhaustive */ } + } +} + +/** + * Enum containing all constants used in this crate. + */ + +enum class AlgorandConstant { + /** + * Length of hash digests (32) + */ + HASH_LENGTH, + + /** + * Length of the checksum used in Algorand addresses (4) + */ + CHECKSUM_LENGTH, + + /** + * Length of a base32-encoded Algorand address (58) + */ + ADDRESS_LENGTH, + + /** + * Length of an Algorand public key in bytes (32) + */ + PUBLIC_KEY_LENGTH, + + /** + * Length of an Algorand secret key in bytes (32) + */ + SECRET_KEY_LENGTH, + + /** + * Length of an Algorand signature in bytes (64) + */ + SIGNATURE_LENGTH, + + /** + * Increment in the encoded byte size when a signature is attached to a transaction (75) + */ + SIGNATURE_ENCODING_INCR_LENGTH, + + /** + * The maximum number of transactions in a group (16) + */ + MAX_TX_GROUP_SIZE, + + ; + + companion object +} + +/** + * @suppress + */ +public object FfiConverterTypeAlgorandConstant : FfiConverterRustBuffer { + override fun read(buf: ByteBuffer) = + try { + AlgorandConstant.values()[buf.getInt() - 1] + } catch (e: IndexOutOfBoundsException) { + throw RuntimeException("invalid enum value, something is very wrong!!", e) + } + + override fun allocationSize(value: AlgorandConstant) = 4UL + + override fun write( + value: AlgorandConstant, + buf: ByteBuffer, + ) { + buf.putInt(value.ordinal + 1) + } +} + +/** + * On-completion actions for app transactions. + * + * These values define what additional actions occur with the transaction. + */ + +enum class OnApplicationComplete { + /** + * NoOp indicates that an app transaction will simply call its + * approval program without any additional action. + */ + NO_OP, + + /** + * OptIn indicates that an app transaction will allocate some + * local state for the app in the sender's account. + */ + OPT_IN, + + /** + * CloseOut indicates that an app transaction will deallocate + * some local state for the app from the user's account. + */ + CLOSE_OUT, + + /** + * ClearState is similar to CloseOut, but may never fail. This + * allows users to reclaim their minimum balance from an app + * they no longer wish to opt in to. + */ + CLEAR_STATE, + + /** + * UpdateApplication indicates that an app transaction will + * update the approval program and clear state program for the app. + */ + UPDATE_APPLICATION, + + /** + * DeleteApplication indicates that an app transaction will + * delete the app parameters for the app from the creator's + * balance record. + */ + DELETE_APPLICATION, + + ; + + companion object +} + +/** + * @suppress + */ +public object FfiConverterTypeOnApplicationComplete : FfiConverterRustBuffer { + override fun read(buf: ByteBuffer) = + try { + OnApplicationComplete.values()[buf.getInt() - 1] + } catch (e: IndexOutOfBoundsException) { + throw RuntimeException("invalid enum value, something is very wrong!!", e) + } + + override fun allocationSize(value: OnApplicationComplete) = 4UL + + override fun write( + value: OnApplicationComplete, + buf: ByteBuffer, + ) { + buf.putInt(value.ordinal + 1) + } +} + +enum class TransactionType { + PAYMENT, + ASSET_TRANSFER, + ASSET_FREEZE, + ASSET_CONFIG, + KEY_REGISTRATION, + APP_CALL, + ; + + companion object +} + +/** + * @suppress + */ +public object FfiConverterTypeTransactionType : FfiConverterRustBuffer { + override fun read(buf: ByteBuffer) = + try { + TransactionType.values()[buf.getInt() - 1] + } catch (e: IndexOutOfBoundsException) { + throw RuntimeException("invalid enum value, something is very wrong!!", e) + } + + override fun allocationSize(value: TransactionType) = 4UL + + override fun write( + value: TransactionType, + buf: ByteBuffer, + ) { + buf.putInt(value.ordinal + 1) + } +} + +/** + * @suppress + */ +public object FfiConverterOptionalUInt : FfiConverterRustBuffer { + override fun read(buf: ByteBuffer): kotlin.UInt? { + if (buf.get().toInt() == 0) { + return null + } + return FfiConverterUInt.read(buf) + } + + override fun allocationSize(value: kotlin.UInt?): ULong { + if (value == null) { + return 1UL + } else { + return 1UL + FfiConverterUInt.allocationSize(value) + } + } + + override fun write( + value: kotlin.UInt?, + buf: ByteBuffer, + ) { + if (value == null) { + buf.put(0) + } else { + buf.put(1) + FfiConverterUInt.write(value, buf) + } + } +} + +/** + * @suppress + */ +public object FfiConverterOptionalULong : FfiConverterRustBuffer { + override fun read(buf: ByteBuffer): kotlin.ULong? { + if (buf.get().toInt() == 0) { + return null + } + return FfiConverterULong.read(buf) + } + + override fun allocationSize(value: kotlin.ULong?): ULong { + if (value == null) { + return 1UL + } else { + return 1UL + FfiConverterULong.allocationSize(value) + } + } + + override fun write( + value: kotlin.ULong?, + buf: ByteBuffer, + ) { + if (value == null) { + buf.put(0) + } else { + buf.put(1) + FfiConverterULong.write(value, buf) + } + } +} + +/** + * @suppress + */ +public object FfiConverterOptionalBoolean : FfiConverterRustBuffer { + override fun read(buf: ByteBuffer): kotlin.Boolean? { + if (buf.get().toInt() == 0) { + return null + } + return FfiConverterBoolean.read(buf) + } + + override fun allocationSize(value: kotlin.Boolean?): ULong { + if (value == null) { + return 1UL + } else { + return 1UL + FfiConverterBoolean.allocationSize(value) + } + } + + override fun write( + value: kotlin.Boolean?, + buf: ByteBuffer, + ) { + if (value == null) { + buf.put(0) + } else { + buf.put(1) + FfiConverterBoolean.write(value, buf) + } + } +} + +/** + * @suppress + */ +public object FfiConverterOptionalString : FfiConverterRustBuffer { + override fun read(buf: ByteBuffer): kotlin.String? { + if (buf.get().toInt() == 0) { + return null + } + return FfiConverterString.read(buf) + } + + override fun allocationSize(value: kotlin.String?): ULong { + if (value == null) { + return 1UL + } else { + return 1UL + FfiConverterString.allocationSize(value) + } + } + + override fun write( + value: kotlin.String?, + buf: ByteBuffer, + ) { + if (value == null) { + buf.put(0) + } else { + buf.put(1) + FfiConverterString.write(value, buf) + } + } +} + +/** + * @suppress + */ +public object FfiConverterOptionalByteArray : FfiConverterRustBuffer { + override fun read(buf: ByteBuffer): kotlin.ByteArray? { + if (buf.get().toInt() == 0) { + return null + } + return FfiConverterByteArray.read(buf) + } + + override fun allocationSize(value: kotlin.ByteArray?): ULong { + if (value == null) { + return 1UL + } else { + return 1UL + FfiConverterByteArray.allocationSize(value) + } + } + + override fun write( + value: kotlin.ByteArray?, + buf: ByteBuffer, + ) { + if (value == null) { + buf.put(0) + } else { + buf.put(1) + FfiConverterByteArray.write(value, buf) + } + } +} + +/** + * @suppress + */ +public object FfiConverterOptionalTypeAppCallTransactionFields : FfiConverterRustBuffer { + override fun read(buf: ByteBuffer): AppCallTransactionFields? { + if (buf.get().toInt() == 0) { + return null + } + return FfiConverterTypeAppCallTransactionFields.read(buf) + } + + override fun allocationSize(value: AppCallTransactionFields?): ULong { + if (value == null) { + return 1UL + } else { + return 1UL + FfiConverterTypeAppCallTransactionFields.allocationSize(value) + } + } + + override fun write( + value: AppCallTransactionFields?, + buf: ByteBuffer, + ) { + if (value == null) { + buf.put(0) + } else { + buf.put(1) + FfiConverterTypeAppCallTransactionFields.write(value, buf) + } + } +} + +/** + * @suppress + */ +public object FfiConverterOptionalTypeAssetConfigTransactionFields : FfiConverterRustBuffer { + override fun read(buf: ByteBuffer): AssetConfigTransactionFields? { + if (buf.get().toInt() == 0) { + return null + } + return FfiConverterTypeAssetConfigTransactionFields.read(buf) + } + + override fun allocationSize(value: AssetConfigTransactionFields?): ULong { + if (value == null) { + return 1UL + } else { + return 1UL + FfiConverterTypeAssetConfigTransactionFields.allocationSize(value) + } + } + + override fun write( + value: AssetConfigTransactionFields?, + buf: ByteBuffer, + ) { + if (value == null) { + buf.put(0) + } else { + buf.put(1) + FfiConverterTypeAssetConfigTransactionFields.write(value, buf) + } + } +} + +/** + * @suppress + */ +public object FfiConverterOptionalTypeAssetFreezeTransactionFields : FfiConverterRustBuffer { + override fun read(buf: ByteBuffer): AssetFreezeTransactionFields? { + if (buf.get().toInt() == 0) { + return null + } + return FfiConverterTypeAssetFreezeTransactionFields.read(buf) + } + + override fun allocationSize(value: AssetFreezeTransactionFields?): ULong { + if (value == null) { + return 1UL + } else { + return 1UL + FfiConverterTypeAssetFreezeTransactionFields.allocationSize(value) + } + } + + override fun write( + value: AssetFreezeTransactionFields?, + buf: ByteBuffer, + ) { + if (value == null) { + buf.put(0) + } else { + buf.put(1) + FfiConverterTypeAssetFreezeTransactionFields.write(value, buf) + } + } +} + +/** + * @suppress + */ +public object FfiConverterOptionalTypeAssetTransferTransactionFields : FfiConverterRustBuffer { + override fun read(buf: ByteBuffer): AssetTransferTransactionFields? { + if (buf.get().toInt() == 0) { + return null + } + return FfiConverterTypeAssetTransferTransactionFields.read(buf) + } + + override fun allocationSize(value: AssetTransferTransactionFields?): ULong { + if (value == null) { + return 1UL + } else { + return 1UL + FfiConverterTypeAssetTransferTransactionFields.allocationSize(value) + } + } + + override fun write( + value: AssetTransferTransactionFields?, + buf: ByteBuffer, + ) { + if (value == null) { + buf.put(0) + } else { + buf.put(1) + FfiConverterTypeAssetTransferTransactionFields.write(value, buf) + } + } +} + +/** + * @suppress + */ +public object FfiConverterOptionalTypeKeyRegistrationTransactionFields : FfiConverterRustBuffer { + override fun read(buf: ByteBuffer): KeyRegistrationTransactionFields? { + if (buf.get().toInt() == 0) { + return null + } + return FfiConverterTypeKeyRegistrationTransactionFields.read(buf) + } + + override fun allocationSize(value: KeyRegistrationTransactionFields?): ULong { + if (value == null) { + return 1UL + } else { + return 1UL + FfiConverterTypeKeyRegistrationTransactionFields.allocationSize(value) + } + } + + override fun write( + value: KeyRegistrationTransactionFields?, + buf: ByteBuffer, + ) { + if (value == null) { + buf.put(0) + } else { + buf.put(1) + FfiConverterTypeKeyRegistrationTransactionFields.write(value, buf) + } + } +} + +/** + * @suppress + */ +public object FfiConverterOptionalTypeMultisigSignature : FfiConverterRustBuffer { + override fun read(buf: ByteBuffer): MultisigSignature? { + if (buf.get().toInt() == 0) { + return null + } + return FfiConverterTypeMultisigSignature.read(buf) + } + + override fun allocationSize(value: MultisigSignature?): ULong { + if (value == null) { + return 1UL + } else { + return 1UL + FfiConverterTypeMultisigSignature.allocationSize(value) + } + } + + override fun write( + value: MultisigSignature?, + buf: ByteBuffer, + ) { + if (value == null) { + buf.put(0) + } else { + buf.put(1) + FfiConverterTypeMultisigSignature.write(value, buf) + } + } +} + +/** + * @suppress + */ +public object FfiConverterOptionalTypePaymentTransactionFields : FfiConverterRustBuffer { + override fun read(buf: ByteBuffer): PaymentTransactionFields? { + if (buf.get().toInt() == 0) { + return null + } + return FfiConverterTypePaymentTransactionFields.read(buf) + } + + override fun allocationSize(value: PaymentTransactionFields?): ULong { + if (value == null) { + return 1UL + } else { + return 1UL + FfiConverterTypePaymentTransactionFields.allocationSize(value) + } + } + + override fun write( + value: PaymentTransactionFields?, + buf: ByteBuffer, + ) { + if (value == null) { + buf.put(0) + } else { + buf.put(1) + FfiConverterTypePaymentTransactionFields.write(value, buf) + } + } +} + +/** + * @suppress + */ +public object FfiConverterOptionalTypeStateSchema : FfiConverterRustBuffer { + override fun read(buf: ByteBuffer): StateSchema? { + if (buf.get().toInt() == 0) { + return null + } + return FfiConverterTypeStateSchema.read(buf) + } + + override fun allocationSize(value: StateSchema?): ULong { + if (value == null) { + return 1UL + } else { + return 1UL + FfiConverterTypeStateSchema.allocationSize(value) + } + } + + override fun write( + value: StateSchema?, + buf: ByteBuffer, + ) { + if (value == null) { + buf.put(0) + } else { + buf.put(1) + FfiConverterTypeStateSchema.write(value, buf) + } + } +} + +/** + * @suppress + */ +public object FfiConverterOptionalSequenceULong : FfiConverterRustBuffer?> { + override fun read(buf: ByteBuffer): List? { + if (buf.get().toInt() == 0) { + return null + } + return FfiConverterSequenceULong.read(buf) + } + + override fun allocationSize(value: List?): ULong { + if (value == null) { + return 1UL + } else { + return 1UL + FfiConverterSequenceULong.allocationSize(value) + } + } + + override fun write( + value: List?, + buf: ByteBuffer, + ) { + if (value == null) { + buf.put(0) + } else { + buf.put(1) + FfiConverterSequenceULong.write(value, buf) + } + } +} + +/** + * @suppress + */ +public object FfiConverterOptionalSequenceString : FfiConverterRustBuffer?> { + override fun read(buf: ByteBuffer): List? { + if (buf.get().toInt() == 0) { + return null + } + return FfiConverterSequenceString.read(buf) + } + + override fun allocationSize(value: List?): ULong { + if (value == null) { + return 1UL + } else { + return 1UL + FfiConverterSequenceString.allocationSize(value) + } + } + + override fun write( + value: List?, + buf: ByteBuffer, + ) { + if (value == null) { + buf.put(0) + } else { + buf.put(1) + FfiConverterSequenceString.write(value, buf) + } + } +} + +/** + * @suppress + */ +public object FfiConverterOptionalSequenceByteArray : FfiConverterRustBuffer?> { + override fun read(buf: ByteBuffer): List? { + if (buf.get().toInt() == 0) { + return null + } + return FfiConverterSequenceByteArray.read(buf) + } + + override fun allocationSize(value: List?): ULong { + if (value == null) { + return 1UL + } else { + return 1UL + FfiConverterSequenceByteArray.allocationSize(value) + } + } + + override fun write( + value: List?, + buf: ByteBuffer, + ) { + if (value == null) { + buf.put(0) + } else { + buf.put(1) + FfiConverterSequenceByteArray.write(value, buf) + } + } +} + +/** + * @suppress + */ +public object FfiConverterOptionalSequenceTypeBoxReference : FfiConverterRustBuffer?> { + override fun read(buf: ByteBuffer): List? { + if (buf.get().toInt() == 0) { + return null + } + return FfiConverterSequenceTypeBoxReference.read(buf) + } + + override fun allocationSize(value: List?): ULong { + if (value == null) { + return 1UL + } else { + return 1UL + FfiConverterSequenceTypeBoxReference.allocationSize(value) + } + } + + override fun write( + value: List?, + buf: ByteBuffer, + ) { + if (value == null) { + buf.put(0) + } else { + buf.put(1) + FfiConverterSequenceTypeBoxReference.write(value, buf) + } + } +} + +/** + * @suppress + */ +public object FfiConverterSequenceULong : FfiConverterRustBuffer> { + override fun read(buf: ByteBuffer): List { + val len = buf.getInt() + return List(len) { + FfiConverterULong.read(buf) + } + } + + override fun allocationSize(value: List): ULong { + val sizeForLength = 4UL + val sizeForItems = value.map { FfiConverterULong.allocationSize(it) }.sum() + return sizeForLength + sizeForItems + } + + override fun write( + value: List, + buf: ByteBuffer, + ) { + buf.putInt(value.size) + value.iterator().forEach { + FfiConverterULong.write(it, buf) + } + } +} + +/** + * @suppress + */ +public object FfiConverterSequenceString : FfiConverterRustBuffer> { + override fun read(buf: ByteBuffer): List { + val len = buf.getInt() + return List(len) { + FfiConverterString.read(buf) + } + } + + override fun allocationSize(value: List): ULong { + val sizeForLength = 4UL + val sizeForItems = value.map { FfiConverterString.allocationSize(it) }.sum() + return sizeForLength + sizeForItems + } + + override fun write( + value: List, + buf: ByteBuffer, + ) { + buf.putInt(value.size) + value.iterator().forEach { + FfiConverterString.write(it, buf) + } + } +} + +/** + * @suppress + */ +public object FfiConverterSequenceByteArray : FfiConverterRustBuffer> { + override fun read(buf: ByteBuffer): List { + val len = buf.getInt() + return List(len) { + FfiConverterByteArray.read(buf) + } + } + + override fun allocationSize(value: List): ULong { + val sizeForLength = 4UL + val sizeForItems = value.map { FfiConverterByteArray.allocationSize(it) }.sum() + return sizeForLength + sizeForItems + } + + override fun write( + value: List, + buf: ByteBuffer, + ) { + buf.putInt(value.size) + value.iterator().forEach { + FfiConverterByteArray.write(it, buf) + } + } +} + +/** + * @suppress + */ +public object FfiConverterSequenceTypeBoxReference : FfiConverterRustBuffer> { + override fun read(buf: ByteBuffer): List { + val len = buf.getInt() + return List(len) { + FfiConverterTypeBoxReference.read(buf) + } + } + + override fun allocationSize(value: List): ULong { + val sizeForLength = 4UL + val sizeForItems = value.map { FfiConverterTypeBoxReference.allocationSize(it) }.sum() + return sizeForLength + sizeForItems + } + + override fun write( + value: List, + buf: ByteBuffer, + ) { + buf.putInt(value.size) + value.iterator().forEach { + FfiConverterTypeBoxReference.write(it, buf) + } + } +} + +/** + * @suppress + */ +public object FfiConverterSequenceTypeMultisigSubsignature : FfiConverterRustBuffer> { + override fun read(buf: ByteBuffer): List { + val len = buf.getInt() + return List(len) { + FfiConverterTypeMultisigSubsignature.read(buf) + } + } + + override fun allocationSize(value: List): ULong { + val sizeForLength = 4UL + val sizeForItems = value.map { FfiConverterTypeMultisigSubsignature.allocationSize(it) }.sum() + return sizeForLength + sizeForItems + } + + override fun write( + value: List, + buf: ByteBuffer, + ) { + buf.putInt(value.size) + value.iterator().forEach { + FfiConverterTypeMultisigSubsignature.write(it, buf) + } + } +} + +/** + * @suppress + */ +public object FfiConverterSequenceTypeSignedTransaction : FfiConverterRustBuffer> { + override fun read(buf: ByteBuffer): List { + val len = buf.getInt() + return List(len) { + FfiConverterTypeSignedTransaction.read(buf) + } + } + + override fun allocationSize(value: List): ULong { + val sizeForLength = 4UL + val sizeForItems = value.map { FfiConverterTypeSignedTransaction.allocationSize(it) }.sum() + return sizeForLength + sizeForItems + } + + override fun write( + value: List, + buf: ByteBuffer, + ) { + buf.putInt(value.size) + value.iterator().forEach { + FfiConverterTypeSignedTransaction.write(it, buf) + } + } +} + +/** + * @suppress + */ +public object FfiConverterSequenceTypeTransaction : FfiConverterRustBuffer> { + override fun read(buf: ByteBuffer): List { + val len = buf.getInt() + return List(len) { + FfiConverterTypeTransaction.read(buf) + } + } + + override fun allocationSize(value: List): ULong { + val sizeForLength = 4UL + val sizeForItems = value.map { FfiConverterTypeTransaction.allocationSize(it) }.sum() + return sizeForLength + sizeForItems + } + + override fun write( + value: List, + buf: ByteBuffer, + ) { + buf.putInt(value.size) + value.iterator().forEach { + FfiConverterTypeTransaction.write(it, buf) + } + } +} + +/** + * Returns the address of the multisignature account. + * + * # Errors + * /// Returns [`AlgoKitTransactError`] if the multisignature signature is invalid or the address cannot be derived. + */ +@Throws(AlgoKitTransactException::class) +fun `addressFromMultisigSignature`(`multisigSignature`: MultisigSignature): kotlin.String = + FfiConverterString.lift( + uniffiRustCallWithError(AlgoKitTransactException) { _status -> + UniffiLib.INSTANCE.uniffi_algokit_transact_ffi_fn_func_address_from_multisig_signature( + FfiConverterTypeMultisigSignature.lower(`multisigSignature`), + _status, + ) + }, + ) + +@Throws(AlgoKitTransactException::class) +fun `addressFromPublicKey`(`publicKey`: kotlin.ByteArray): String = + FfiConverterString.lift( + uniffiRustCallWithError(AlgoKitTransactException) { _status -> + UniffiLib.INSTANCE.uniffi_algokit_transact_ffi_fn_func_address_from_public_key( + FfiConverterByteArray.lower(`publicKey`), + _status, + ) + }, + ) + +/** + * Applies a subsignature for a participant to a multisignature signature, replacing any existing signature. + * + * # Errors + * + * Returns [`AlgoKitTransactError`] if the participant address is invalid or not found, or if the signature bytes are invalid. + */ +@Throws(AlgoKitTransactException::class) +fun `applyMultisigSubsignature`( + `multisigSignature`: MultisigSignature, + `participant`: kotlin.String, + `subsignature`: kotlin.ByteArray, +): MultisigSignature = + FfiConverterTypeMultisigSignature.lift( + uniffiRustCallWithError(AlgoKitTransactException) { _status -> + UniffiLib.INSTANCE.uniffi_algokit_transact_ffi_fn_func_apply_multisig_subsignature( + FfiConverterTypeMultisigSignature.lower(`multisigSignature`), + FfiConverterString.lower(`participant`), + FfiConverterByteArray.lower(`subsignature`), + _status, + ) + }, + ) + +@Throws(AlgoKitTransactException::class) +fun `assignFee`( + `transaction`: Transaction, + `feeParams`: FeeParams, +): Transaction = + FfiConverterTypeTransaction.lift( + uniffiRustCallWithError(AlgoKitTransactException) { _status -> + UniffiLib.INSTANCE.uniffi_algokit_transact_ffi_fn_func_assign_fee( + FfiConverterTypeTransaction.lower(`transaction`), + FfiConverterTypeFeeParams.lower(`feeParams`), + _status, + ) + }, + ) + +@Throws(AlgoKitTransactException::class) +fun `calculateFee`( + `transaction`: Transaction, + `feeParams`: FeeParams, +): kotlin.ULong = + FfiConverterULong.lift( + uniffiRustCallWithError(AlgoKitTransactException) { _status -> + UniffiLib.INSTANCE.uniffi_algokit_transact_ffi_fn_func_calculate_fee( + FfiConverterTypeTransaction.lower(`transaction`), + FfiConverterTypeFeeParams.lower(`feeParams`), + _status, + ) + }, + ) + +/** + * Decodes a signed transaction. + * + * # Parameters + * * `encoded_signed_transaction` - The MsgPack encoded signed transaction bytes + * + * # Returns + * The decoded SignedTransaction or an error if decoding fails. + */ +@Throws(AlgoKitTransactException::class) +fun `decodeSignedTransaction`(`encodedSignedTransaction`: kotlin.ByteArray): SignedTransaction = + FfiConverterTypeSignedTransaction.lift( + uniffiRustCallWithError(AlgoKitTransactException) { _status -> + UniffiLib.INSTANCE.uniffi_algokit_transact_ffi_fn_func_decode_signed_transaction( + FfiConverterByteArray.lower(`encodedSignedTransaction`), + _status, + ) + }, + ) + +/** + * Decodes a collection of MsgPack bytes into a signed transaction collection. + * + * # Parameters + * * `encoded_signed_transactions` - A collection of MsgPack encoded bytes, each representing a signed transaction. + * + * # Returns + * A collection of decoded signed transactions or an error if decoding fails. + */ +@Throws(AlgoKitTransactException::class) +fun `decodeSignedTransactions`(`encodedSignedTransactions`: List): List = + FfiConverterSequenceTypeSignedTransaction.lift( + uniffiRustCallWithError(AlgoKitTransactException) { _status -> + UniffiLib.INSTANCE.uniffi_algokit_transact_ffi_fn_func_decode_signed_transactions( + FfiConverterSequenceByteArray.lower(`encodedSignedTransactions`), + _status, + ) + }, + ) + +/** + * Decodes MsgPack bytes into a transaction. + * + * # Parameters + * * `encoded_tx` - MsgPack encoded bytes representing a transaction. + * + * # Returns + * A decoded transaction or an error if decoding fails. + */ +@Throws(AlgoKitTransactException::class) +fun `decodeTransaction`(`encodedTx`: kotlin.ByteArray): Transaction = + FfiConverterTypeTransaction.lift( + uniffiRustCallWithError(AlgoKitTransactException) { _status -> + UniffiLib.INSTANCE.uniffi_algokit_transact_ffi_fn_func_decode_transaction( + FfiConverterByteArray.lower(`encodedTx`), + _status, + ) + }, + ) + +/** + * Decodes a collection of MsgPack bytes into a transaction collection. + * + * # Parameters + * * `encoded_txs` - A collection of MsgPack encoded bytes, each representing a transaction. + * + * # Returns + * A collection of decoded transactions or an error if decoding fails. + */ +@Throws(AlgoKitTransactException::class) +fun `decodeTransactions`(`encodedTxs`: List): List = + FfiConverterSequenceTypeTransaction.lift( + uniffiRustCallWithError(AlgoKitTransactException) { _status -> + UniffiLib.INSTANCE.uniffi_algokit_transact_ffi_fn_func_decode_transactions( + FfiConverterSequenceByteArray.lower(`encodedTxs`), + _status, + ) + }, + ) + +/** + * Encode a signed transaction to MsgPack for sending on the network. + * + * This method performs canonical encoding. No domain separation prefix is applicable. + * + * # Parameters + * * `signed_transaction` - The signed transaction to encode + * + * # Returns + * The MsgPack encoded bytes or an error if encoding fails. + */ +@Throws(AlgoKitTransactException::class) +fun `encodeSignedTransaction`(`signedTransaction`: SignedTransaction): kotlin.ByteArray = + FfiConverterByteArray.lift( + uniffiRustCallWithError(AlgoKitTransactException) { _status -> + UniffiLib.INSTANCE.uniffi_algokit_transact_ffi_fn_func_encode_signed_transaction( + FfiConverterTypeSignedTransaction.lower(`signedTransaction`), + _status, + ) + }, + ) + +/** + * Encode signed transactions to MsgPack for sending on the network. + * + * This method performs canonical encoding. No domain separation prefix is applicable. + * + * # Parameters + * * `signed_transactions` - A collection of signed transactions to encode + * + * # Returns + * A collection of MsgPack encoded bytes or an error if encoding fails. + */ +@Throws(AlgoKitTransactException::class) +fun `encodeSignedTransactions`(`signedTransactions`: List): List = + FfiConverterSequenceByteArray.lift( + uniffiRustCallWithError(AlgoKitTransactException) { _status -> + UniffiLib.INSTANCE.uniffi_algokit_transact_ffi_fn_func_encode_signed_transactions( + FfiConverterSequenceTypeSignedTransaction.lower(`signedTransactions`), + _status, + ) + }, + ) + +/** + * Encode the transaction with the domain separation (e.g. "TX") prefix + */ +@Throws(AlgoKitTransactException::class) +fun `encodeTransaction`(`transaction`: Transaction): kotlin.ByteArray = + FfiConverterByteArray.lift( + uniffiRustCallWithError(AlgoKitTransactException) { _status -> + UniffiLib.INSTANCE.uniffi_algokit_transact_ffi_fn_func_encode_transaction( + FfiConverterTypeTransaction.lower(`transaction`), + _status, + ) + }, + ) + +/** + * Encode the transaction without the domain separation (e.g. "TX") prefix + * This is useful for encoding the transaction for signing with tools that automatically add "TX" prefix to the transaction bytes. + */ +@Throws(AlgoKitTransactException::class) +fun `encodeTransactionRaw`(`transaction`: Transaction): kotlin.ByteArray = + FfiConverterByteArray.lift( + uniffiRustCallWithError(AlgoKitTransactException) { _status -> + UniffiLib.INSTANCE.uniffi_algokit_transact_ffi_fn_func_encode_transaction_raw( + FfiConverterTypeTransaction.lower(`transaction`), + _status, + ) + }, + ) + +/** + * Encode transactions to MsgPack with the domain separation (e.g. "TX") prefix. + * + * # Parameters + * * `transactions` - A collection of transactions to encode + * + * # Returns + * A collection of MsgPack encoded bytes or an error if encoding fails. + */ +@Throws(AlgoKitTransactException::class) +fun `encodeTransactions`(`transactions`: List): List = + FfiConverterSequenceByteArray.lift( + uniffiRustCallWithError(AlgoKitTransactException) { _status -> + UniffiLib.INSTANCE.uniffi_algokit_transact_ffi_fn_func_encode_transactions( + FfiConverterSequenceTypeTransaction.lower(`transactions`), + _status, + ) + }, + ) + +/** + * Return the size of the transaction in bytes as if it was already signed and encoded. + * This is useful for estimating the fee for the transaction. + */ +@Throws(AlgoKitTransactException::class) +fun `estimateTransactionSize`(`transaction`: Transaction): kotlin.ULong = + FfiConverterULong.lift( + uniffiRustCallWithError(AlgoKitTransactException) { _status -> + UniffiLib.INSTANCE.uniffi_algokit_transact_ffi_fn_func_estimate_transaction_size( + FfiConverterTypeTransaction.lower(`transaction`), + _status, + ) + }, + ) + +fun `getAlgorandConstant`(`constant`: AlgorandConstant): kotlin.ULong = + FfiConverterULong.lift( + uniffiRustCall { _status -> + UniffiLib.INSTANCE.uniffi_algokit_transact_ffi_fn_func_get_algorand_constant( + FfiConverterTypeAlgorandConstant.lower(`constant`), + _status, + ) + }, + ) + +/** + * Get the transaction type from the encoded transaction. + * This is particularly useful when decoding a transaction that has an unknown type + */ +@Throws(AlgoKitTransactException::class) +fun `getEncodedTransactionType`(`encodedTransaction`: kotlin.ByteArray): TransactionType = + FfiConverterTypeTransactionType.lift( + uniffiRustCallWithError(AlgoKitTransactException) { _status -> + UniffiLib.INSTANCE.uniffi_algokit_transact_ffi_fn_func_get_encoded_transaction_type( + FfiConverterByteArray.lower(`encodedTransaction`), + _status, + ) + }, + ) + +/** + * Get the base32 transaction ID string for a transaction. + */ +@Throws(AlgoKitTransactException::class) +fun `getTransactionId`(`transaction`: Transaction): kotlin.String = + FfiConverterString.lift( + uniffiRustCallWithError(AlgoKitTransactException) { _status -> + UniffiLib.INSTANCE.uniffi_algokit_transact_ffi_fn_func_get_transaction_id( + FfiConverterTypeTransaction.lower(`transaction`), + _status, + ) + }, + ) + +/** + * Get the raw 32-byte transaction ID for a transaction. + */ +@Throws(AlgoKitTransactException::class) +fun `getTransactionIdRaw`(`transaction`: Transaction): kotlin.ByteArray = + FfiConverterByteArray.lift( + uniffiRustCallWithError(AlgoKitTransactException) { _status -> + UniffiLib.INSTANCE.uniffi_algokit_transact_ffi_fn_func_get_transaction_id_raw( + FfiConverterTypeTransaction.lower(`transaction`), + _status, + ) + }, + ) + +/** + * Groups a collection of transactions by calculating and assigning the group to each transaction. + */ +@Throws(AlgoKitTransactException::class) +fun `groupTransactions`(`transactions`: List): List = + FfiConverterSequenceTypeTransaction.lift( + uniffiRustCallWithError(AlgoKitTransactException) { _status -> + UniffiLib.INSTANCE.uniffi_algokit_transact_ffi_fn_func_group_transactions( + FfiConverterSequenceTypeTransaction.lower(`transactions`), + _status, + ) + }, + ) + +/** + * Merges two multisignature signatures, replacing signatures in the first with those from the second where present. + * + * # Errors + * + * Returns [`AlgoKitTransactError`] if the multisignature parameters or participants do not match. + */ +@Throws(AlgoKitTransactException::class) +fun `mergeMultisignatures`( + `multisigSignatureA`: MultisigSignature, + `multisigSignatureB`: MultisigSignature, +): MultisigSignature = + FfiConverterTypeMultisigSignature.lift( + uniffiRustCallWithError(AlgoKitTransactException) { _status -> + UniffiLib.INSTANCE.uniffi_algokit_transact_ffi_fn_func_merge_multisignatures( + FfiConverterTypeMultisigSignature.lower(`multisigSignatureA`), + FfiConverterTypeMultisigSignature.lower(`multisigSignatureB`), + _status, + ) + }, + ) + +/** + * Creates an empty multisignature signature from a list of participant addresses. + * + * # Errors + * + * Returns [`AlgoKitTransactError`] if any address is invalid or the multisignature parameters are invalid. + */ +@Throws(AlgoKitTransactException::class) +fun `newMultisigSignature`( + `version`: kotlin.UByte, + `threshold`: kotlin.UByte, + `participants`: List, +): MultisigSignature = + FfiConverterTypeMultisigSignature.lift( + uniffiRustCallWithError(AlgoKitTransactException) { _status -> + UniffiLib.INSTANCE.uniffi_algokit_transact_ffi_fn_func_new_multisig_signature( + FfiConverterUByte.lower(`version`), + FfiConverterUByte.lower(`threshold`), + FfiConverterSequenceString.lower(`participants`), + _status, + ) + }, + ) + +/** + * Returns the list of participant addresses from a multisignature signature. + * + * # Errors + * Returns [`AlgoKitTransactError`] if the multisignature is invalid. + */ +@Throws(AlgoKitTransactException::class) +fun `participantsFromMultisigSignature`(`multisigSignature`: MultisigSignature): List = + FfiConverterSequenceString.lift( + uniffiRustCallWithError(AlgoKitTransactException) { _status -> + UniffiLib.INSTANCE.uniffi_algokit_transact_ffi_fn_func_participants_from_multisig_signature( + FfiConverterTypeMultisigSignature.lower(`multisigSignature`), + _status, + ) + }, + ) + +@Throws(AlgoKitTransactException::class) +fun `publicKeyFromAddress`(`address`: kotlin.String): kotlin.ByteArray = + FfiConverterByteArray.lift( + uniffiRustCallWithError(AlgoKitTransactException) { _status -> + UniffiLib.INSTANCE.uniffi_algokit_transact_ffi_fn_func_public_key_from_address( + FfiConverterString.lower(`address`), + _status, + ) + }, + ) diff --git a/packages/android/algokit_transact/transact/src/test/kotlin/com/example/transact/ExampleUnitTest.kt b/packages/android/algokit_transact/transact/src/test/kotlin/com/example/transact/ExampleUnitTest.kt new file mode 100644 index 000000000..03a82e68d --- /dev/null +++ b/packages/android/algokit_transact/transact/src/test/kotlin/com/example/transact/ExampleUnitTest.kt @@ -0,0 +1,17 @@ +package com.example.transact + +import org.junit.Test + +import org.junit.Assert.* + +/** + * Example local unit test, which will execute on the development machine (host). + * + * See [testing documentation](http://d.android.com/tools/testing). + */ +class ExampleUnitTest { + @Test + fun addition_isCorrect() { + assertEquals(4, 2 + 2) + } +} \ No newline at end of file diff --git a/packages/swift/AlgoKitTransact/Frameworks/algokit_transact.xcframework/Info.plist b/packages/swift/AlgoKitTransact/Frameworks/algokit_transact.xcframework/Info.plist index 40164b8fe..baa085171 100644 --- a/packages/swift/AlgoKitTransact/Frameworks/algokit_transact.xcframework/Info.plist +++ b/packages/swift/AlgoKitTransact/Frameworks/algokit_transact.xcframework/Info.plist @@ -6,55 +6,55 @@ BinaryPath - libalgokit_transact_ffi.a + libalgokit_transact_ffi-macos.a HeadersPath Headers LibraryIdentifier - ios-arm64 + macos-arm64_x86_64 LibraryPath - libalgokit_transact_ffi.a + libalgokit_transact_ffi-macos.a SupportedArchitectures arm64 + x86_64 SupportedPlatform - ios + macos BinaryPath - libalgokit_transact_ffi-macos.a + libalgokit_transact_ffi-catalyst.a HeadersPath Headers LibraryIdentifier - macos-arm64_x86_64 + ios-arm64_x86_64-maccatalyst LibraryPath - libalgokit_transact_ffi-macos.a + libalgokit_transact_ffi-catalyst.a SupportedArchitectures arm64 x86_64 SupportedPlatform - macos + ios + SupportedPlatformVariant + maccatalyst BinaryPath - libalgokit_transact_ffi-catalyst.a + libalgokit_transact_ffi.a HeadersPath Headers LibraryIdentifier - ios-arm64_x86_64-maccatalyst + ios-arm64 LibraryPath - libalgokit_transact_ffi-catalyst.a + libalgokit_transact_ffi.a SupportedArchitectures arm64 - x86_64 SupportedPlatform ios - SupportedPlatformVariant - maccatalyst BinaryPath diff --git a/packages/swift/AlgoKitTransact/Frameworks/algokit_transact.xcframework/ios-arm64/Headers/algokit_transact.swift b/packages/swift/AlgoKitTransact/Frameworks/algokit_transact.xcframework/ios-arm64/Headers/algokit_transact.swift index 8fe29c207..92e86dfc8 100644 --- a/packages/swift/AlgoKitTransact/Frameworks/algokit_transact.xcframework/ios-arm64/Headers/algokit_transact.swift +++ b/packages/swift/AlgoKitTransact/Frameworks/algokit_transact.xcframework/ios-arm64/Headers/algokit_transact.swift @@ -281,7 +281,7 @@ private func makeRustCall( _ callback: (UnsafeMutablePointer) -> T, errorHandler: ((RustBuffer) throws -> E)? ) throws -> T { - uniffiEnsureInitialized() + uniffiEnsureAlgokitTransactFfiInitialized() var callStatus = RustCallStatus.init() let returnedVal = callback(&callStatus) try uniffiCheckCallStatus(callStatus: callStatus, errorHandler: errorHandler) @@ -352,9 +352,10 @@ private func uniffiTraitInterfaceCallWithError( callStatus.pointee.errorBuf = FfiConverterString.lower(String(describing: error)) } } -fileprivate class UniffiHandleMap { - private var map: [UInt64: T] = [:] +fileprivate final class UniffiHandleMap: @unchecked Sendable { + // All mutation happens with this lock held, which is why we implement @unchecked Sendable. private let lock = NSLock() + private var map: [UInt64: T] = [:] private var currentHandle: UInt64 = 1 func insert(obj: T) -> UInt64 { @@ -396,6 +397,38 @@ fileprivate class UniffiHandleMap { // Public interface members begin here. +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +fileprivate struct FfiConverterUInt8: FfiConverterPrimitive { + typealias FfiType = UInt8 + typealias SwiftType = UInt8 + + public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> UInt8 { + return try lift(readInt(&buf)) + } + + public static func write(_ value: UInt8, into buf: inout [UInt8]) { + writeInt(&buf, lower(value)) + } +} + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +fileprivate struct FfiConverterUInt32: FfiConverterPrimitive { + typealias FfiType = UInt32 + typealias SwiftType = UInt32 + + public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> UInt32 { + return try lift(readInt(&buf)) + } + + public static func write(_ value: SwiftType, into buf: inout [UInt8]) { + writeInt(&buf, lower(value)) + } +} + #if swift(>=5.8) @_documentation(visibility: private) #endif @@ -412,6 +445,30 @@ fileprivate struct FfiConverterUInt64: FfiConverterPrimitive { } } +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +fileprivate struct FfiConverterBool : FfiConverter { + typealias FfiType = Int8 + typealias SwiftType = Bool + + public static func lift(_ value: Int8) throws -> Bool { + return value != 0 + } + + public static func lower(_ value: Bool) -> Int8 { + return value ? 1 : 0 + } + + public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> Bool { + return try lift(readInt(&buf)) + } + + public static func write(_ value: Bool, into buf: inout [UInt8]) { + writeInt(&buf, lower(value)) + } +} + #if swift(>=5.8) @_documentation(visibility: private) #endif @@ -472,53 +529,269 @@ fileprivate struct FfiConverterData: FfiConverterRustBuffer { } -public struct Address { - public var address: String - public var pubKey: ByteBuf +/** + * Represents an app call transaction that interacts with Algorand Smart Contracts. + * + * App call transactions are used to create, update, delete, opt-in to, + * close out of, or clear state from Algorand applications (smart contracts). + */ +public struct AppCallTransactionFields { + /** + * ID of the app being called. + * + * Set this to 0 to indicate an app creation call. + */ + public var appId: UInt64 + /** + * Defines what additional actions occur with the transaction. + */ + public var onComplete: OnApplicationComplete + /** + * Logic executed for every app call transaction, except when + * on-completion is set to "clear". + * + * Approval programs may reject the transaction. + * Only required for app creation and update transactions. + */ + public var approvalProgram: Data? + /** + * Logic executed for app call transactions with on-completion set to "clear". + * + * Clear state programs cannot reject the transaction. + * Only required for app creation and update transactions. + */ + public var clearStateProgram: Data? + /** + * Holds the maximum number of global state values. + * + * Only required for app creation transactions. + * This cannot be changed after creation. + */ + public var globalStateSchema: StateSchema? + /** + * Holds the maximum number of local state values. + * + * Only required for app creation transactions. + * This cannot be changed after creation. + */ + public var localStateSchema: StateSchema? + /** + * Number of additional pages allocated to the app's approval + * and clear state programs. + * + * Each extra program page is 2048 bytes. The sum of approval program + * and clear state program may not exceed 2048*(1+extra_program_pages) bytes. + * Currently, the maximum value is 3. + * This cannot be changed after creation. + */ + public var extraProgramPages: UInt32? + /** + * Transaction specific arguments available in the app's + * approval program and clear state program. + */ + public var args: [Data]? + /** + * List of accounts in addition to the sender that may be accessed + * from the app's approval program and clear state program. + */ + public var accountReferences: [String]? + /** + * List of apps in addition to the current app that may be called + * from the app's approval program and clear state program. + */ + public var appReferences: [UInt64]? + /** + * Lists the assets whose parameters may be accessed by this app's + * approval program and clear state program. + * + * The access is read-only. + */ + public var assetReferences: [UInt64]? + /** + * The boxes that should be made available for the runtime of the program. + */ + public var boxReferences: [BoxReference]? // Default memberwise initializers are never public by default, so we // declare one manually. - public init(address: String, pubKey: ByteBuf) { - self.address = address - self.pubKey = pubKey - } -} - + public init( + /** + * ID of the app being called. + * + * Set this to 0 to indicate an app creation call. + */appId: UInt64, + /** + * Defines what additional actions occur with the transaction. + */onComplete: OnApplicationComplete, + /** + * Logic executed for every app call transaction, except when + * on-completion is set to "clear". + * + * Approval programs may reject the transaction. + * Only required for app creation and update transactions. + */approvalProgram: Data? = nil, + /** + * Logic executed for app call transactions with on-completion set to "clear". + * + * Clear state programs cannot reject the transaction. + * Only required for app creation and update transactions. + */clearStateProgram: Data? = nil, + /** + * Holds the maximum number of global state values. + * + * Only required for app creation transactions. + * This cannot be changed after creation. + */globalStateSchema: StateSchema? = nil, + /** + * Holds the maximum number of local state values. + * + * Only required for app creation transactions. + * This cannot be changed after creation. + */localStateSchema: StateSchema? = nil, + /** + * Number of additional pages allocated to the app's approval + * and clear state programs. + * + * Each extra program page is 2048 bytes. The sum of approval program + * and clear state program may not exceed 2048*(1+extra_program_pages) bytes. + * Currently, the maximum value is 3. + * This cannot be changed after creation. + */extraProgramPages: UInt32? = nil, + /** + * Transaction specific arguments available in the app's + * approval program and clear state program. + */args: [Data]? = nil, + /** + * List of accounts in addition to the sender that may be accessed + * from the app's approval program and clear state program. + */accountReferences: [String]? = nil, + /** + * List of apps in addition to the current app that may be called + * from the app's approval program and clear state program. + */appReferences: [UInt64]? = nil, + /** + * Lists the assets whose parameters may be accessed by this app's + * approval program and clear state program. + * + * The access is read-only. + */assetReferences: [UInt64]? = nil, + /** + * The boxes that should be made available for the runtime of the program. + */boxReferences: [BoxReference]? = nil) { + self.appId = appId + self.onComplete = onComplete + self.approvalProgram = approvalProgram + self.clearStateProgram = clearStateProgram + self.globalStateSchema = globalStateSchema + self.localStateSchema = localStateSchema + self.extraProgramPages = extraProgramPages + self.args = args + self.accountReferences = accountReferences + self.appReferences = appReferences + self.assetReferences = assetReferences + self.boxReferences = boxReferences + } +} + +#if compiler(>=6) +extension AppCallTransactionFields: Sendable {} +#endif -extension Address: Equatable, Hashable { - public static func ==(lhs: Address, rhs: Address) -> Bool { - if lhs.address != rhs.address { +extension AppCallTransactionFields: Equatable, Hashable { + public static func ==(lhs: AppCallTransactionFields, rhs: AppCallTransactionFields) -> Bool { + if lhs.appId != rhs.appId { return false } - if lhs.pubKey != rhs.pubKey { + if lhs.onComplete != rhs.onComplete { + return false + } + if lhs.approvalProgram != rhs.approvalProgram { + return false + } + if lhs.clearStateProgram != rhs.clearStateProgram { + return false + } + if lhs.globalStateSchema != rhs.globalStateSchema { + return false + } + if lhs.localStateSchema != rhs.localStateSchema { + return false + } + if lhs.extraProgramPages != rhs.extraProgramPages { + return false + } + if lhs.args != rhs.args { + return false + } + if lhs.accountReferences != rhs.accountReferences { + return false + } + if lhs.appReferences != rhs.appReferences { + return false + } + if lhs.assetReferences != rhs.assetReferences { + return false + } + if lhs.boxReferences != rhs.boxReferences { return false } return true } public func hash(into hasher: inout Hasher) { - hasher.combine(address) - hasher.combine(pubKey) + hasher.combine(appId) + hasher.combine(onComplete) + hasher.combine(approvalProgram) + hasher.combine(clearStateProgram) + hasher.combine(globalStateSchema) + hasher.combine(localStateSchema) + hasher.combine(extraProgramPages) + hasher.combine(args) + hasher.combine(accountReferences) + hasher.combine(appReferences) + hasher.combine(assetReferences) + hasher.combine(boxReferences) } } + #if swift(>=5.8) @_documentation(visibility: private) #endif -public struct FfiConverterTypeAddress: FfiConverterRustBuffer { - public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> Address { +public struct FfiConverterTypeAppCallTransactionFields: FfiConverterRustBuffer { + public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> AppCallTransactionFields { return - try Address( - address: FfiConverterString.read(from: &buf), - pubKey: FfiConverterTypeByteBuf.read(from: &buf) + try AppCallTransactionFields( + appId: FfiConverterUInt64.read(from: &buf), + onComplete: FfiConverterTypeOnApplicationComplete.read(from: &buf), + approvalProgram: FfiConverterOptionData.read(from: &buf), + clearStateProgram: FfiConverterOptionData.read(from: &buf), + globalStateSchema: FfiConverterOptionTypeStateSchema.read(from: &buf), + localStateSchema: FfiConverterOptionTypeStateSchema.read(from: &buf), + extraProgramPages: FfiConverterOptionUInt32.read(from: &buf), + args: FfiConverterOptionSequenceData.read(from: &buf), + accountReferences: FfiConverterOptionSequenceString.read(from: &buf), + appReferences: FfiConverterOptionSequenceUInt64.read(from: &buf), + assetReferences: FfiConverterOptionSequenceUInt64.read(from: &buf), + boxReferences: FfiConverterOptionSequenceTypeBoxReference.read(from: &buf) ) } - public static func write(_ value: Address, into buf: inout [UInt8]) { - FfiConverterString.write(value.address, into: &buf) - FfiConverterTypeByteBuf.write(value.pubKey, into: &buf) + public static func write(_ value: AppCallTransactionFields, into buf: inout [UInt8]) { + FfiConverterUInt64.write(value.appId, into: &buf) + FfiConverterTypeOnApplicationComplete.write(value.onComplete, into: &buf) + FfiConverterOptionData.write(value.approvalProgram, into: &buf) + FfiConverterOptionData.write(value.clearStateProgram, into: &buf) + FfiConverterOptionTypeStateSchema.write(value.globalStateSchema, into: &buf) + FfiConverterOptionTypeStateSchema.write(value.localStateSchema, into: &buf) + FfiConverterOptionUInt32.write(value.extraProgramPages, into: &buf) + FfiConverterOptionSequenceData.write(value.args, into: &buf) + FfiConverterOptionSequenceString.write(value.accountReferences, into: &buf) + FfiConverterOptionSequenceUInt64.write(value.appReferences, into: &buf) + FfiConverterOptionSequenceUInt64.write(value.assetReferences, into: &buf) + FfiConverterOptionSequenceTypeBoxReference.write(value.boxReferences, into: &buf) } } @@ -526,53 +799,306 @@ public struct FfiConverterTypeAddress: FfiConverterRustBuffer { #if swift(>=5.8) @_documentation(visibility: private) #endif -public func FfiConverterTypeAddress_lift(_ buf: RustBuffer) throws -> Address { - return try FfiConverterTypeAddress.lift(buf) +public func FfiConverterTypeAppCallTransactionFields_lift(_ buf: RustBuffer) throws -> AppCallTransactionFields { + return try FfiConverterTypeAppCallTransactionFields.lift(buf) } #if swift(>=5.8) @_documentation(visibility: private) #endif -public func FfiConverterTypeAddress_lower(_ value: Address) -> RustBuffer { - return FfiConverterTypeAddress.lower(value) +public func FfiConverterTypeAppCallTransactionFields_lower(_ value: AppCallTransactionFields) -> RustBuffer { + return FfiConverterTypeAppCallTransactionFields.lower(value) } -public struct AssetTransferTransactionFields { +/** + * Parameters to define an asset config transaction. + * + * For asset creation, the asset ID field must be 0. + * For asset reconfiguration, the asset ID field must be set. Only fields manager, reserve, freeze, and clawback can be set. + * For asset destroy, the asset ID field must be set, all other fields must not be set. + * + * **Note:** The manager, reserve, freeze, and clawback addresses + * are immutably empty if they are not set. If manager is not set then + * all fields are immutable from that point forward. + */ +public struct AssetConfigTransactionFields { + /** + * ID of the asset to operate on. + * + * For asset creation, this must be 0. + * For asset reconfiguration this is the ID of the existing asset to be reconfigured, + * For asset destroy this is the ID of the existing asset to be destroyed. + */ public var assetId: UInt64 - public var amount: UInt64 - public var receiver: Address - public var assetSender: Address? - public var closeRemainderTo: Address? + /** + * The total amount of the smallest divisible (decimal) unit to create. + * + * Required when creating a new asset. + * For example, if creating a asset with 2 decimals and wanting a total supply of 100 units, this value should be 10000. + * + * This field can only be specified upon asset creation. + */ + public var total: UInt64? + /** + * The amount of decimal places the asset should have. + * + * If unspecified then the asset will be in whole units (i.e. `0`). + * * If 0, the asset is not divisible; + * * If 1, the base unit of the asset is in tenths; + * * If 2, the base unit of the asset is in hundredths; + * * If 3, the base unit of the asset is in thousandths; + * + * and so on up to 19 decimal places. + * + * This field can only be specified upon asset creation. + */ + public var decimals: UInt32? + /** + * Whether the asset is frozen by default for all accounts. + * Defaults to `false`. + * + * If `true` then for anyone apart from the creator to hold the + * asset it needs to be unfrozen per account using an asset freeze + * transaction from the `freeze` account, which must be set on creation. + * + * This field can only be specified upon asset creation. + */ + public var defaultFrozen: Bool? + /** + * The optional name of the asset. + * + * Max size is 32 bytes. + * + * This field can only be specified upon asset creation. + */ + public var assetName: String? + /** + * The optional name of the unit of this asset (e.g. ticker name). + * + * Max size is 8 bytes. + * + * This field can only be specified upon asset creation. + */ + public var unitName: String? + /** + * Specifies an optional URL where more information about the asset can be retrieved (e.g. metadata). + * + * Max size is 96 bytes. + * + * This field can only be specified upon asset creation. + */ + public var url: String? + /** + * 32-byte hash of some metadata that is relevant to your asset and/or asset holders. + * + * The format of this metadata is up to the application. + * + * This field can only be specified upon asset creation. + */ + public var metadataHash: Data? + /** + * The address of the optional account that can manage the configuration of the asset and destroy it. + * + * The fields it can change are `manager`, `reserve`, `clawback`, and `freeze`. + * + * If not set or set to the Zero address the asset becomes permanently immutable. + */ + public var manager: String? + /** + * The address of the optional account that holds the reserve (uncirculated supply) units of the asset. + * + * This address has no specific authority in the protocol itself and is informational only. + * + * Some standards like [ARC-19](https://github.com/algorandfoundation/ARCs/blob/main/ARCs/arc-0019.md) + * rely on this field to hold meaningful data. + * + * It can be used in the case where you want to signal to holders of your asset that the uncirculated units + * of the asset reside in an account that is different from the default creator account. + * + * If not set or set to the Zero address is permanently empty. + */ + public var reserve: String? + /** + * The address of the optional account that can be used to freeze or unfreeze holdings of this asset for any account. + * + * If empty, freezing is not permitted. + * + * If not set or set to the Zero address is permanently empty. + */ + public var freeze: String? + /** + * The address of the optional account that can clawback holdings of this asset from any account. + * + * **This field should be used with caution** as the clawback account has the ability to **unconditionally take assets from any account**. + * + * If empty, clawback is not permitted. + * + * If not set or set to the Zero address is permanently empty. + */ + public var clawback: String? // Default memberwise initializers are never public by default, so we // declare one manually. - public init(assetId: UInt64, amount: UInt64, receiver: Address, assetSender: Address? = nil, closeRemainderTo: Address? = nil) { + public init( + /** + * ID of the asset to operate on. + * + * For asset creation, this must be 0. + * For asset reconfiguration this is the ID of the existing asset to be reconfigured, + * For asset destroy this is the ID of the existing asset to be destroyed. + */assetId: UInt64, + /** + * The total amount of the smallest divisible (decimal) unit to create. + * + * Required when creating a new asset. + * For example, if creating a asset with 2 decimals and wanting a total supply of 100 units, this value should be 10000. + * + * This field can only be specified upon asset creation. + */total: UInt64? = nil, + /** + * The amount of decimal places the asset should have. + * + * If unspecified then the asset will be in whole units (i.e. `0`). + * * If 0, the asset is not divisible; + * * If 1, the base unit of the asset is in tenths; + * * If 2, the base unit of the asset is in hundredths; + * * If 3, the base unit of the asset is in thousandths; + * + * and so on up to 19 decimal places. + * + * This field can only be specified upon asset creation. + */decimals: UInt32? = nil, + /** + * Whether the asset is frozen by default for all accounts. + * Defaults to `false`. + * + * If `true` then for anyone apart from the creator to hold the + * asset it needs to be unfrozen per account using an asset freeze + * transaction from the `freeze` account, which must be set on creation. + * + * This field can only be specified upon asset creation. + */defaultFrozen: Bool? = nil, + /** + * The optional name of the asset. + * + * Max size is 32 bytes. + * + * This field can only be specified upon asset creation. + */assetName: String? = nil, + /** + * The optional name of the unit of this asset (e.g. ticker name). + * + * Max size is 8 bytes. + * + * This field can only be specified upon asset creation. + */unitName: String? = nil, + /** + * Specifies an optional URL where more information about the asset can be retrieved (e.g. metadata). + * + * Max size is 96 bytes. + * + * This field can only be specified upon asset creation. + */url: String? = nil, + /** + * 32-byte hash of some metadata that is relevant to your asset and/or asset holders. + * + * The format of this metadata is up to the application. + * + * This field can only be specified upon asset creation. + */metadataHash: Data? = nil, + /** + * The address of the optional account that can manage the configuration of the asset and destroy it. + * + * The fields it can change are `manager`, `reserve`, `clawback`, and `freeze`. + * + * If not set or set to the Zero address the asset becomes permanently immutable. + */manager: String? = nil, + /** + * The address of the optional account that holds the reserve (uncirculated supply) units of the asset. + * + * This address has no specific authority in the protocol itself and is informational only. + * + * Some standards like [ARC-19](https://github.com/algorandfoundation/ARCs/blob/main/ARCs/arc-0019.md) + * rely on this field to hold meaningful data. + * + * It can be used in the case where you want to signal to holders of your asset that the uncirculated units + * of the asset reside in an account that is different from the default creator account. + * + * If not set or set to the Zero address is permanently empty. + */reserve: String? = nil, + /** + * The address of the optional account that can be used to freeze or unfreeze holdings of this asset for any account. + * + * If empty, freezing is not permitted. + * + * If not set or set to the Zero address is permanently empty. + */freeze: String? = nil, + /** + * The address of the optional account that can clawback holdings of this asset from any account. + * + * **This field should be used with caution** as the clawback account has the ability to **unconditionally take assets from any account**. + * + * If empty, clawback is not permitted. + * + * If not set or set to the Zero address is permanently empty. + */clawback: String? = nil) { self.assetId = assetId - self.amount = amount - self.receiver = receiver - self.assetSender = assetSender - self.closeRemainderTo = closeRemainderTo - } -} - + self.total = total + self.decimals = decimals + self.defaultFrozen = defaultFrozen + self.assetName = assetName + self.unitName = unitName + self.url = url + self.metadataHash = metadataHash + self.manager = manager + self.reserve = reserve + self.freeze = freeze + self.clawback = clawback + } +} + +#if compiler(>=6) +extension AssetConfigTransactionFields: Sendable {} +#endif -extension AssetTransferTransactionFields: Equatable, Hashable { - public static func ==(lhs: AssetTransferTransactionFields, rhs: AssetTransferTransactionFields) -> Bool { +extension AssetConfigTransactionFields: Equatable, Hashable { + public static func ==(lhs: AssetConfigTransactionFields, rhs: AssetConfigTransactionFields) -> Bool { if lhs.assetId != rhs.assetId { return false } - if lhs.amount != rhs.amount { + if lhs.total != rhs.total { return false } - if lhs.receiver != rhs.receiver { + if lhs.decimals != rhs.decimals { return false } - if lhs.assetSender != rhs.assetSender { + if lhs.defaultFrozen != rhs.defaultFrozen { return false } - if lhs.closeRemainderTo != rhs.closeRemainderTo { + if lhs.assetName != rhs.assetName { + return false + } + if lhs.unitName != rhs.unitName { + return false + } + if lhs.url != rhs.url { + return false + } + if lhs.metadataHash != rhs.metadataHash { + return false + } + if lhs.manager != rhs.manager { + return false + } + if lhs.reserve != rhs.reserve { + return false + } + if lhs.freeze != rhs.freeze { + return false + } + if lhs.clawback != rhs.clawback { return false } return true @@ -580,35 +1106,57 @@ extension AssetTransferTransactionFields: Equatable, Hashable { public func hash(into hasher: inout Hasher) { hasher.combine(assetId) - hasher.combine(amount) - hasher.combine(receiver) - hasher.combine(assetSender) - hasher.combine(closeRemainderTo) + hasher.combine(total) + hasher.combine(decimals) + hasher.combine(defaultFrozen) + hasher.combine(assetName) + hasher.combine(unitName) + hasher.combine(url) + hasher.combine(metadataHash) + hasher.combine(manager) + hasher.combine(reserve) + hasher.combine(freeze) + hasher.combine(clawback) } } + #if swift(>=5.8) @_documentation(visibility: private) #endif -public struct FfiConverterTypeAssetTransferTransactionFields: FfiConverterRustBuffer { - public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> AssetTransferTransactionFields { +public struct FfiConverterTypeAssetConfigTransactionFields: FfiConverterRustBuffer { + public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> AssetConfigTransactionFields { return - try AssetTransferTransactionFields( + try AssetConfigTransactionFields( assetId: FfiConverterUInt64.read(from: &buf), - amount: FfiConverterUInt64.read(from: &buf), - receiver: FfiConverterTypeAddress.read(from: &buf), - assetSender: FfiConverterOptionTypeAddress.read(from: &buf), - closeRemainderTo: FfiConverterOptionTypeAddress.read(from: &buf) + total: FfiConverterOptionUInt64.read(from: &buf), + decimals: FfiConverterOptionUInt32.read(from: &buf), + defaultFrozen: FfiConverterOptionBool.read(from: &buf), + assetName: FfiConverterOptionString.read(from: &buf), + unitName: FfiConverterOptionString.read(from: &buf), + url: FfiConverterOptionString.read(from: &buf), + metadataHash: FfiConverterOptionData.read(from: &buf), + manager: FfiConverterOptionString.read(from: &buf), + reserve: FfiConverterOptionString.read(from: &buf), + freeze: FfiConverterOptionString.read(from: &buf), + clawback: FfiConverterOptionString.read(from: &buf) ) } - public static func write(_ value: AssetTransferTransactionFields, into buf: inout [UInt8]) { + public static func write(_ value: AssetConfigTransactionFields, into buf: inout [UInt8]) { FfiConverterUInt64.write(value.assetId, into: &buf) - FfiConverterUInt64.write(value.amount, into: &buf) - FfiConverterTypeAddress.write(value.receiver, into: &buf) - FfiConverterOptionTypeAddress.write(value.assetSender, into: &buf) - FfiConverterOptionTypeAddress.write(value.closeRemainderTo, into: &buf) + FfiConverterOptionUInt64.write(value.total, into: &buf) + FfiConverterOptionUInt32.write(value.decimals, into: &buf) + FfiConverterOptionBool.write(value.defaultFrozen, into: &buf) + FfiConverterOptionString.write(value.assetName, into: &buf) + FfiConverterOptionString.write(value.unitName, into: &buf) + FfiConverterOptionString.write(value.url, into: &buf) + FfiConverterOptionData.write(value.metadataHash, into: &buf) + FfiConverterOptionString.write(value.manager, into: &buf) + FfiConverterOptionString.write(value.reserve, into: &buf) + FfiConverterOptionString.write(value.freeze, into: &buf) + FfiConverterOptionString.write(value.clawback, into: &buf) } } @@ -616,73 +1164,107 @@ public struct FfiConverterTypeAssetTransferTransactionFields: FfiConverterRustBu #if swift(>=5.8) @_documentation(visibility: private) #endif -public func FfiConverterTypeAssetTransferTransactionFields_lift(_ buf: RustBuffer) throws -> AssetTransferTransactionFields { - return try FfiConverterTypeAssetTransferTransactionFields.lift(buf) +public func FfiConverterTypeAssetConfigTransactionFields_lift(_ buf: RustBuffer) throws -> AssetConfigTransactionFields { + return try FfiConverterTypeAssetConfigTransactionFields.lift(buf) } #if swift(>=5.8) @_documentation(visibility: private) #endif -public func FfiConverterTypeAssetTransferTransactionFields_lower(_ value: AssetTransferTransactionFields) -> RustBuffer { - return FfiConverterTypeAssetTransferTransactionFields.lower(value) +public func FfiConverterTypeAssetConfigTransactionFields_lower(_ value: AssetConfigTransactionFields) -> RustBuffer { + return FfiConverterTypeAssetConfigTransactionFields.lower(value) } -public struct PaymentTransactionFields { - public var receiver: Address - public var amount: UInt64 - public var closeRemainderTo: Address? +/** + * Represents an asset freeze transaction that freezes or unfreezes asset holdings. + * + * Asset freeze transactions are used by the asset freeze account to control + * whether a specific account can transfer a particular asset. + */ +public struct AssetFreezeTransactionFields { + /** + * The ID of the asset being frozen/unfrozen. + */ + public var assetId: UInt64 + /** + * The target account whose asset holdings will be affected. + */ + public var freezeTarget: String + /** + * The new freeze status. + * + * `true` to freeze the asset holdings (prevent transfers), + * `false` to unfreeze the asset holdings (allow transfers). + */ + public var frozen: Bool // Default memberwise initializers are never public by default, so we // declare one manually. - public init(receiver: Address, amount: UInt64, closeRemainderTo: Address? = nil) { - self.receiver = receiver - self.amount = amount - self.closeRemainderTo = closeRemainderTo + public init( + /** + * The ID of the asset being frozen/unfrozen. + */assetId: UInt64, + /** + * The target account whose asset holdings will be affected. + */freezeTarget: String, + /** + * The new freeze status. + * + * `true` to freeze the asset holdings (prevent transfers), + * `false` to unfreeze the asset holdings (allow transfers). + */frozen: Bool) { + self.assetId = assetId + self.freezeTarget = freezeTarget + self.frozen = frozen } } +#if compiler(>=6) +extension AssetFreezeTransactionFields: Sendable {} +#endif -extension PaymentTransactionFields: Equatable, Hashable { - public static func ==(lhs: PaymentTransactionFields, rhs: PaymentTransactionFields) -> Bool { - if lhs.receiver != rhs.receiver { +extension AssetFreezeTransactionFields: Equatable, Hashable { + public static func ==(lhs: AssetFreezeTransactionFields, rhs: AssetFreezeTransactionFields) -> Bool { + if lhs.assetId != rhs.assetId { return false } - if lhs.amount != rhs.amount { + if lhs.freezeTarget != rhs.freezeTarget { return false } - if lhs.closeRemainderTo != rhs.closeRemainderTo { + if lhs.frozen != rhs.frozen { return false } return true } public func hash(into hasher: inout Hasher) { - hasher.combine(receiver) - hasher.combine(amount) - hasher.combine(closeRemainderTo) + hasher.combine(assetId) + hasher.combine(freezeTarget) + hasher.combine(frozen) } } + #if swift(>=5.8) @_documentation(visibility: private) #endif -public struct FfiConverterTypePaymentTransactionFields: FfiConverterRustBuffer { - public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> PaymentTransactionFields { +public struct FfiConverterTypeAssetFreezeTransactionFields: FfiConverterRustBuffer { + public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> AssetFreezeTransactionFields { return - try PaymentTransactionFields( - receiver: FfiConverterTypeAddress.read(from: &buf), - amount: FfiConverterUInt64.read(from: &buf), - closeRemainderTo: FfiConverterOptionTypeAddress.read(from: &buf) + try AssetFreezeTransactionFields( + assetId: FfiConverterUInt64.read(from: &buf), + freezeTarget: FfiConverterString.read(from: &buf), + frozen: FfiConverterBool.read(from: &buf) ) } - public static func write(_ value: PaymentTransactionFields, into buf: inout [UInt8]) { - FfiConverterTypeAddress.write(value.receiver, into: &buf) - FfiConverterUInt64.write(value.amount, into: &buf) - FfiConverterOptionTypeAddress.write(value.closeRemainderTo, into: &buf) + public static func write(_ value: AssetFreezeTransactionFields, into buf: inout [UInt8]) { + FfiConverterUInt64.write(value.assetId, into: &buf) + FfiConverterString.write(value.freezeTarget, into: &buf) + FfiConverterBool.write(value.frozen, into: &buf) } } @@ -690,38 +1272,993 @@ public struct FfiConverterTypePaymentTransactionFields: FfiConverterRustBuffer { #if swift(>=5.8) @_documentation(visibility: private) #endif -public func FfiConverterTypePaymentTransactionFields_lift(_ buf: RustBuffer) throws -> PaymentTransactionFields { - return try FfiConverterTypePaymentTransactionFields.lift(buf) +public func FfiConverterTypeAssetFreezeTransactionFields_lift(_ buf: RustBuffer) throws -> AssetFreezeTransactionFields { + return try FfiConverterTypeAssetFreezeTransactionFields.lift(buf) } #if swift(>=5.8) @_documentation(visibility: private) #endif -public func FfiConverterTypePaymentTransactionFields_lower(_ value: PaymentTransactionFields) -> RustBuffer { - return FfiConverterTypePaymentTransactionFields.lower(value) +public func FfiConverterTypeAssetFreezeTransactionFields_lower(_ value: AssetFreezeTransactionFields) -> RustBuffer { + return FfiConverterTypeAssetFreezeTransactionFields.lower(value) } -public struct Transaction { - /** - * The type of transaction - */ - public var transactionType: TransactionType - /** - * The sender of the transaction - */ - public var sender: Address - public var fee: UInt64 - public var firstValid: UInt64 - public var lastValid: UInt64 - public var genesisHash: ByteBuf? - public var genesisId: String? - public var note: ByteBuf? - public var rekeyTo: Address? - public var lease: ByteBuf? - public var group: ByteBuf? - public var payment: PaymentTransactionFields? - public var assetTransfer: AssetTransferTransactionFields? +public struct AssetTransferTransactionFields { + public var assetId: UInt64 + public var amount: UInt64 + public var receiver: String + public var assetSender: String? + public var closeRemainderTo: String? + + // Default memberwise initializers are never public by default, so we + // declare one manually. + public init(assetId: UInt64, amount: UInt64, receiver: String, assetSender: String? = nil, closeRemainderTo: String? = nil) { + self.assetId = assetId + self.amount = amount + self.receiver = receiver + self.assetSender = assetSender + self.closeRemainderTo = closeRemainderTo + } +} + +#if compiler(>=6) +extension AssetTransferTransactionFields: Sendable {} +#endif + + +extension AssetTransferTransactionFields: Equatable, Hashable { + public static func ==(lhs: AssetTransferTransactionFields, rhs: AssetTransferTransactionFields) -> Bool { + if lhs.assetId != rhs.assetId { + return false + } + if lhs.amount != rhs.amount { + return false + } + if lhs.receiver != rhs.receiver { + return false + } + if lhs.assetSender != rhs.assetSender { + return false + } + if lhs.closeRemainderTo != rhs.closeRemainderTo { + return false + } + return true + } + + public func hash(into hasher: inout Hasher) { + hasher.combine(assetId) + hasher.combine(amount) + hasher.combine(receiver) + hasher.combine(assetSender) + hasher.combine(closeRemainderTo) + } +} + + + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +public struct FfiConverterTypeAssetTransferTransactionFields: FfiConverterRustBuffer { + public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> AssetTransferTransactionFields { + return + try AssetTransferTransactionFields( + assetId: FfiConverterUInt64.read(from: &buf), + amount: FfiConverterUInt64.read(from: &buf), + receiver: FfiConverterString.read(from: &buf), + assetSender: FfiConverterOptionString.read(from: &buf), + closeRemainderTo: FfiConverterOptionString.read(from: &buf) + ) + } + + public static func write(_ value: AssetTransferTransactionFields, into buf: inout [UInt8]) { + FfiConverterUInt64.write(value.assetId, into: &buf) + FfiConverterUInt64.write(value.amount, into: &buf) + FfiConverterString.write(value.receiver, into: &buf) + FfiConverterOptionString.write(value.assetSender, into: &buf) + FfiConverterOptionString.write(value.closeRemainderTo, into: &buf) + } +} + + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +public func FfiConverterTypeAssetTransferTransactionFields_lift(_ buf: RustBuffer) throws -> AssetTransferTransactionFields { + return try FfiConverterTypeAssetTransferTransactionFields.lift(buf) +} + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +public func FfiConverterTypeAssetTransferTransactionFields_lower(_ value: AssetTransferTransactionFields) -> RustBuffer { + return FfiConverterTypeAssetTransferTransactionFields.lower(value) +} + + +/** + * Box reference for app call transactions. + * + * References a specific box that should be made available for the runtime + * of the program. + */ +public struct BoxReference { + /** + * App ID that owns the box. + * A value of 0 indicates the current app. + */ + public var appId: UInt64 + /** + * Name of the box. + */ + public var name: Data + + // Default memberwise initializers are never public by default, so we + // declare one manually. + public init( + /** + * App ID that owns the box. + * A value of 0 indicates the current app. + */appId: UInt64, + /** + * Name of the box. + */name: Data) { + self.appId = appId + self.name = name + } +} + +#if compiler(>=6) +extension BoxReference: Sendable {} +#endif + + +extension BoxReference: Equatable, Hashable { + public static func ==(lhs: BoxReference, rhs: BoxReference) -> Bool { + if lhs.appId != rhs.appId { + return false + } + if lhs.name != rhs.name { + return false + } + return true + } + + public func hash(into hasher: inout Hasher) { + hasher.combine(appId) + hasher.combine(name) + } +} + + + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +public struct FfiConverterTypeBoxReference: FfiConverterRustBuffer { + public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> BoxReference { + return + try BoxReference( + appId: FfiConverterUInt64.read(from: &buf), + name: FfiConverterData.read(from: &buf) + ) + } + + public static func write(_ value: BoxReference, into buf: inout [UInt8]) { + FfiConverterUInt64.write(value.appId, into: &buf) + FfiConverterData.write(value.name, into: &buf) + } +} + + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +public func FfiConverterTypeBoxReference_lift(_ buf: RustBuffer) throws -> BoxReference { + return try FfiConverterTypeBoxReference.lift(buf) +} + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +public func FfiConverterTypeBoxReference_lower(_ value: BoxReference) -> RustBuffer { + return FfiConverterTypeBoxReference.lower(value) +} + + +public struct FeeParams { + public var feePerByte: UInt64 + public var minFee: UInt64 + public var extraFee: UInt64? + public var maxFee: UInt64? + + // Default memberwise initializers are never public by default, so we + // declare one manually. + public init(feePerByte: UInt64, minFee: UInt64, extraFee: UInt64? = nil, maxFee: UInt64? = nil) { + self.feePerByte = feePerByte + self.minFee = minFee + self.extraFee = extraFee + self.maxFee = maxFee + } +} + +#if compiler(>=6) +extension FeeParams: Sendable {} +#endif + + +extension FeeParams: Equatable, Hashable { + public static func ==(lhs: FeeParams, rhs: FeeParams) -> Bool { + if lhs.feePerByte != rhs.feePerByte { + return false + } + if lhs.minFee != rhs.minFee { + return false + } + if lhs.extraFee != rhs.extraFee { + return false + } + if lhs.maxFee != rhs.maxFee { + return false + } + return true + } + + public func hash(into hasher: inout Hasher) { + hasher.combine(feePerByte) + hasher.combine(minFee) + hasher.combine(extraFee) + hasher.combine(maxFee) + } +} + + + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +public struct FfiConverterTypeFeeParams: FfiConverterRustBuffer { + public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> FeeParams { + return + try FeeParams( + feePerByte: FfiConverterUInt64.read(from: &buf), + minFee: FfiConverterUInt64.read(from: &buf), + extraFee: FfiConverterOptionUInt64.read(from: &buf), + maxFee: FfiConverterOptionUInt64.read(from: &buf) + ) + } + + public static func write(_ value: FeeParams, into buf: inout [UInt8]) { + FfiConverterUInt64.write(value.feePerByte, into: &buf) + FfiConverterUInt64.write(value.minFee, into: &buf) + FfiConverterOptionUInt64.write(value.extraFee, into: &buf) + FfiConverterOptionUInt64.write(value.maxFee, into: &buf) + } +} + + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +public func FfiConverterTypeFeeParams_lift(_ buf: RustBuffer) throws -> FeeParams { + return try FfiConverterTypeFeeParams.lift(buf) +} + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +public func FfiConverterTypeFeeParams_lower(_ value: FeeParams) -> RustBuffer { + return FfiConverterTypeFeeParams.lower(value) +} + + +public struct KeyPairAccount { + public var pubKey: Data + + // Default memberwise initializers are never public by default, so we + // declare one manually. + public init(pubKey: Data) { + self.pubKey = pubKey + } +} + +#if compiler(>=6) +extension KeyPairAccount: Sendable {} +#endif + + +extension KeyPairAccount: Equatable, Hashable { + public static func ==(lhs: KeyPairAccount, rhs: KeyPairAccount) -> Bool { + if lhs.pubKey != rhs.pubKey { + return false + } + return true + } + + public func hash(into hasher: inout Hasher) { + hasher.combine(pubKey) + } +} + + + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +public struct FfiConverterTypeKeyPairAccount: FfiConverterRustBuffer { + public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> KeyPairAccount { + return + try KeyPairAccount( + pubKey: FfiConverterData.read(from: &buf) + ) + } + + public static func write(_ value: KeyPairAccount, into buf: inout [UInt8]) { + FfiConverterData.write(value.pubKey, into: &buf) + } +} + + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +public func FfiConverterTypeKeyPairAccount_lift(_ buf: RustBuffer) throws -> KeyPairAccount { + return try FfiConverterTypeKeyPairAccount.lift(buf) +} + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +public func FfiConverterTypeKeyPairAccount_lower(_ value: KeyPairAccount) -> RustBuffer { + return FfiConverterTypeKeyPairAccount.lower(value) +} + + +public struct KeyRegistrationTransactionFields { + /** + * Root participation public key (32 bytes) + */ + public var voteKey: Data? + /** + * VRF public key (32 bytes) + */ + public var selectionKey: Data? + /** + * State proof key (64 bytes) + */ + public var stateProofKey: Data? + /** + * First round for which the participation key is valid + */ + public var voteFirst: UInt64? + /** + * Last round for which the participation key is valid + */ + public var voteLast: UInt64? + /** + * Key dilution for the 2-level participation key + */ + public var voteKeyDilution: UInt64? + /** + * Mark account as non-reward earning + */ + public var nonParticipation: Bool? + + // Default memberwise initializers are never public by default, so we + // declare one manually. + public init( + /** + * Root participation public key (32 bytes) + */voteKey: Data? = nil, + /** + * VRF public key (32 bytes) + */selectionKey: Data? = nil, + /** + * State proof key (64 bytes) + */stateProofKey: Data? = nil, + /** + * First round for which the participation key is valid + */voteFirst: UInt64? = nil, + /** + * Last round for which the participation key is valid + */voteLast: UInt64? = nil, + /** + * Key dilution for the 2-level participation key + */voteKeyDilution: UInt64? = nil, + /** + * Mark account as non-reward earning + */nonParticipation: Bool? = nil) { + self.voteKey = voteKey + self.selectionKey = selectionKey + self.stateProofKey = stateProofKey + self.voteFirst = voteFirst + self.voteLast = voteLast + self.voteKeyDilution = voteKeyDilution + self.nonParticipation = nonParticipation + } +} + +#if compiler(>=6) +extension KeyRegistrationTransactionFields: Sendable {} +#endif + + +extension KeyRegistrationTransactionFields: Equatable, Hashable { + public static func ==(lhs: KeyRegistrationTransactionFields, rhs: KeyRegistrationTransactionFields) -> Bool { + if lhs.voteKey != rhs.voteKey { + return false + } + if lhs.selectionKey != rhs.selectionKey { + return false + } + if lhs.stateProofKey != rhs.stateProofKey { + return false + } + if lhs.voteFirst != rhs.voteFirst { + return false + } + if lhs.voteLast != rhs.voteLast { + return false + } + if lhs.voteKeyDilution != rhs.voteKeyDilution { + return false + } + if lhs.nonParticipation != rhs.nonParticipation { + return false + } + return true + } + + public func hash(into hasher: inout Hasher) { + hasher.combine(voteKey) + hasher.combine(selectionKey) + hasher.combine(stateProofKey) + hasher.combine(voteFirst) + hasher.combine(voteLast) + hasher.combine(voteKeyDilution) + hasher.combine(nonParticipation) + } +} + + + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +public struct FfiConverterTypeKeyRegistrationTransactionFields: FfiConverterRustBuffer { + public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> KeyRegistrationTransactionFields { + return + try KeyRegistrationTransactionFields( + voteKey: FfiConverterOptionData.read(from: &buf), + selectionKey: FfiConverterOptionData.read(from: &buf), + stateProofKey: FfiConverterOptionData.read(from: &buf), + voteFirst: FfiConverterOptionUInt64.read(from: &buf), + voteLast: FfiConverterOptionUInt64.read(from: &buf), + voteKeyDilution: FfiConverterOptionUInt64.read(from: &buf), + nonParticipation: FfiConverterOptionBool.read(from: &buf) + ) + } + + public static func write(_ value: KeyRegistrationTransactionFields, into buf: inout [UInt8]) { + FfiConverterOptionData.write(value.voteKey, into: &buf) + FfiConverterOptionData.write(value.selectionKey, into: &buf) + FfiConverterOptionData.write(value.stateProofKey, into: &buf) + FfiConverterOptionUInt64.write(value.voteFirst, into: &buf) + FfiConverterOptionUInt64.write(value.voteLast, into: &buf) + FfiConverterOptionUInt64.write(value.voteKeyDilution, into: &buf) + FfiConverterOptionBool.write(value.nonParticipation, into: &buf) + } +} + + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +public func FfiConverterTypeKeyRegistrationTransactionFields_lift(_ buf: RustBuffer) throws -> KeyRegistrationTransactionFields { + return try FfiConverterTypeKeyRegistrationTransactionFields.lift(buf) +} + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +public func FfiConverterTypeKeyRegistrationTransactionFields_lower(_ value: KeyRegistrationTransactionFields) -> RustBuffer { + return FfiConverterTypeKeyRegistrationTransactionFields.lower(value) +} + + +/** + * Representation of an Algorand multisignature signature. + */ +public struct MultisigSignature { + /** + * Multisig version. + */ + public var version: UInt8 + /** + * Minimum number of signatures required. + */ + public var threshold: UInt8 + /** + * List of subsignatures for each participant. + */ + public var subsignatures: [MultisigSubsignature] + + // Default memberwise initializers are never public by default, so we + // declare one manually. + public init( + /** + * Multisig version. + */version: UInt8, + /** + * Minimum number of signatures required. + */threshold: UInt8, + /** + * List of subsignatures for each participant. + */subsignatures: [MultisigSubsignature]) { + self.version = version + self.threshold = threshold + self.subsignatures = subsignatures + } +} + +#if compiler(>=6) +extension MultisigSignature: Sendable {} +#endif + + +extension MultisigSignature: Equatable, Hashable { + public static func ==(lhs: MultisigSignature, rhs: MultisigSignature) -> Bool { + if lhs.version != rhs.version { + return false + } + if lhs.threshold != rhs.threshold { + return false + } + if lhs.subsignatures != rhs.subsignatures { + return false + } + return true + } + + public func hash(into hasher: inout Hasher) { + hasher.combine(version) + hasher.combine(threshold) + hasher.combine(subsignatures) + } +} + + + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +public struct FfiConverterTypeMultisigSignature: FfiConverterRustBuffer { + public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> MultisigSignature { + return + try MultisigSignature( + version: FfiConverterUInt8.read(from: &buf), + threshold: FfiConverterUInt8.read(from: &buf), + subsignatures: FfiConverterSequenceTypeMultisigSubsignature.read(from: &buf) + ) + } + + public static func write(_ value: MultisigSignature, into buf: inout [UInt8]) { + FfiConverterUInt8.write(value.version, into: &buf) + FfiConverterUInt8.write(value.threshold, into: &buf) + FfiConverterSequenceTypeMultisigSubsignature.write(value.subsignatures, into: &buf) + } +} + + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +public func FfiConverterTypeMultisigSignature_lift(_ buf: RustBuffer) throws -> MultisigSignature { + return try FfiConverterTypeMultisigSignature.lift(buf) +} + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +public func FfiConverterTypeMultisigSignature_lower(_ value: MultisigSignature) -> RustBuffer { + return FfiConverterTypeMultisigSignature.lower(value) +} + + +/** + * Representation of a single subsignature in a multisignature transaction. + * + * Each subsignature contains the participant's address and an optional signature. + */ +public struct MultisigSubsignature { + /** + * Address of the participant. + */ + public var address: String + /** + * Optional signature bytes for the participant. + */ + public var signature: Data? + + // Default memberwise initializers are never public by default, so we + // declare one manually. + public init( + /** + * Address of the participant. + */address: String, + /** + * Optional signature bytes for the participant. + */signature: Data? = nil) { + self.address = address + self.signature = signature + } +} + +#if compiler(>=6) +extension MultisigSubsignature: Sendable {} +#endif + + +extension MultisigSubsignature: Equatable, Hashable { + public static func ==(lhs: MultisigSubsignature, rhs: MultisigSubsignature) -> Bool { + if lhs.address != rhs.address { + return false + } + if lhs.signature != rhs.signature { + return false + } + return true + } + + public func hash(into hasher: inout Hasher) { + hasher.combine(address) + hasher.combine(signature) + } +} + + + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +public struct FfiConverterTypeMultisigSubsignature: FfiConverterRustBuffer { + public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> MultisigSubsignature { + return + try MultisigSubsignature( + address: FfiConverterString.read(from: &buf), + signature: FfiConverterOptionData.read(from: &buf) + ) + } + + public static func write(_ value: MultisigSubsignature, into buf: inout [UInt8]) { + FfiConverterString.write(value.address, into: &buf) + FfiConverterOptionData.write(value.signature, into: &buf) + } +} + + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +public func FfiConverterTypeMultisigSubsignature_lift(_ buf: RustBuffer) throws -> MultisigSubsignature { + return try FfiConverterTypeMultisigSubsignature.lift(buf) +} + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +public func FfiConverterTypeMultisigSubsignature_lower(_ value: MultisigSubsignature) -> RustBuffer { + return FfiConverterTypeMultisigSubsignature.lower(value) +} + + +public struct PaymentTransactionFields { + public var receiver: String + public var amount: UInt64 + public var closeRemainderTo: String? + + // Default memberwise initializers are never public by default, so we + // declare one manually. + public init(receiver: String, amount: UInt64, closeRemainderTo: String? = nil) { + self.receiver = receiver + self.amount = amount + self.closeRemainderTo = closeRemainderTo + } +} + +#if compiler(>=6) +extension PaymentTransactionFields: Sendable {} +#endif + + +extension PaymentTransactionFields: Equatable, Hashable { + public static func ==(lhs: PaymentTransactionFields, rhs: PaymentTransactionFields) -> Bool { + if lhs.receiver != rhs.receiver { + return false + } + if lhs.amount != rhs.amount { + return false + } + if lhs.closeRemainderTo != rhs.closeRemainderTo { + return false + } + return true + } + + public func hash(into hasher: inout Hasher) { + hasher.combine(receiver) + hasher.combine(amount) + hasher.combine(closeRemainderTo) + } +} + + + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +public struct FfiConverterTypePaymentTransactionFields: FfiConverterRustBuffer { + public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> PaymentTransactionFields { + return + try PaymentTransactionFields( + receiver: FfiConverterString.read(from: &buf), + amount: FfiConverterUInt64.read(from: &buf), + closeRemainderTo: FfiConverterOptionString.read(from: &buf) + ) + } + + public static func write(_ value: PaymentTransactionFields, into buf: inout [UInt8]) { + FfiConverterString.write(value.receiver, into: &buf) + FfiConverterUInt64.write(value.amount, into: &buf) + FfiConverterOptionString.write(value.closeRemainderTo, into: &buf) + } +} + + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +public func FfiConverterTypePaymentTransactionFields_lift(_ buf: RustBuffer) throws -> PaymentTransactionFields { + return try FfiConverterTypePaymentTransactionFields.lift(buf) +} + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +public func FfiConverterTypePaymentTransactionFields_lower(_ value: PaymentTransactionFields) -> RustBuffer { + return FfiConverterTypePaymentTransactionFields.lower(value) +} + + +public struct SignedTransaction { + /** + * The transaction that has been signed. + */ + public var transaction: Transaction + /** + * Optional Ed25519 signature authorizing the transaction. + */ + public var signature: Data? + /** + * Optional auth address applicable if the transaction sender is a rekeyed account. + */ + public var authAddress: String? + /** + * Optional multisig signature if the transaction is a multisig transaction. + */ + public var multisignature: MultisigSignature? + + // Default memberwise initializers are never public by default, so we + // declare one manually. + public init( + /** + * The transaction that has been signed. + */transaction: Transaction, + /** + * Optional Ed25519 signature authorizing the transaction. + */signature: Data? = nil, + /** + * Optional auth address applicable if the transaction sender is a rekeyed account. + */authAddress: String? = nil, + /** + * Optional multisig signature if the transaction is a multisig transaction. + */multisignature: MultisigSignature? = nil) { + self.transaction = transaction + self.signature = signature + self.authAddress = authAddress + self.multisignature = multisignature + } +} + +#if compiler(>=6) +extension SignedTransaction: Sendable {} +#endif + + +extension SignedTransaction: Equatable, Hashable { + public static func ==(lhs: SignedTransaction, rhs: SignedTransaction) -> Bool { + if lhs.transaction != rhs.transaction { + return false + } + if lhs.signature != rhs.signature { + return false + } + if lhs.authAddress != rhs.authAddress { + return false + } + if lhs.multisignature != rhs.multisignature { + return false + } + return true + } + + public func hash(into hasher: inout Hasher) { + hasher.combine(transaction) + hasher.combine(signature) + hasher.combine(authAddress) + hasher.combine(multisignature) + } +} + + + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +public struct FfiConverterTypeSignedTransaction: FfiConverterRustBuffer { + public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> SignedTransaction { + return + try SignedTransaction( + transaction: FfiConverterTypeTransaction.read(from: &buf), + signature: FfiConverterOptionData.read(from: &buf), + authAddress: FfiConverterOptionString.read(from: &buf), + multisignature: FfiConverterOptionTypeMultisigSignature.read(from: &buf) + ) + } + + public static func write(_ value: SignedTransaction, into buf: inout [UInt8]) { + FfiConverterTypeTransaction.write(value.transaction, into: &buf) + FfiConverterOptionData.write(value.signature, into: &buf) + FfiConverterOptionString.write(value.authAddress, into: &buf) + FfiConverterOptionTypeMultisigSignature.write(value.multisignature, into: &buf) + } +} + + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +public func FfiConverterTypeSignedTransaction_lift(_ buf: RustBuffer) throws -> SignedTransaction { + return try FfiConverterTypeSignedTransaction.lift(buf) +} + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +public func FfiConverterTypeSignedTransaction_lower(_ value: SignedTransaction) -> RustBuffer { + return FfiConverterTypeSignedTransaction.lower(value) +} + + +/** + * Schema for app state storage. + * + * Defines the maximum number of values that may be stored in app + * key/value storage for both global and local state. + */ +public struct StateSchema { + /** + * Maximum number of integer values that may be stored. + */ + public var numUints: UInt32 + /** + * Maximum number of byte slice values that may be stored. + */ + public var numByteSlices: UInt32 + + // Default memberwise initializers are never public by default, so we + // declare one manually. + public init( + /** + * Maximum number of integer values that may be stored. + */numUints: UInt32, + /** + * Maximum number of byte slice values that may be stored. + */numByteSlices: UInt32) { + self.numUints = numUints + self.numByteSlices = numByteSlices + } +} + +#if compiler(>=6) +extension StateSchema: Sendable {} +#endif + + +extension StateSchema: Equatable, Hashable { + public static func ==(lhs: StateSchema, rhs: StateSchema) -> Bool { + if lhs.numUints != rhs.numUints { + return false + } + if lhs.numByteSlices != rhs.numByteSlices { + return false + } + return true + } + + public func hash(into hasher: inout Hasher) { + hasher.combine(numUints) + hasher.combine(numByteSlices) + } +} + + + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +public struct FfiConverterTypeStateSchema: FfiConverterRustBuffer { + public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> StateSchema { + return + try StateSchema( + numUints: FfiConverterUInt32.read(from: &buf), + numByteSlices: FfiConverterUInt32.read(from: &buf) + ) + } + + public static func write(_ value: StateSchema, into buf: inout [UInt8]) { + FfiConverterUInt32.write(value.numUints, into: &buf) + FfiConverterUInt32.write(value.numByteSlices, into: &buf) + } +} + + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +public func FfiConverterTypeStateSchema_lift(_ buf: RustBuffer) throws -> StateSchema { + return try FfiConverterTypeStateSchema.lift(buf) +} + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +public func FfiConverterTypeStateSchema_lower(_ value: StateSchema) -> RustBuffer { + return FfiConverterTypeStateSchema.lower(value) +} + + +public struct Transaction { + /** + * The type of transaction + */ + public var transactionType: TransactionType + /** + * The sender of the transaction + */ + public var sender: String + /** + * Optional transaction fee in microALGO. + * + * If not set, the fee will be interpreted as 0 by the network. + */ + public var fee: UInt64? + public var firstValid: UInt64 + public var lastValid: UInt64 + public var genesisHash: Data? + public var genesisId: String? + public var note: Data? + public var rekeyTo: String? + public var lease: Data? + public var group: Data? + public var payment: PaymentTransactionFields? + public var assetTransfer: AssetTransferTransactionFields? + public var assetConfig: AssetConfigTransactionFields? + public var appCall: AppCallTransactionFields? + public var keyRegistration: KeyRegistrationTransactionFields? + public var assetFreeze: AssetFreezeTransactionFields? // Default memberwise initializers are never public by default, so we // declare one manually. @@ -731,7 +2268,12 @@ public struct Transaction { */transactionType: TransactionType, /** * The sender of the transaction - */sender: Address, fee: UInt64, firstValid: UInt64, lastValid: UInt64, genesisHash: ByteBuf?, genesisId: String?, note: ByteBuf? = nil, rekeyTo: Address? = nil, lease: ByteBuf? = nil, group: ByteBuf? = nil, payment: PaymentTransactionFields? = nil, assetTransfer: AssetTransferTransactionFields? = nil) { + */sender: String, + /** + * Optional transaction fee in microALGO. + * + * If not set, the fee will be interpreted as 0 by the network. + */fee: UInt64? = nil, firstValid: UInt64, lastValid: UInt64, genesisHash: Data?, genesisId: String?, note: Data? = nil, rekeyTo: String? = nil, lease: Data? = nil, group: Data? = nil, payment: PaymentTransactionFields? = nil, assetTransfer: AssetTransferTransactionFields? = nil, assetConfig: AssetConfigTransactionFields? = nil, appCall: AppCallTransactionFields? = nil, keyRegistration: KeyRegistrationTransactionFields? = nil, assetFreeze: AssetFreezeTransactionFields? = nil) { self.transactionType = transactionType self.sender = sender self.fee = fee @@ -745,9 +2287,16 @@ public struct Transaction { self.group = group self.payment = payment self.assetTransfer = assetTransfer + self.assetConfig = assetConfig + self.appCall = appCall + self.keyRegistration = keyRegistration + self.assetFreeze = assetFreeze } } +#if compiler(>=6) +extension Transaction: Sendable {} +#endif extension Transaction: Equatable, Hashable { @@ -791,6 +2340,18 @@ extension Transaction: Equatable, Hashable { if lhs.assetTransfer != rhs.assetTransfer { return false } + if lhs.assetConfig != rhs.assetConfig { + return false + } + if lhs.appCall != rhs.appCall { + return false + } + if lhs.keyRegistration != rhs.keyRegistration { + return false + } + if lhs.assetFreeze != rhs.assetFreeze { + return false + } return true } @@ -808,10 +2369,15 @@ extension Transaction: Equatable, Hashable { hasher.combine(group) hasher.combine(payment) hasher.combine(assetTransfer) + hasher.combine(assetConfig) + hasher.combine(appCall) + hasher.combine(keyRegistration) + hasher.combine(assetFreeze) } } + #if swift(>=5.8) @_documentation(visibility: private) #endif @@ -820,35 +2386,43 @@ public struct FfiConverterTypeTransaction: FfiConverterRustBuffer { return try Transaction( transactionType: FfiConverterTypeTransactionType.read(from: &buf), - sender: FfiConverterTypeAddress.read(from: &buf), - fee: FfiConverterUInt64.read(from: &buf), + sender: FfiConverterString.read(from: &buf), + fee: FfiConverterOptionUInt64.read(from: &buf), firstValid: FfiConverterUInt64.read(from: &buf), lastValid: FfiConverterUInt64.read(from: &buf), - genesisHash: FfiConverterOptionTypeByteBuf.read(from: &buf), + genesisHash: FfiConverterOptionData.read(from: &buf), genesisId: FfiConverterOptionString.read(from: &buf), - note: FfiConverterOptionTypeByteBuf.read(from: &buf), - rekeyTo: FfiConverterOptionTypeAddress.read(from: &buf), - lease: FfiConverterOptionTypeByteBuf.read(from: &buf), - group: FfiConverterOptionTypeByteBuf.read(from: &buf), + note: FfiConverterOptionData.read(from: &buf), + rekeyTo: FfiConverterOptionString.read(from: &buf), + lease: FfiConverterOptionData.read(from: &buf), + group: FfiConverterOptionData.read(from: &buf), payment: FfiConverterOptionTypePaymentTransactionFields.read(from: &buf), - assetTransfer: FfiConverterOptionTypeAssetTransferTransactionFields.read(from: &buf) + assetTransfer: FfiConverterOptionTypeAssetTransferTransactionFields.read(from: &buf), + assetConfig: FfiConverterOptionTypeAssetConfigTransactionFields.read(from: &buf), + appCall: FfiConverterOptionTypeAppCallTransactionFields.read(from: &buf), + keyRegistration: FfiConverterOptionTypeKeyRegistrationTransactionFields.read(from: &buf), + assetFreeze: FfiConverterOptionTypeAssetFreezeTransactionFields.read(from: &buf) ) } public static func write(_ value: Transaction, into buf: inout [UInt8]) { FfiConverterTypeTransactionType.write(value.transactionType, into: &buf) - FfiConverterTypeAddress.write(value.sender, into: &buf) - FfiConverterUInt64.write(value.fee, into: &buf) + FfiConverterString.write(value.sender, into: &buf) + FfiConverterOptionUInt64.write(value.fee, into: &buf) FfiConverterUInt64.write(value.firstValid, into: &buf) FfiConverterUInt64.write(value.lastValid, into: &buf) - FfiConverterOptionTypeByteBuf.write(value.genesisHash, into: &buf) + FfiConverterOptionData.write(value.genesisHash, into: &buf) FfiConverterOptionString.write(value.genesisId, into: &buf) - FfiConverterOptionTypeByteBuf.write(value.note, into: &buf) - FfiConverterOptionTypeAddress.write(value.rekeyTo, into: &buf) - FfiConverterOptionTypeByteBuf.write(value.lease, into: &buf) - FfiConverterOptionTypeByteBuf.write(value.group, into: &buf) + FfiConverterOptionData.write(value.note, into: &buf) + FfiConverterOptionString.write(value.rekeyTo, into: &buf) + FfiConverterOptionData.write(value.lease, into: &buf) + FfiConverterOptionData.write(value.group, into: &buf) FfiConverterOptionTypePaymentTransactionFields.write(value.payment, into: &buf) FfiConverterOptionTypeAssetTransferTransactionFields.write(value.assetTransfer, into: &buf) + FfiConverterOptionTypeAssetConfigTransactionFields.write(value.assetConfig, into: &buf) + FfiConverterOptionTypeAppCallTransactionFields.write(value.appCall, into: &buf) + FfiConverterOptionTypeKeyRegistrationTransactionFields.write(value.keyRegistration, into: &buf) + FfiConverterOptionTypeAssetFreezeTransactionFields.write(value.assetFreeze, into: &buf) } } @@ -868,13 +2442,17 @@ public func FfiConverterTypeTransaction_lower(_ value: Transaction) -> RustBuffe } -public enum AlgoKitTransactError { +public enum AlgoKitTransactError: Swift.Error { - case EncodingError(String + case EncodingError(errorMsg: String + ) + case DecodingError(errorMsg: String ) - case DecodingError(String + case InputError(errorMsg: String + ) + case MsgPackError(errorMsg: String ) } @@ -893,10 +2471,16 @@ public struct FfiConverterTypeAlgoKitTransactError: FfiConverterRustBuffer { case 1: return .EncodingError( - try FfiConverterString.read(from: &buf) + errorMsg: try FfiConverterString.read(from: &buf) ) case 2: return .DecodingError( - try FfiConverterString.read(from: &buf) + errorMsg: try FfiConverterString.read(from: &buf) + ) + case 3: return .InputError( + errorMsg: try FfiConverterString.read(from: &buf) + ) + case 4: return .MsgPackError( + errorMsg: try FfiConverterString.read(from: &buf) ) default: throw UniffiInternalError.unexpectedEnumCase @@ -910,126 +2494,300 @@ public struct FfiConverterTypeAlgoKitTransactError: FfiConverterRustBuffer { - case let .EncodingError(v1): + case let .EncodingError(errorMsg): writeInt(&buf, Int32(1)) - FfiConverterString.write(v1, into: &buf) + FfiConverterString.write(errorMsg, into: &buf) - case let .DecodingError(v1): + case let .DecodingError(errorMsg): writeInt(&buf, Int32(2)) - FfiConverterString.write(v1, into: &buf) + FfiConverterString.write(errorMsg, into: &buf) + + + case let .InputError(errorMsg): + writeInt(&buf, Int32(3)) + FfiConverterString.write(errorMsg, into: &buf) + + + case let .MsgPackError(errorMsg): + writeInt(&buf, Int32(4)) + FfiConverterString.write(errorMsg, into: &buf) } } } -extension AlgoKitTransactError: Equatable, Hashable {} +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +public func FfiConverterTypeAlgoKitTransactError_lift(_ buf: RustBuffer) throws -> AlgoKitTransactError { + return try FfiConverterTypeAlgoKitTransactError.lift(buf) +} + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +public func FfiConverterTypeAlgoKitTransactError_lower(_ value: AlgoKitTransactError) -> RustBuffer { + return FfiConverterTypeAlgoKitTransactError.lower(value) +} + + +extension AlgoKitTransactError: Equatable, Hashable {} + + + + +extension AlgoKitTransactError: Foundation.LocalizedError { + public var errorDescription: String? { + String(reflecting: self) + } +} + + + + +// Note that we don't yet support `indirect` for enums. +// See https://github.com/mozilla/uniffi-rs/issues/396 for further discussion. +/** + * Enum containing all constants used in this crate. + */ + +public enum AlgorandConstant { + + /** + * Length of hash digests (32) + */ + case hashLength + /** + * Length of the checksum used in Algorand addresses (4) + */ + case checksumLength + /** + * Length of a base32-encoded Algorand address (58) + */ + case addressLength + /** + * Length of an Algorand public key in bytes (32) + */ + case publicKeyLength + /** + * Length of an Algorand secret key in bytes (32) + */ + case secretKeyLength + /** + * Length of an Algorand signature in bytes (64) + */ + case signatureLength + /** + * Increment in the encoded byte size when a signature is attached to a transaction (75) + */ + case signatureEncodingIncrLength + /** + * The maximum number of transactions in a group (16) + */ + case maxTxGroupSize +} + + +#if compiler(>=6) +extension AlgorandConstant: Sendable {} +#endif + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +public struct FfiConverterTypeAlgorandConstant: FfiConverterRustBuffer { + typealias SwiftType = AlgorandConstant + + public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> AlgorandConstant { + let variant: Int32 = try readInt(&buf) + switch variant { + + case 1: return .hashLength + + case 2: return .checksumLength + + case 3: return .addressLength + + case 4: return .publicKeyLength + + case 5: return .secretKeyLength + + case 6: return .signatureLength + + case 7: return .signatureEncodingIncrLength + + case 8: return .maxTxGroupSize + + default: throw UniffiInternalError.unexpectedEnumCase + } + } + + public static func write(_ value: AlgorandConstant, into buf: inout [UInt8]) { + switch value { + + + case .hashLength: + writeInt(&buf, Int32(1)) + + + case .checksumLength: + writeInt(&buf, Int32(2)) + + + case .addressLength: + writeInt(&buf, Int32(3)) + + + case .publicKeyLength: + writeInt(&buf, Int32(4)) + + + case .secretKeyLength: + writeInt(&buf, Int32(5)) + + + case .signatureLength: + writeInt(&buf, Int32(6)) + + + case .signatureEncodingIncrLength: + writeInt(&buf, Int32(7)) + + + case .maxTxGroupSize: + writeInt(&buf, Int32(8)) + + } + } +} + + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +public func FfiConverterTypeAlgorandConstant_lift(_ buf: RustBuffer) throws -> AlgorandConstant { + return try FfiConverterTypeAlgorandConstant.lift(buf) +} + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +public func FfiConverterTypeAlgorandConstant_lower(_ value: AlgorandConstant) -> RustBuffer { + return FfiConverterTypeAlgorandConstant.lower(value) +} + + +extension AlgorandConstant: Equatable, Hashable {} + + + + -extension AlgoKitTransactError: Foundation.LocalizedError { - public var errorDescription: String? { - String(reflecting: self) - } -} // Note that we don't yet support `indirect` for enums. // See https://github.com/mozilla/uniffi-rs/issues/396 for further discussion. /** - * Enum containing all constants used in this crate. + * On-completion actions for app transactions. + * + * These values define what additional actions occur with the transaction. */ -public enum AlgorandConstant { +public enum OnApplicationComplete { /** - * Length of hash digests (32) - */ - case hashLength - /** - * Length of the checksum used in Algorand addresses (4) + * NoOp indicates that an app transaction will simply call its + * approval program without any additional action. */ - case checksumLength + case noOp /** - * Length of a base32-encoded Algorand address (58) + * OptIn indicates that an app transaction will allocate some + * local state for the app in the sender's account. */ - case addressLength + case optIn /** - * Length of an Algorand public key in bytes (32) + * CloseOut indicates that an app transaction will deallocate + * some local state for the app from the user's account. */ - case publicKeyLength + case closeOut /** - * Length of an Algorand secret key in bytes (32) + * ClearState is similar to CloseOut, but may never fail. This + * allows users to reclaim their minimum balance from an app + * they no longer wish to opt in to. */ - case secretKeyLength + case clearState /** - * Length of an Algorand signature in bytes (64) + * UpdateApplication indicates that an app transaction will + * update the approval program and clear state program for the app. */ - case signatureLength + case updateApplication /** - * Increment in the encoded byte size when a signature is attached to a transaction (75) + * DeleteApplication indicates that an app transaction will + * delete the app parameters for the app from the creator's + * balance record. */ - case signatureEncodingIncrLength + case deleteApplication } +#if compiler(>=6) +extension OnApplicationComplete: Sendable {} +#endif + #if swift(>=5.8) @_documentation(visibility: private) #endif -public struct FfiConverterTypeAlgorandConstant: FfiConverterRustBuffer { - typealias SwiftType = AlgorandConstant +public struct FfiConverterTypeOnApplicationComplete: FfiConverterRustBuffer { + typealias SwiftType = OnApplicationComplete - public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> AlgorandConstant { + public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> OnApplicationComplete { let variant: Int32 = try readInt(&buf) switch variant { - case 1: return .hashLength - - case 2: return .checksumLength + case 1: return .noOp - case 3: return .addressLength + case 2: return .optIn - case 4: return .publicKeyLength + case 3: return .closeOut - case 5: return .secretKeyLength + case 4: return .clearState - case 6: return .signatureLength + case 5: return .updateApplication - case 7: return .signatureEncodingIncrLength + case 6: return .deleteApplication default: throw UniffiInternalError.unexpectedEnumCase } } - public static func write(_ value: AlgorandConstant, into buf: inout [UInt8]) { + public static func write(_ value: OnApplicationComplete, into buf: inout [UInt8]) { switch value { - case .hashLength: + case .noOp: writeInt(&buf, Int32(1)) - case .checksumLength: + case .optIn: writeInt(&buf, Int32(2)) - case .addressLength: + case .closeOut: writeInt(&buf, Int32(3)) - case .publicKeyLength: + case .clearState: writeInt(&buf, Int32(4)) - case .secretKeyLength: + case .updateApplication: writeInt(&buf, Int32(5)) - case .signatureLength: + case .deleteApplication: writeInt(&buf, Int32(6)) - - case .signatureEncodingIncrLength: - writeInt(&buf, Int32(7)) - } } } @@ -1038,20 +2796,22 @@ public struct FfiConverterTypeAlgorandConstant: FfiConverterRustBuffer { #if swift(>=5.8) @_documentation(visibility: private) #endif -public func FfiConverterTypeAlgorandConstant_lift(_ buf: RustBuffer) throws -> AlgorandConstant { - return try FfiConverterTypeAlgorandConstant.lift(buf) +public func FfiConverterTypeOnApplicationComplete_lift(_ buf: RustBuffer) throws -> OnApplicationComplete { + return try FfiConverterTypeOnApplicationComplete.lift(buf) } #if swift(>=5.8) @_documentation(visibility: private) #endif -public func FfiConverterTypeAlgorandConstant_lower(_ value: AlgorandConstant) -> RustBuffer { - return FfiConverterTypeAlgorandConstant.lower(value) +public func FfiConverterTypeOnApplicationComplete_lower(_ value: OnApplicationComplete) -> RustBuffer { + return FfiConverterTypeOnApplicationComplete.lower(value) } +extension OnApplicationComplete: Equatable, Hashable {} + + -extension AlgorandConstant: Equatable, Hashable {} @@ -1065,10 +2825,14 @@ public enum TransactionType { case assetFreeze case assetConfig case keyRegistration - case applicationCall + case appCall } +#if compiler(>=6) +extension TransactionType: Sendable {} +#endif + #if swift(>=5.8) @_documentation(visibility: private) #endif @@ -1089,7 +2853,7 @@ public struct FfiConverterTypeTransactionType: FfiConverterRustBuffer { case 5: return .keyRegistration - case 6: return .applicationCall + case 6: return .appCall default: throw UniffiInternalError.unexpectedEnumCase } @@ -1119,39 +2883,329 @@ public struct FfiConverterTypeTransactionType: FfiConverterRustBuffer { writeInt(&buf, Int32(5)) - case .applicationCall: + case .appCall: writeInt(&buf, Int32(6)) } } -} +} + + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +public func FfiConverterTypeTransactionType_lift(_ buf: RustBuffer) throws -> TransactionType { + return try FfiConverterTypeTransactionType.lift(buf) +} + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +public func FfiConverterTypeTransactionType_lower(_ value: TransactionType) -> RustBuffer { + return FfiConverterTypeTransactionType.lower(value) +} + + +extension TransactionType: Equatable, Hashable {} + + + + + + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +fileprivate struct FfiConverterOptionUInt32: FfiConverterRustBuffer { + typealias SwiftType = UInt32? + + public static func write(_ value: SwiftType, into buf: inout [UInt8]) { + guard let value = value else { + writeInt(&buf, Int8(0)) + return + } + writeInt(&buf, Int8(1)) + FfiConverterUInt32.write(value, into: &buf) + } + + public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> SwiftType { + switch try readInt(&buf) as Int8 { + case 0: return nil + case 1: return try FfiConverterUInt32.read(from: &buf) + default: throw UniffiInternalError.unexpectedOptionalTag + } + } +} + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +fileprivate struct FfiConverterOptionUInt64: FfiConverterRustBuffer { + typealias SwiftType = UInt64? + + public static func write(_ value: SwiftType, into buf: inout [UInt8]) { + guard let value = value else { + writeInt(&buf, Int8(0)) + return + } + writeInt(&buf, Int8(1)) + FfiConverterUInt64.write(value, into: &buf) + } + + public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> SwiftType { + switch try readInt(&buf) as Int8 { + case 0: return nil + case 1: return try FfiConverterUInt64.read(from: &buf) + default: throw UniffiInternalError.unexpectedOptionalTag + } + } +} + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +fileprivate struct FfiConverterOptionBool: FfiConverterRustBuffer { + typealias SwiftType = Bool? + + public static func write(_ value: SwiftType, into buf: inout [UInt8]) { + guard let value = value else { + writeInt(&buf, Int8(0)) + return + } + writeInt(&buf, Int8(1)) + FfiConverterBool.write(value, into: &buf) + } + + public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> SwiftType { + switch try readInt(&buf) as Int8 { + case 0: return nil + case 1: return try FfiConverterBool.read(from: &buf) + default: throw UniffiInternalError.unexpectedOptionalTag + } + } +} + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +fileprivate struct FfiConverterOptionString: FfiConverterRustBuffer { + typealias SwiftType = String? + + public static func write(_ value: SwiftType, into buf: inout [UInt8]) { + guard let value = value else { + writeInt(&buf, Int8(0)) + return + } + writeInt(&buf, Int8(1)) + FfiConverterString.write(value, into: &buf) + } + + public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> SwiftType { + switch try readInt(&buf) as Int8 { + case 0: return nil + case 1: return try FfiConverterString.read(from: &buf) + default: throw UniffiInternalError.unexpectedOptionalTag + } + } +} + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +fileprivate struct FfiConverterOptionData: FfiConverterRustBuffer { + typealias SwiftType = Data? + + public static func write(_ value: SwiftType, into buf: inout [UInt8]) { + guard let value = value else { + writeInt(&buf, Int8(0)) + return + } + writeInt(&buf, Int8(1)) + FfiConverterData.write(value, into: &buf) + } + + public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> SwiftType { + switch try readInt(&buf) as Int8 { + case 0: return nil + case 1: return try FfiConverterData.read(from: &buf) + default: throw UniffiInternalError.unexpectedOptionalTag + } + } +} + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +fileprivate struct FfiConverterOptionTypeAppCallTransactionFields: FfiConverterRustBuffer { + typealias SwiftType = AppCallTransactionFields? + + public static func write(_ value: SwiftType, into buf: inout [UInt8]) { + guard let value = value else { + writeInt(&buf, Int8(0)) + return + } + writeInt(&buf, Int8(1)) + FfiConverterTypeAppCallTransactionFields.write(value, into: &buf) + } + + public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> SwiftType { + switch try readInt(&buf) as Int8 { + case 0: return nil + case 1: return try FfiConverterTypeAppCallTransactionFields.read(from: &buf) + default: throw UniffiInternalError.unexpectedOptionalTag + } + } +} + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +fileprivate struct FfiConverterOptionTypeAssetConfigTransactionFields: FfiConverterRustBuffer { + typealias SwiftType = AssetConfigTransactionFields? + + public static func write(_ value: SwiftType, into buf: inout [UInt8]) { + guard let value = value else { + writeInt(&buf, Int8(0)) + return + } + writeInt(&buf, Int8(1)) + FfiConverterTypeAssetConfigTransactionFields.write(value, into: &buf) + } + + public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> SwiftType { + switch try readInt(&buf) as Int8 { + case 0: return nil + case 1: return try FfiConverterTypeAssetConfigTransactionFields.read(from: &buf) + default: throw UniffiInternalError.unexpectedOptionalTag + } + } +} + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +fileprivate struct FfiConverterOptionTypeAssetFreezeTransactionFields: FfiConverterRustBuffer { + typealias SwiftType = AssetFreezeTransactionFields? + + public static func write(_ value: SwiftType, into buf: inout [UInt8]) { + guard let value = value else { + writeInt(&buf, Int8(0)) + return + } + writeInt(&buf, Int8(1)) + FfiConverterTypeAssetFreezeTransactionFields.write(value, into: &buf) + } + + public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> SwiftType { + switch try readInt(&buf) as Int8 { + case 0: return nil + case 1: return try FfiConverterTypeAssetFreezeTransactionFields.read(from: &buf) + default: throw UniffiInternalError.unexpectedOptionalTag + } + } +} + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +fileprivate struct FfiConverterOptionTypeAssetTransferTransactionFields: FfiConverterRustBuffer { + typealias SwiftType = AssetTransferTransactionFields? + + public static func write(_ value: SwiftType, into buf: inout [UInt8]) { + guard let value = value else { + writeInt(&buf, Int8(0)) + return + } + writeInt(&buf, Int8(1)) + FfiConverterTypeAssetTransferTransactionFields.write(value, into: &buf) + } + public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> SwiftType { + switch try readInt(&buf) as Int8 { + case 0: return nil + case 1: return try FfiConverterTypeAssetTransferTransactionFields.read(from: &buf) + default: throw UniffiInternalError.unexpectedOptionalTag + } + } +} #if swift(>=5.8) @_documentation(visibility: private) #endif -public func FfiConverterTypeTransactionType_lift(_ buf: RustBuffer) throws -> TransactionType { - return try FfiConverterTypeTransactionType.lift(buf) +fileprivate struct FfiConverterOptionTypeKeyRegistrationTransactionFields: FfiConverterRustBuffer { + typealias SwiftType = KeyRegistrationTransactionFields? + + public static func write(_ value: SwiftType, into buf: inout [UInt8]) { + guard let value = value else { + writeInt(&buf, Int8(0)) + return + } + writeInt(&buf, Int8(1)) + FfiConverterTypeKeyRegistrationTransactionFields.write(value, into: &buf) + } + + public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> SwiftType { + switch try readInt(&buf) as Int8 { + case 0: return nil + case 1: return try FfiConverterTypeKeyRegistrationTransactionFields.read(from: &buf) + default: throw UniffiInternalError.unexpectedOptionalTag + } + } } #if swift(>=5.8) @_documentation(visibility: private) #endif -public func FfiConverterTypeTransactionType_lower(_ value: TransactionType) -> RustBuffer { - return FfiConverterTypeTransactionType.lower(value) -} +fileprivate struct FfiConverterOptionTypeMultisigSignature: FfiConverterRustBuffer { + typealias SwiftType = MultisigSignature? + public static func write(_ value: SwiftType, into buf: inout [UInt8]) { + guard let value = value else { + writeInt(&buf, Int8(0)) + return + } + writeInt(&buf, Int8(1)) + FfiConverterTypeMultisigSignature.write(value, into: &buf) + } + public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> SwiftType { + switch try readInt(&buf) as Int8 { + case 0: return nil + case 1: return try FfiConverterTypeMultisigSignature.read(from: &buf) + default: throw UniffiInternalError.unexpectedOptionalTag + } + } +} -extension TransactionType: Equatable, Hashable {} +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +fileprivate struct FfiConverterOptionTypePaymentTransactionFields: FfiConverterRustBuffer { + typealias SwiftType = PaymentTransactionFields? + public static func write(_ value: SwiftType, into buf: inout [UInt8]) { + guard let value = value else { + writeInt(&buf, Int8(0)) + return + } + writeInt(&buf, Int8(1)) + FfiConverterTypePaymentTransactionFields.write(value, into: &buf) + } + public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> SwiftType { + switch try readInt(&buf) as Int8 { + case 0: return nil + case 1: return try FfiConverterTypePaymentTransactionFields.read(from: &buf) + default: throw UniffiInternalError.unexpectedOptionalTag + } + } +} #if swift(>=5.8) @_documentation(visibility: private) #endif -fileprivate struct FfiConverterOptionString: FfiConverterRustBuffer { - typealias SwiftType = String? +fileprivate struct FfiConverterOptionTypeStateSchema: FfiConverterRustBuffer { + typealias SwiftType = StateSchema? public static func write(_ value: SwiftType, into buf: inout [UInt8]) { guard let value = value else { @@ -1159,13 +3213,13 @@ fileprivate struct FfiConverterOptionString: FfiConverterRustBuffer { return } writeInt(&buf, Int8(1)) - FfiConverterString.write(value, into: &buf) + FfiConverterTypeStateSchema.write(value, into: &buf) } public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> SwiftType { switch try readInt(&buf) as Int8 { case 0: return nil - case 1: return try FfiConverterString.read(from: &buf) + case 1: return try FfiConverterTypeStateSchema.read(from: &buf) default: throw UniffiInternalError.unexpectedOptionalTag } } @@ -1174,8 +3228,8 @@ fileprivate struct FfiConverterOptionString: FfiConverterRustBuffer { #if swift(>=5.8) @_documentation(visibility: private) #endif -fileprivate struct FfiConverterOptionTypeAddress: FfiConverterRustBuffer { - typealias SwiftType = Address? +fileprivate struct FfiConverterOptionSequenceUInt64: FfiConverterRustBuffer { + typealias SwiftType = [UInt64]? public static func write(_ value: SwiftType, into buf: inout [UInt8]) { guard let value = value else { @@ -1183,13 +3237,13 @@ fileprivate struct FfiConverterOptionTypeAddress: FfiConverterRustBuffer { return } writeInt(&buf, Int8(1)) - FfiConverterTypeAddress.write(value, into: &buf) + FfiConverterSequenceUInt64.write(value, into: &buf) } public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> SwiftType { switch try readInt(&buf) as Int8 { case 0: return nil - case 1: return try FfiConverterTypeAddress.read(from: &buf) + case 1: return try FfiConverterSequenceUInt64.read(from: &buf) default: throw UniffiInternalError.unexpectedOptionalTag } } @@ -1198,8 +3252,8 @@ fileprivate struct FfiConverterOptionTypeAddress: FfiConverterRustBuffer { #if swift(>=5.8) @_documentation(visibility: private) #endif -fileprivate struct FfiConverterOptionTypeAssetTransferTransactionFields: FfiConverterRustBuffer { - typealias SwiftType = AssetTransferTransactionFields? +fileprivate struct FfiConverterOptionSequenceString: FfiConverterRustBuffer { + typealias SwiftType = [String]? public static func write(_ value: SwiftType, into buf: inout [UInt8]) { guard let value = value else { @@ -1207,13 +3261,13 @@ fileprivate struct FfiConverterOptionTypeAssetTransferTransactionFields: FfiConv return } writeInt(&buf, Int8(1)) - FfiConverterTypeAssetTransferTransactionFields.write(value, into: &buf) + FfiConverterSequenceString.write(value, into: &buf) } public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> SwiftType { switch try readInt(&buf) as Int8 { case 0: return nil - case 1: return try FfiConverterTypeAssetTransferTransactionFields.read(from: &buf) + case 1: return try FfiConverterSequenceString.read(from: &buf) default: throw UniffiInternalError.unexpectedOptionalTag } } @@ -1222,8 +3276,8 @@ fileprivate struct FfiConverterOptionTypeAssetTransferTransactionFields: FfiConv #if swift(>=5.8) @_documentation(visibility: private) #endif -fileprivate struct FfiConverterOptionTypePaymentTransactionFields: FfiConverterRustBuffer { - typealias SwiftType = PaymentTransactionFields? +fileprivate struct FfiConverterOptionSequenceData: FfiConverterRustBuffer { + typealias SwiftType = [Data]? public static func write(_ value: SwiftType, into buf: inout [UInt8]) { guard let value = value else { @@ -1231,13 +3285,13 @@ fileprivate struct FfiConverterOptionTypePaymentTransactionFields: FfiConverterR return } writeInt(&buf, Int8(1)) - FfiConverterTypePaymentTransactionFields.write(value, into: &buf) + FfiConverterSequenceData.write(value, into: &buf) } public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> SwiftType { switch try readInt(&buf) as Int8 { case 0: return nil - case 1: return try FfiConverterTypePaymentTransactionFields.read(from: &buf) + case 1: return try FfiConverterSequenceData.read(from: &buf) default: throw UniffiInternalError.unexpectedOptionalTag } } @@ -1246,8 +3300,8 @@ fileprivate struct FfiConverterOptionTypePaymentTransactionFields: FfiConverterR #if swift(>=5.8) @_documentation(visibility: private) #endif -fileprivate struct FfiConverterOptionTypeByteBuf: FfiConverterRustBuffer { - typealias SwiftType = ByteBuf? +fileprivate struct FfiConverterOptionSequenceTypeBoxReference: FfiConverterRustBuffer { + typealias SwiftType = [BoxReference]? public static func write(_ value: SwiftType, into buf: inout [UInt8]) { guard let value = value else { @@ -1255,97 +3309,351 @@ fileprivate struct FfiConverterOptionTypeByteBuf: FfiConverterRustBuffer { return } writeInt(&buf, Int8(1)) - FfiConverterTypeByteBuf.write(value, into: &buf) + FfiConverterSequenceTypeBoxReference.write(value, into: &buf) } public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> SwiftType { switch try readInt(&buf) as Int8 { case 0: return nil - case 1: return try FfiConverterTypeByteBuf.read(from: &buf) + case 1: return try FfiConverterSequenceTypeBoxReference.read(from: &buf) default: throw UniffiInternalError.unexpectedOptionalTag } } } +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +fileprivate struct FfiConverterSequenceUInt64: FfiConverterRustBuffer { + typealias SwiftType = [UInt64] -/** - * Typealias from the type name used in the UDL file to the builtin type. This - * is needed because the UDL type name is used in function/method signatures. - */ -public typealias ByteBuf = Data + public static func write(_ value: [UInt64], into buf: inout [UInt8]) { + let len = Int32(value.count) + writeInt(&buf, len) + for item in value { + FfiConverterUInt64.write(item, into: &buf) + } + } + + public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> [UInt64] { + let len: Int32 = try readInt(&buf) + var seq = [UInt64]() + seq.reserveCapacity(Int(len)) + for _ in 0 ..< len { + seq.append(try FfiConverterUInt64.read(from: &buf)) + } + return seq + } +} #if swift(>=5.8) @_documentation(visibility: private) #endif -public struct FfiConverterTypeByteBuf: FfiConverter { - public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> ByteBuf { - return try FfiConverterData.read(from: &buf) +fileprivate struct FfiConverterSequenceString: FfiConverterRustBuffer { + typealias SwiftType = [String] + + public static func write(_ value: [String], into buf: inout [UInt8]) { + let len = Int32(value.count) + writeInt(&buf, len) + for item in value { + FfiConverterString.write(item, into: &buf) + } } - public static func write(_ value: ByteBuf, into buf: inout [UInt8]) { - return FfiConverterData.write(value, into: &buf) + public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> [String] { + let len: Int32 = try readInt(&buf) + var seq = [String]() + seq.reserveCapacity(Int(len)) + for _ in 0 ..< len { + seq.append(try FfiConverterString.read(from: &buf)) + } + return seq } +} + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +fileprivate struct FfiConverterSequenceData: FfiConverterRustBuffer { + typealias SwiftType = [Data] - public static func lift(_ value: RustBuffer) throws -> ByteBuf { - return try FfiConverterData.lift(value) + public static func write(_ value: [Data], into buf: inout [UInt8]) { + let len = Int32(value.count) + writeInt(&buf, len) + for item in value { + FfiConverterData.write(item, into: &buf) + } } - public static func lower(_ value: ByteBuf) -> RustBuffer { - return FfiConverterData.lower(value) + public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> [Data] { + let len: Int32 = try readInt(&buf) + var seq = [Data]() + seq.reserveCapacity(Int(len)) + for _ in 0 ..< len { + seq.append(try FfiConverterData.read(from: &buf)) + } + return seq } } +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +fileprivate struct FfiConverterSequenceTypeBoxReference: FfiConverterRustBuffer { + typealias SwiftType = [BoxReference] + + public static func write(_ value: [BoxReference], into buf: inout [UInt8]) { + let len = Int32(value.count) + writeInt(&buf, len) + for item in value { + FfiConverterTypeBoxReference.write(item, into: &buf) + } + } + + public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> [BoxReference] { + let len: Int32 = try readInt(&buf) + var seq = [BoxReference]() + seq.reserveCapacity(Int(len)) + for _ in 0 ..< len { + seq.append(try FfiConverterTypeBoxReference.read(from: &buf)) + } + return seq + } +} #if swift(>=5.8) @_documentation(visibility: private) #endif -public func FfiConverterTypeByteBuf_lift(_ value: RustBuffer) throws -> ByteBuf { - return try FfiConverterTypeByteBuf.lift(value) +fileprivate struct FfiConverterSequenceTypeMultisigSubsignature: FfiConverterRustBuffer { + typealias SwiftType = [MultisigSubsignature] + + public static func write(_ value: [MultisigSubsignature], into buf: inout [UInt8]) { + let len = Int32(value.count) + writeInt(&buf, len) + for item in value { + FfiConverterTypeMultisigSubsignature.write(item, into: &buf) + } + } + + public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> [MultisigSubsignature] { + let len: Int32 = try readInt(&buf) + var seq = [MultisigSubsignature]() + seq.reserveCapacity(Int(len)) + for _ in 0 ..< len { + seq.append(try FfiConverterTypeMultisigSubsignature.read(from: &buf)) + } + return seq + } } #if swift(>=5.8) @_documentation(visibility: private) #endif -public func FfiConverterTypeByteBuf_lower(_ value: ByteBuf) -> RustBuffer { - return FfiConverterTypeByteBuf.lower(value) +fileprivate struct FfiConverterSequenceTypeSignedTransaction: FfiConverterRustBuffer { + typealias SwiftType = [SignedTransaction] + + public static func write(_ value: [SignedTransaction], into buf: inout [UInt8]) { + let len = Int32(value.count) + writeInt(&buf, len) + for item in value { + FfiConverterTypeSignedTransaction.write(item, into: &buf) + } + } + + public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> [SignedTransaction] { + let len: Int32 = try readInt(&buf) + var seq = [SignedTransaction]() + seq.reserveCapacity(Int(len)) + for _ in 0 ..< len { + seq.append(try FfiConverterTypeSignedTransaction.read(from: &buf)) + } + return seq + } } -public func addressFromPubKey(pubKey: Data)throws -> Address { - return try FfiConverterTypeAddress.lift(try rustCallWithError(FfiConverterTypeAlgoKitTransactError.lift) { - uniffi_algokit_transact_ffi_fn_func_address_from_pub_key( - FfiConverterData.lower(pubKey),$0 +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +fileprivate struct FfiConverterSequenceTypeTransaction: FfiConverterRustBuffer { + typealias SwiftType = [Transaction] + + public static func write(_ value: [Transaction], into buf: inout [UInt8]) { + let len = Int32(value.count) + writeInt(&buf, len) + for item in value { + FfiConverterTypeTransaction.write(item, into: &buf) + } + } + + public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> [Transaction] { + let len: Int32 = try readInt(&buf) + var seq = [Transaction]() + seq.reserveCapacity(Int(len)) + for _ in 0 ..< len { + seq.append(try FfiConverterTypeTransaction.read(from: &buf)) + } + return seq + } +} +/** + * Returns the address of the multisignature account. + * + * # Errors + * /// Returns [`AlgoKitTransactError`] if the multisignature signature is invalid or the address cannot be derived. + */ +public func addressFromMultisigSignature(multisigSignature: MultisigSignature)throws -> String { + return try FfiConverterString.lift(try rustCallWithError(FfiConverterTypeAlgoKitTransactError_lift) { + uniffi_algokit_transact_ffi_fn_func_address_from_multisig_signature( + FfiConverterTypeMultisigSignature_lower(multisigSignature),$0 ) }) } -public func addressFromString(address: String)throws -> Address { - return try FfiConverterTypeAddress.lift(try rustCallWithError(FfiConverterTypeAlgoKitTransactError.lift) { - uniffi_algokit_transact_ffi_fn_func_address_from_string( - FfiConverterString.lower(address),$0 +public func addressFromPublicKey(publicKey: Data)throws -> String { + return try FfiConverterString.lift(try rustCallWithError(FfiConverterTypeAlgoKitTransactError_lift) { + uniffi_algokit_transact_ffi_fn_func_address_from_public_key( + FfiConverterData.lower(publicKey),$0 + ) +}) +} +/** + * Applies a subsignature for a participant to a multisignature signature, replacing any existing signature. + * + * # Errors + * + * Returns [`AlgoKitTransactError`] if the participant address is invalid or not found, or if the signature bytes are invalid. + */ +public func applyMultisigSubsignature(multisigSignature: MultisigSignature, participant: String, subsignature: Data)throws -> MultisigSignature { + return try FfiConverterTypeMultisigSignature_lift(try rustCallWithError(FfiConverterTypeAlgoKitTransactError_lift) { + uniffi_algokit_transact_ffi_fn_func_apply_multisig_subsignature( + FfiConverterTypeMultisigSignature_lower(multisigSignature), + FfiConverterString.lower(participant), + FfiConverterData.lower(subsignature),$0 + ) +}) +} +public func assignFee(transaction: Transaction, feeParams: FeeParams)throws -> Transaction { + return try FfiConverterTypeTransaction_lift(try rustCallWithError(FfiConverterTypeAlgoKitTransactError_lift) { + uniffi_algokit_transact_ffi_fn_func_assign_fee( + FfiConverterTypeTransaction_lower(transaction), + FfiConverterTypeFeeParams_lower(feeParams),$0 + ) +}) +} +public func calculateFee(transaction: Transaction, feeParams: FeeParams)throws -> UInt64 { + return try FfiConverterUInt64.lift(try rustCallWithError(FfiConverterTypeAlgoKitTransactError_lift) { + uniffi_algokit_transact_ffi_fn_func_calculate_fee( + FfiConverterTypeTransaction_lower(transaction), + FfiConverterTypeFeeParams_lower(feeParams),$0 + ) +}) +} +/** + * Decodes a signed transaction. + * + * # Parameters + * * `encoded_signed_transaction` - The MsgPack encoded signed transaction bytes + * + * # Returns + * The decoded SignedTransaction or an error if decoding fails. + */ +public func decodeSignedTransaction(encodedSignedTransaction: Data)throws -> SignedTransaction { + return try FfiConverterTypeSignedTransaction_lift(try rustCallWithError(FfiConverterTypeAlgoKitTransactError_lift) { + uniffi_algokit_transact_ffi_fn_func_decode_signed_transaction( + FfiConverterData.lower(encodedSignedTransaction),$0 ) }) } -public func attachSignature(encodedTx: Data, signature: Data)throws -> Data { - return try FfiConverterData.lift(try rustCallWithError(FfiConverterTypeAlgoKitTransactError.lift) { - uniffi_algokit_transact_ffi_fn_func_attach_signature( - FfiConverterData.lower(encodedTx), - FfiConverterData.lower(signature),$0 +/** + * Decodes a collection of MsgPack bytes into a signed transaction collection. + * + * # Parameters + * * `encoded_signed_transactions` - A collection of MsgPack encoded bytes, each representing a signed transaction. + * + * # Returns + * A collection of decoded signed transactions or an error if decoding fails. + */ +public func decodeSignedTransactions(encodedSignedTransactions: [Data])throws -> [SignedTransaction] { + return try FfiConverterSequenceTypeSignedTransaction.lift(try rustCallWithError(FfiConverterTypeAlgoKitTransactError_lift) { + uniffi_algokit_transact_ffi_fn_func_decode_signed_transactions( + FfiConverterSequenceData.lower(encodedSignedTransactions),$0 ) }) } -public func decodeTransaction(bytes: Data)throws -> Transaction { - return try FfiConverterTypeTransaction.lift(try rustCallWithError(FfiConverterTypeAlgoKitTransactError.lift) { +/** + * Decodes MsgPack bytes into a transaction. + * + * # Parameters + * * `encoded_tx` - MsgPack encoded bytes representing a transaction. + * + * # Returns + * A decoded transaction or an error if decoding fails. + */ +public func decodeTransaction(encodedTx: Data)throws -> Transaction { + return try FfiConverterTypeTransaction_lift(try rustCallWithError(FfiConverterTypeAlgoKitTransactError_lift) { uniffi_algokit_transact_ffi_fn_func_decode_transaction( - FfiConverterData.lower(bytes),$0 + FfiConverterData.lower(encodedTx),$0 + ) +}) +} +/** + * Decodes a collection of MsgPack bytes into a transaction collection. + * + * # Parameters + * * `encoded_txs` - A collection of MsgPack encoded bytes, each representing a transaction. + * + * # Returns + * A collection of decoded transactions or an error if decoding fails. + */ +public func decodeTransactions(encodedTxs: [Data])throws -> [Transaction] { + return try FfiConverterSequenceTypeTransaction.lift(try rustCallWithError(FfiConverterTypeAlgoKitTransactError_lift) { + uniffi_algokit_transact_ffi_fn_func_decode_transactions( + FfiConverterSequenceData.lower(encodedTxs),$0 + ) +}) +} +/** + * Encode a signed transaction to MsgPack for sending on the network. + * + * This method performs canonical encoding. No domain separation prefix is applicable. + * + * # Parameters + * * `signed_transaction` - The signed transaction to encode + * + * # Returns + * The MsgPack encoded bytes or an error if encoding fails. + */ +public func encodeSignedTransaction(signedTransaction: SignedTransaction)throws -> Data { + return try FfiConverterData.lift(try rustCallWithError(FfiConverterTypeAlgoKitTransactError_lift) { + uniffi_algokit_transact_ffi_fn_func_encode_signed_transaction( + FfiConverterTypeSignedTransaction_lower(signedTransaction),$0 + ) +}) +} +/** + * Encode signed transactions to MsgPack for sending on the network. + * + * This method performs canonical encoding. No domain separation prefix is applicable. + * + * # Parameters + * * `signed_transactions` - A collection of signed transactions to encode + * + * # Returns + * A collection of MsgPack encoded bytes or an error if encoding fails. + */ +public func encodeSignedTransactions(signedTransactions: [SignedTransaction])throws -> [Data] { + return try FfiConverterSequenceData.lift(try rustCallWithError(FfiConverterTypeAlgoKitTransactError_lift) { + uniffi_algokit_transact_ffi_fn_func_encode_signed_transactions( + FfiConverterSequenceTypeSignedTransaction.lower(signedTransactions),$0 ) }) } /** * Encode the transaction with the domain separation (e.g. "TX") prefix */ -public func encodeTransaction(tx: Transaction)throws -> Data { - return try FfiConverterData.lift(try rustCallWithError(FfiConverterTypeAlgoKitTransactError.lift) { +public func encodeTransaction(transaction: Transaction)throws -> Data { + return try FfiConverterData.lift(try rustCallWithError(FfiConverterTypeAlgoKitTransactError_lift) { uniffi_algokit_transact_ffi_fn_func_encode_transaction( - FfiConverterTypeTransaction.lower(tx),$0 + FfiConverterTypeTransaction_lower(transaction),$0 ) }) } @@ -1353,10 +3661,26 @@ public func encodeTransaction(tx: Transaction)throws -> Data { * Encode the transaction without the domain separation (e.g. "TX") prefix * This is useful for encoding the transaction for signing with tools that automatically add "TX" prefix to the transaction bytes. */ -public func encodeTransactionRaw(tx: Transaction)throws -> Data { - return try FfiConverterData.lift(try rustCallWithError(FfiConverterTypeAlgoKitTransactError.lift) { +public func encodeTransactionRaw(transaction: Transaction)throws -> Data { + return try FfiConverterData.lift(try rustCallWithError(FfiConverterTypeAlgoKitTransactError_lift) { uniffi_algokit_transact_ffi_fn_func_encode_transaction_raw( - FfiConverterTypeTransaction.lower(tx),$0 + FfiConverterTypeTransaction_lower(transaction),$0 + ) +}) +} +/** + * Encode transactions to MsgPack with the domain separation (e.g. "TX") prefix. + * + * # Parameters + * * `transactions` - A collection of transactions to encode + * + * # Returns + * A collection of MsgPack encoded bytes or an error if encoding fails. + */ +public func encodeTransactions(transactions: [Transaction])throws -> [Data] { + return try FfiConverterSequenceData.lift(try rustCallWithError(FfiConverterTypeAlgoKitTransactError_lift) { + uniffi_algokit_transact_ffi_fn_func_encode_transactions( + FfiConverterSequenceTypeTransaction.lower(transactions),$0 ) }) } @@ -1364,17 +3688,17 @@ public func encodeTransactionRaw(tx: Transaction)throws -> Data { * Return the size of the transaction in bytes as if it was already signed and encoded. * This is useful for estimating the fee for the transaction. */ -public func estimateTransactionSize(transaction: Transaction)throws -> UInt64 { - return try FfiConverterUInt64.lift(try rustCallWithError(FfiConverterTypeAlgoKitTransactError.lift) { +public func estimateTransactionSize(transaction: Transaction)throws -> UInt64 { + return try FfiConverterUInt64.lift(try rustCallWithError(FfiConverterTypeAlgoKitTransactError_lift) { uniffi_algokit_transact_ffi_fn_func_estimate_transaction_size( - FfiConverterTypeTransaction.lower(transaction),$0 + FfiConverterTypeTransaction_lower(transaction),$0 ) }) } -public func getAlgorandConstant(constant: AlgorandConstant) -> UInt64 { +public func getAlgorandConstant(constant: AlgorandConstant) -> UInt64 { return try! FfiConverterUInt64.lift(try! rustCall() { uniffi_algokit_transact_ffi_fn_func_get_algorand_constant( - FfiConverterTypeAlgorandConstant.lower(constant),$0 + FfiConverterTypeAlgorandConstant_lower(constant),$0 ) }) } @@ -1382,30 +3706,91 @@ public func getAlgorandConstant(constant: AlgorandConstant) -> UInt64 { * Get the transaction type from the encoded transaction. * This is particularly useful when decoding a transaction that has an unknown type */ -public func getEncodedTransactionType(bytes: Data)throws -> TransactionType { - return try FfiConverterTypeTransactionType.lift(try rustCallWithError(FfiConverterTypeAlgoKitTransactError.lift) { +public func getEncodedTransactionType(encodedTransaction: Data)throws -> TransactionType { + return try FfiConverterTypeTransactionType_lift(try rustCallWithError(FfiConverterTypeAlgoKitTransactError_lift) { uniffi_algokit_transact_ffi_fn_func_get_encoded_transaction_type( - FfiConverterData.lower(bytes),$0 + FfiConverterData.lower(encodedTransaction),$0 ) }) } /** * Get the base32 transaction ID string for a transaction. */ -public func getTransactionId(tx: Transaction)throws -> String { - return try FfiConverterString.lift(try rustCallWithError(FfiConverterTypeAlgoKitTransactError.lift) { +public func getTransactionId(transaction: Transaction)throws -> String { + return try FfiConverterString.lift(try rustCallWithError(FfiConverterTypeAlgoKitTransactError_lift) { uniffi_algokit_transact_ffi_fn_func_get_transaction_id( - FfiConverterTypeTransaction.lower(tx),$0 + FfiConverterTypeTransaction_lower(transaction),$0 ) }) } /** * Get the raw 32-byte transaction ID for a transaction. */ -public func getTransactionIdRaw(tx: Transaction)throws -> Data { - return try FfiConverterData.lift(try rustCallWithError(FfiConverterTypeAlgoKitTransactError.lift) { +public func getTransactionIdRaw(transaction: Transaction)throws -> Data { + return try FfiConverterData.lift(try rustCallWithError(FfiConverterTypeAlgoKitTransactError_lift) { uniffi_algokit_transact_ffi_fn_func_get_transaction_id_raw( - FfiConverterTypeTransaction.lower(tx),$0 + FfiConverterTypeTransaction_lower(transaction),$0 + ) +}) +} +/** + * Groups a collection of transactions by calculating and assigning the group to each transaction. + */ +public func groupTransactions(transactions: [Transaction])throws -> [Transaction] { + return try FfiConverterSequenceTypeTransaction.lift(try rustCallWithError(FfiConverterTypeAlgoKitTransactError_lift) { + uniffi_algokit_transact_ffi_fn_func_group_transactions( + FfiConverterSequenceTypeTransaction.lower(transactions),$0 + ) +}) +} +/** + * Merges two multisignature signatures, replacing signatures in the first with those from the second where present. + * + * # Errors + * + * Returns [`AlgoKitTransactError`] if the multisignature parameters or participants do not match. + */ +public func mergeMultisignatures(multisigSignatureA: MultisigSignature, multisigSignatureB: MultisigSignature)throws -> MultisigSignature { + return try FfiConverterTypeMultisigSignature_lift(try rustCallWithError(FfiConverterTypeAlgoKitTransactError_lift) { + uniffi_algokit_transact_ffi_fn_func_merge_multisignatures( + FfiConverterTypeMultisigSignature_lower(multisigSignatureA), + FfiConverterTypeMultisigSignature_lower(multisigSignatureB),$0 + ) +}) +} +/** + * Creates an empty multisignature signature from a list of participant addresses. + * + * # Errors + * + * Returns [`AlgoKitTransactError`] if any address is invalid or the multisignature parameters are invalid. + */ +public func newMultisigSignature(version: UInt8, threshold: UInt8, participants: [String])throws -> MultisigSignature { + return try FfiConverterTypeMultisigSignature_lift(try rustCallWithError(FfiConverterTypeAlgoKitTransactError_lift) { + uniffi_algokit_transact_ffi_fn_func_new_multisig_signature( + FfiConverterUInt8.lower(version), + FfiConverterUInt8.lower(threshold), + FfiConverterSequenceString.lower(participants),$0 + ) +}) +} +/** + * Returns the list of participant addresses from a multisignature signature. + * + * # Errors + * Returns [`AlgoKitTransactError`] if the multisignature is invalid. + */ +public func participantsFromMultisigSignature(multisigSignature: MultisigSignature)throws -> [String] { + return try FfiConverterSequenceString.lift(try rustCallWithError(FfiConverterTypeAlgoKitTransactError_lift) { + uniffi_algokit_transact_ffi_fn_func_participants_from_multisig_signature( + FfiConverterTypeMultisigSignature_lower(multisigSignature),$0 + ) +}) +} +public func publicKeyFromAddress(address: String)throws -> Data { + return try FfiConverterData.lift(try rustCallWithError(FfiConverterTypeAlgoKitTransactError_lift) { + uniffi_algokit_transact_ffi_fn_func_public_key_from_address( + FfiConverterString.lower(address),$0 ) }) } @@ -1419,28 +3804,52 @@ private enum InitializationResult { // the code inside is only computed once. private let initializationResult: InitializationResult = { // Get the bindings contract version from our ComponentInterface - let bindings_contract_version = 26 + let bindings_contract_version = 29 // Get the scaffolding contract version by calling the into the dylib let scaffolding_contract_version = ffi_algokit_transact_ffi_uniffi_contract_version() if bindings_contract_version != scaffolding_contract_version { return InitializationResult.contractVersionMismatch } - if (uniffi_algokit_transact_ffi_checksum_func_address_from_pub_key() != 65205) { + if (uniffi_algokit_transact_ffi_checksum_func_address_from_multisig_signature() != 51026) { + return InitializationResult.apiChecksumMismatch + } + if (uniffi_algokit_transact_ffi_checksum_func_address_from_public_key() != 10716) { + return InitializationResult.apiChecksumMismatch + } + if (uniffi_algokit_transact_ffi_checksum_func_apply_multisig_subsignature() != 42634) { + return InitializationResult.apiChecksumMismatch + } + if (uniffi_algokit_transact_ffi_checksum_func_assign_fee() != 35003) { + return InitializationResult.apiChecksumMismatch + } + if (uniffi_algokit_transact_ffi_checksum_func_calculate_fee() != 7537) { + return InitializationResult.apiChecksumMismatch + } + if (uniffi_algokit_transact_ffi_checksum_func_decode_signed_transaction() != 43569) { return InitializationResult.apiChecksumMismatch } - if (uniffi_algokit_transact_ffi_checksum_func_address_from_string() != 56499) { + if (uniffi_algokit_transact_ffi_checksum_func_decode_signed_transactions() != 62888) { return InitializationResult.apiChecksumMismatch } - if (uniffi_algokit_transact_ffi_checksum_func_attach_signature() != 7369) { + if (uniffi_algokit_transact_ffi_checksum_func_decode_transaction() != 56405) { return InitializationResult.apiChecksumMismatch } - if (uniffi_algokit_transact_ffi_checksum_func_decode_transaction() != 38127) { + if (uniffi_algokit_transact_ffi_checksum_func_decode_transactions() != 26956) { return InitializationResult.apiChecksumMismatch } - if (uniffi_algokit_transact_ffi_checksum_func_encode_transaction() != 62809) { + if (uniffi_algokit_transact_ffi_checksum_func_encode_signed_transaction() != 47064) { return InitializationResult.apiChecksumMismatch } - if (uniffi_algokit_transact_ffi_checksum_func_encode_transaction_raw() != 1774) { + if (uniffi_algokit_transact_ffi_checksum_func_encode_signed_transactions() != 1956) { + return InitializationResult.apiChecksumMismatch + } + if (uniffi_algokit_transact_ffi_checksum_func_encode_transaction() != 11275) { + return InitializationResult.apiChecksumMismatch + } + if (uniffi_algokit_transact_ffi_checksum_func_encode_transaction_raw() != 384) { + return InitializationResult.apiChecksumMismatch + } + if (uniffi_algokit_transact_ffi_checksum_func_encode_transactions() != 59611) { return InitializationResult.apiChecksumMismatch } if (uniffi_algokit_transact_ffi_checksum_func_estimate_transaction_size() != 60858) { @@ -1449,20 +3858,37 @@ private let initializationResult: InitializationResult = { if (uniffi_algokit_transact_ffi_checksum_func_get_algorand_constant() != 49400) { return InitializationResult.apiChecksumMismatch } - if (uniffi_algokit_transact_ffi_checksum_func_get_encoded_transaction_type() != 9866) { + if (uniffi_algokit_transact_ffi_checksum_func_get_encoded_transaction_type() != 42551) { + return InitializationResult.apiChecksumMismatch + } + if (uniffi_algokit_transact_ffi_checksum_func_get_transaction_id() != 10957) { + return InitializationResult.apiChecksumMismatch + } + if (uniffi_algokit_transact_ffi_checksum_func_get_transaction_id_raw() != 48975) { + return InitializationResult.apiChecksumMismatch + } + if (uniffi_algokit_transact_ffi_checksum_func_group_transactions() != 18193) { + return InitializationResult.apiChecksumMismatch + } + if (uniffi_algokit_transact_ffi_checksum_func_merge_multisignatures() != 58688) { + return InitializationResult.apiChecksumMismatch + } + if (uniffi_algokit_transact_ffi_checksum_func_new_multisig_signature() != 29314) { return InitializationResult.apiChecksumMismatch } - if (uniffi_algokit_transact_ffi_checksum_func_get_transaction_id() != 20463) { + if (uniffi_algokit_transact_ffi_checksum_func_participants_from_multisig_signature() != 25095) { return InitializationResult.apiChecksumMismatch } - if (uniffi_algokit_transact_ffi_checksum_func_get_transaction_id_raw() != 37098) { + if (uniffi_algokit_transact_ffi_checksum_func_public_key_from_address() != 58152) { return InitializationResult.apiChecksumMismatch } return InitializationResult.ok }() -private func uniffiEnsureInitialized() { +// Make the ensure init function public so that other modules which have external type references to +// our types can call it. +public func uniffiEnsureAlgokitTransactFfiInitialized() { switch initializationResult { case .ok: break diff --git a/packages/swift/AlgoKitTransact/Frameworks/algokit_transact.xcframework/ios-arm64/Headers/algokit_transactFFI.h b/packages/swift/AlgoKitTransact/Frameworks/algokit_transact.xcframework/ios-arm64/Headers/algokit_transactFFI.h index 5f1185624..d6dd1e874 100644 --- a/packages/swift/AlgoKitTransact/Frameworks/algokit_transact.xcframework/ios-arm64/Headers/algokit_transactFFI.h +++ b/packages/swift/AlgoKitTransact/Frameworks/algokit_transact.xcframework/ios-arm64/Headers/algokit_transactFFI.h @@ -251,34 +251,74 @@ typedef void (*UniffiForeignFutureCompleteVoid)(uint64_t, UniffiForeignFutureStr ); #endif -#ifndef UNIFFI_FFIDEF_UNIFFI_ALGOKIT_TRANSACT_FFI_FN_FUNC_ADDRESS_FROM_PUB_KEY -#define UNIFFI_FFIDEF_UNIFFI_ALGOKIT_TRANSACT_FFI_FN_FUNC_ADDRESS_FROM_PUB_KEY -RustBuffer uniffi_algokit_transact_ffi_fn_func_address_from_pub_key(RustBuffer pub_key, RustCallStatus *_Nonnull out_status +#ifndef UNIFFI_FFIDEF_UNIFFI_ALGOKIT_TRANSACT_FFI_FN_FUNC_ADDRESS_FROM_MULTISIG_SIGNATURE +#define UNIFFI_FFIDEF_UNIFFI_ALGOKIT_TRANSACT_FFI_FN_FUNC_ADDRESS_FROM_MULTISIG_SIGNATURE +RustBuffer uniffi_algokit_transact_ffi_fn_func_address_from_multisig_signature(RustBuffer multisig_signature, RustCallStatus *_Nonnull out_status ); #endif -#ifndef UNIFFI_FFIDEF_UNIFFI_ALGOKIT_TRANSACT_FFI_FN_FUNC_ADDRESS_FROM_STRING -#define UNIFFI_FFIDEF_UNIFFI_ALGOKIT_TRANSACT_FFI_FN_FUNC_ADDRESS_FROM_STRING -RustBuffer uniffi_algokit_transact_ffi_fn_func_address_from_string(RustBuffer address, RustCallStatus *_Nonnull out_status +#ifndef UNIFFI_FFIDEF_UNIFFI_ALGOKIT_TRANSACT_FFI_FN_FUNC_ADDRESS_FROM_PUBLIC_KEY +#define UNIFFI_FFIDEF_UNIFFI_ALGOKIT_TRANSACT_FFI_FN_FUNC_ADDRESS_FROM_PUBLIC_KEY +RustBuffer uniffi_algokit_transact_ffi_fn_func_address_from_public_key(RustBuffer public_key, RustCallStatus *_Nonnull out_status ); #endif -#ifndef UNIFFI_FFIDEF_UNIFFI_ALGOKIT_TRANSACT_FFI_FN_FUNC_ATTACH_SIGNATURE -#define UNIFFI_FFIDEF_UNIFFI_ALGOKIT_TRANSACT_FFI_FN_FUNC_ATTACH_SIGNATURE -RustBuffer uniffi_algokit_transact_ffi_fn_func_attach_signature(RustBuffer encoded_tx, RustBuffer signature, RustCallStatus *_Nonnull out_status +#ifndef UNIFFI_FFIDEF_UNIFFI_ALGOKIT_TRANSACT_FFI_FN_FUNC_APPLY_MULTISIG_SUBSIGNATURE +#define UNIFFI_FFIDEF_UNIFFI_ALGOKIT_TRANSACT_FFI_FN_FUNC_APPLY_MULTISIG_SUBSIGNATURE +RustBuffer uniffi_algokit_transact_ffi_fn_func_apply_multisig_subsignature(RustBuffer multisig_signature, RustBuffer participant, RustBuffer subsignature, RustCallStatus *_Nonnull out_status +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_ALGOKIT_TRANSACT_FFI_FN_FUNC_ASSIGN_FEE +#define UNIFFI_FFIDEF_UNIFFI_ALGOKIT_TRANSACT_FFI_FN_FUNC_ASSIGN_FEE +RustBuffer uniffi_algokit_transact_ffi_fn_func_assign_fee(RustBuffer transaction, RustBuffer fee_params, RustCallStatus *_Nonnull out_status +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_ALGOKIT_TRANSACT_FFI_FN_FUNC_CALCULATE_FEE +#define UNIFFI_FFIDEF_UNIFFI_ALGOKIT_TRANSACT_FFI_FN_FUNC_CALCULATE_FEE +uint64_t uniffi_algokit_transact_ffi_fn_func_calculate_fee(RustBuffer transaction, RustBuffer fee_params, RustCallStatus *_Nonnull out_status +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_ALGOKIT_TRANSACT_FFI_FN_FUNC_DECODE_SIGNED_TRANSACTION +#define UNIFFI_FFIDEF_UNIFFI_ALGOKIT_TRANSACT_FFI_FN_FUNC_DECODE_SIGNED_TRANSACTION +RustBuffer uniffi_algokit_transact_ffi_fn_func_decode_signed_transaction(RustBuffer encoded_signed_transaction, RustCallStatus *_Nonnull out_status +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_ALGOKIT_TRANSACT_FFI_FN_FUNC_DECODE_SIGNED_TRANSACTIONS +#define UNIFFI_FFIDEF_UNIFFI_ALGOKIT_TRANSACT_FFI_FN_FUNC_DECODE_SIGNED_TRANSACTIONS +RustBuffer uniffi_algokit_transact_ffi_fn_func_decode_signed_transactions(RustBuffer encoded_signed_transactions, RustCallStatus *_Nonnull out_status ); #endif #ifndef UNIFFI_FFIDEF_UNIFFI_ALGOKIT_TRANSACT_FFI_FN_FUNC_DECODE_TRANSACTION #define UNIFFI_FFIDEF_UNIFFI_ALGOKIT_TRANSACT_FFI_FN_FUNC_DECODE_TRANSACTION -RustBuffer uniffi_algokit_transact_ffi_fn_func_decode_transaction(RustBuffer bytes, RustCallStatus *_Nonnull out_status +RustBuffer uniffi_algokit_transact_ffi_fn_func_decode_transaction(RustBuffer encoded_tx, RustCallStatus *_Nonnull out_status +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_ALGOKIT_TRANSACT_FFI_FN_FUNC_DECODE_TRANSACTIONS +#define UNIFFI_FFIDEF_UNIFFI_ALGOKIT_TRANSACT_FFI_FN_FUNC_DECODE_TRANSACTIONS +RustBuffer uniffi_algokit_transact_ffi_fn_func_decode_transactions(RustBuffer encoded_txs, RustCallStatus *_Nonnull out_status +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_ALGOKIT_TRANSACT_FFI_FN_FUNC_ENCODE_SIGNED_TRANSACTION +#define UNIFFI_FFIDEF_UNIFFI_ALGOKIT_TRANSACT_FFI_FN_FUNC_ENCODE_SIGNED_TRANSACTION +RustBuffer uniffi_algokit_transact_ffi_fn_func_encode_signed_transaction(RustBuffer signed_transaction, RustCallStatus *_Nonnull out_status +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_ALGOKIT_TRANSACT_FFI_FN_FUNC_ENCODE_SIGNED_TRANSACTIONS +#define UNIFFI_FFIDEF_UNIFFI_ALGOKIT_TRANSACT_FFI_FN_FUNC_ENCODE_SIGNED_TRANSACTIONS +RustBuffer uniffi_algokit_transact_ffi_fn_func_encode_signed_transactions(RustBuffer signed_transactions, RustCallStatus *_Nonnull out_status ); #endif #ifndef UNIFFI_FFIDEF_UNIFFI_ALGOKIT_TRANSACT_FFI_FN_FUNC_ENCODE_TRANSACTION #define UNIFFI_FFIDEF_UNIFFI_ALGOKIT_TRANSACT_FFI_FN_FUNC_ENCODE_TRANSACTION -RustBuffer uniffi_algokit_transact_ffi_fn_func_encode_transaction(RustBuffer tx, RustCallStatus *_Nonnull out_status +RustBuffer uniffi_algokit_transact_ffi_fn_func_encode_transaction(RustBuffer transaction, RustCallStatus *_Nonnull out_status ); #endif #ifndef UNIFFI_FFIDEF_UNIFFI_ALGOKIT_TRANSACT_FFI_FN_FUNC_ENCODE_TRANSACTION_RAW #define UNIFFI_FFIDEF_UNIFFI_ALGOKIT_TRANSACT_FFI_FN_FUNC_ENCODE_TRANSACTION_RAW -RustBuffer uniffi_algokit_transact_ffi_fn_func_encode_transaction_raw(RustBuffer tx, RustCallStatus *_Nonnull out_status +RustBuffer uniffi_algokit_transact_ffi_fn_func_encode_transaction_raw(RustBuffer transaction, RustCallStatus *_Nonnull out_status +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_ALGOKIT_TRANSACT_FFI_FN_FUNC_ENCODE_TRANSACTIONS +#define UNIFFI_FFIDEF_UNIFFI_ALGOKIT_TRANSACT_FFI_FN_FUNC_ENCODE_TRANSACTIONS +RustBuffer uniffi_algokit_transact_ffi_fn_func_encode_transactions(RustBuffer transactions, RustCallStatus *_Nonnull out_status ); #endif #ifndef UNIFFI_FFIDEF_UNIFFI_ALGOKIT_TRANSACT_FFI_FN_FUNC_ESTIMATE_TRANSACTION_SIZE @@ -293,17 +333,42 @@ uint64_t uniffi_algokit_transact_ffi_fn_func_get_algorand_constant(RustBuffer co #endif #ifndef UNIFFI_FFIDEF_UNIFFI_ALGOKIT_TRANSACT_FFI_FN_FUNC_GET_ENCODED_TRANSACTION_TYPE #define UNIFFI_FFIDEF_UNIFFI_ALGOKIT_TRANSACT_FFI_FN_FUNC_GET_ENCODED_TRANSACTION_TYPE -RustBuffer uniffi_algokit_transact_ffi_fn_func_get_encoded_transaction_type(RustBuffer bytes, RustCallStatus *_Nonnull out_status +RustBuffer uniffi_algokit_transact_ffi_fn_func_get_encoded_transaction_type(RustBuffer encoded_transaction, RustCallStatus *_Nonnull out_status ); #endif #ifndef UNIFFI_FFIDEF_UNIFFI_ALGOKIT_TRANSACT_FFI_FN_FUNC_GET_TRANSACTION_ID #define UNIFFI_FFIDEF_UNIFFI_ALGOKIT_TRANSACT_FFI_FN_FUNC_GET_TRANSACTION_ID -RustBuffer uniffi_algokit_transact_ffi_fn_func_get_transaction_id(RustBuffer tx, RustCallStatus *_Nonnull out_status +RustBuffer uniffi_algokit_transact_ffi_fn_func_get_transaction_id(RustBuffer transaction, RustCallStatus *_Nonnull out_status ); #endif #ifndef UNIFFI_FFIDEF_UNIFFI_ALGOKIT_TRANSACT_FFI_FN_FUNC_GET_TRANSACTION_ID_RAW #define UNIFFI_FFIDEF_UNIFFI_ALGOKIT_TRANSACT_FFI_FN_FUNC_GET_TRANSACTION_ID_RAW -RustBuffer uniffi_algokit_transact_ffi_fn_func_get_transaction_id_raw(RustBuffer tx, RustCallStatus *_Nonnull out_status +RustBuffer uniffi_algokit_transact_ffi_fn_func_get_transaction_id_raw(RustBuffer transaction, RustCallStatus *_Nonnull out_status +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_ALGOKIT_TRANSACT_FFI_FN_FUNC_GROUP_TRANSACTIONS +#define UNIFFI_FFIDEF_UNIFFI_ALGOKIT_TRANSACT_FFI_FN_FUNC_GROUP_TRANSACTIONS +RustBuffer uniffi_algokit_transact_ffi_fn_func_group_transactions(RustBuffer transactions, RustCallStatus *_Nonnull out_status +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_ALGOKIT_TRANSACT_FFI_FN_FUNC_MERGE_MULTISIGNATURES +#define UNIFFI_FFIDEF_UNIFFI_ALGOKIT_TRANSACT_FFI_FN_FUNC_MERGE_MULTISIGNATURES +RustBuffer uniffi_algokit_transact_ffi_fn_func_merge_multisignatures(RustBuffer multisig_signature_a, RustBuffer multisig_signature_b, RustCallStatus *_Nonnull out_status +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_ALGOKIT_TRANSACT_FFI_FN_FUNC_NEW_MULTISIG_SIGNATURE +#define UNIFFI_FFIDEF_UNIFFI_ALGOKIT_TRANSACT_FFI_FN_FUNC_NEW_MULTISIG_SIGNATURE +RustBuffer uniffi_algokit_transact_ffi_fn_func_new_multisig_signature(uint8_t version, uint8_t threshold, RustBuffer participants, RustCallStatus *_Nonnull out_status +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_ALGOKIT_TRANSACT_FFI_FN_FUNC_PARTICIPANTS_FROM_MULTISIG_SIGNATURE +#define UNIFFI_FFIDEF_UNIFFI_ALGOKIT_TRANSACT_FFI_FN_FUNC_PARTICIPANTS_FROM_MULTISIG_SIGNATURE +RustBuffer uniffi_algokit_transact_ffi_fn_func_participants_from_multisig_signature(RustBuffer multisig_signature, RustCallStatus *_Nonnull out_status +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_ALGOKIT_TRANSACT_FFI_FN_FUNC_PUBLIC_KEY_FROM_ADDRESS +#define UNIFFI_FFIDEF_UNIFFI_ALGOKIT_TRANSACT_FFI_FN_FUNC_PUBLIC_KEY_FROM_ADDRESS +RustBuffer uniffi_algokit_transact_ffi_fn_func_public_key_from_address(RustBuffer address, RustCallStatus *_Nonnull out_status ); #endif #ifndef UNIFFI_FFIDEF_FFI_ALGOKIT_TRANSACT_FFI_RUSTBUFFER_ALLOC @@ -586,21 +651,45 @@ void ffi_algokit_transact_ffi_rust_future_free_void(uint64_t handle void ffi_algokit_transact_ffi_rust_future_complete_void(uint64_t handle, RustCallStatus *_Nonnull out_status ); #endif -#ifndef UNIFFI_FFIDEF_UNIFFI_ALGOKIT_TRANSACT_FFI_CHECKSUM_FUNC_ADDRESS_FROM_PUB_KEY -#define UNIFFI_FFIDEF_UNIFFI_ALGOKIT_TRANSACT_FFI_CHECKSUM_FUNC_ADDRESS_FROM_PUB_KEY -uint16_t uniffi_algokit_transact_ffi_checksum_func_address_from_pub_key(void +#ifndef UNIFFI_FFIDEF_UNIFFI_ALGOKIT_TRANSACT_FFI_CHECKSUM_FUNC_ADDRESS_FROM_MULTISIG_SIGNATURE +#define UNIFFI_FFIDEF_UNIFFI_ALGOKIT_TRANSACT_FFI_CHECKSUM_FUNC_ADDRESS_FROM_MULTISIG_SIGNATURE +uint16_t uniffi_algokit_transact_ffi_checksum_func_address_from_multisig_signature(void + +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_ALGOKIT_TRANSACT_FFI_CHECKSUM_FUNC_ADDRESS_FROM_PUBLIC_KEY +#define UNIFFI_FFIDEF_UNIFFI_ALGOKIT_TRANSACT_FFI_CHECKSUM_FUNC_ADDRESS_FROM_PUBLIC_KEY +uint16_t uniffi_algokit_transact_ffi_checksum_func_address_from_public_key(void ); #endif -#ifndef UNIFFI_FFIDEF_UNIFFI_ALGOKIT_TRANSACT_FFI_CHECKSUM_FUNC_ADDRESS_FROM_STRING -#define UNIFFI_FFIDEF_UNIFFI_ALGOKIT_TRANSACT_FFI_CHECKSUM_FUNC_ADDRESS_FROM_STRING -uint16_t uniffi_algokit_transact_ffi_checksum_func_address_from_string(void +#ifndef UNIFFI_FFIDEF_UNIFFI_ALGOKIT_TRANSACT_FFI_CHECKSUM_FUNC_APPLY_MULTISIG_SUBSIGNATURE +#define UNIFFI_FFIDEF_UNIFFI_ALGOKIT_TRANSACT_FFI_CHECKSUM_FUNC_APPLY_MULTISIG_SUBSIGNATURE +uint16_t uniffi_algokit_transact_ffi_checksum_func_apply_multisig_subsignature(void ); #endif -#ifndef UNIFFI_FFIDEF_UNIFFI_ALGOKIT_TRANSACT_FFI_CHECKSUM_FUNC_ATTACH_SIGNATURE -#define UNIFFI_FFIDEF_UNIFFI_ALGOKIT_TRANSACT_FFI_CHECKSUM_FUNC_ATTACH_SIGNATURE -uint16_t uniffi_algokit_transact_ffi_checksum_func_attach_signature(void +#ifndef UNIFFI_FFIDEF_UNIFFI_ALGOKIT_TRANSACT_FFI_CHECKSUM_FUNC_ASSIGN_FEE +#define UNIFFI_FFIDEF_UNIFFI_ALGOKIT_TRANSACT_FFI_CHECKSUM_FUNC_ASSIGN_FEE +uint16_t uniffi_algokit_transact_ffi_checksum_func_assign_fee(void + +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_ALGOKIT_TRANSACT_FFI_CHECKSUM_FUNC_CALCULATE_FEE +#define UNIFFI_FFIDEF_UNIFFI_ALGOKIT_TRANSACT_FFI_CHECKSUM_FUNC_CALCULATE_FEE +uint16_t uniffi_algokit_transact_ffi_checksum_func_calculate_fee(void + +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_ALGOKIT_TRANSACT_FFI_CHECKSUM_FUNC_DECODE_SIGNED_TRANSACTION +#define UNIFFI_FFIDEF_UNIFFI_ALGOKIT_TRANSACT_FFI_CHECKSUM_FUNC_DECODE_SIGNED_TRANSACTION +uint16_t uniffi_algokit_transact_ffi_checksum_func_decode_signed_transaction(void + +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_ALGOKIT_TRANSACT_FFI_CHECKSUM_FUNC_DECODE_SIGNED_TRANSACTIONS +#define UNIFFI_FFIDEF_UNIFFI_ALGOKIT_TRANSACT_FFI_CHECKSUM_FUNC_DECODE_SIGNED_TRANSACTIONS +uint16_t uniffi_algokit_transact_ffi_checksum_func_decode_signed_transactions(void ); #endif @@ -608,6 +697,24 @@ uint16_t uniffi_algokit_transact_ffi_checksum_func_attach_signature(void #define UNIFFI_FFIDEF_UNIFFI_ALGOKIT_TRANSACT_FFI_CHECKSUM_FUNC_DECODE_TRANSACTION uint16_t uniffi_algokit_transact_ffi_checksum_func_decode_transaction(void +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_ALGOKIT_TRANSACT_FFI_CHECKSUM_FUNC_DECODE_TRANSACTIONS +#define UNIFFI_FFIDEF_UNIFFI_ALGOKIT_TRANSACT_FFI_CHECKSUM_FUNC_DECODE_TRANSACTIONS +uint16_t uniffi_algokit_transact_ffi_checksum_func_decode_transactions(void + +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_ALGOKIT_TRANSACT_FFI_CHECKSUM_FUNC_ENCODE_SIGNED_TRANSACTION +#define UNIFFI_FFIDEF_UNIFFI_ALGOKIT_TRANSACT_FFI_CHECKSUM_FUNC_ENCODE_SIGNED_TRANSACTION +uint16_t uniffi_algokit_transact_ffi_checksum_func_encode_signed_transaction(void + +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_ALGOKIT_TRANSACT_FFI_CHECKSUM_FUNC_ENCODE_SIGNED_TRANSACTIONS +#define UNIFFI_FFIDEF_UNIFFI_ALGOKIT_TRANSACT_FFI_CHECKSUM_FUNC_ENCODE_SIGNED_TRANSACTIONS +uint16_t uniffi_algokit_transact_ffi_checksum_func_encode_signed_transactions(void + ); #endif #ifndef UNIFFI_FFIDEF_UNIFFI_ALGOKIT_TRANSACT_FFI_CHECKSUM_FUNC_ENCODE_TRANSACTION @@ -620,6 +727,12 @@ uint16_t uniffi_algokit_transact_ffi_checksum_func_encode_transaction(void #define UNIFFI_FFIDEF_UNIFFI_ALGOKIT_TRANSACT_FFI_CHECKSUM_FUNC_ENCODE_TRANSACTION_RAW uint16_t uniffi_algokit_transact_ffi_checksum_func_encode_transaction_raw(void +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_ALGOKIT_TRANSACT_FFI_CHECKSUM_FUNC_ENCODE_TRANSACTIONS +#define UNIFFI_FFIDEF_UNIFFI_ALGOKIT_TRANSACT_FFI_CHECKSUM_FUNC_ENCODE_TRANSACTIONS +uint16_t uniffi_algokit_transact_ffi_checksum_func_encode_transactions(void + ); #endif #ifndef UNIFFI_FFIDEF_UNIFFI_ALGOKIT_TRANSACT_FFI_CHECKSUM_FUNC_ESTIMATE_TRANSACTION_SIZE @@ -650,6 +763,36 @@ uint16_t uniffi_algokit_transact_ffi_checksum_func_get_transaction_id(void #define UNIFFI_FFIDEF_UNIFFI_ALGOKIT_TRANSACT_FFI_CHECKSUM_FUNC_GET_TRANSACTION_ID_RAW uint16_t uniffi_algokit_transact_ffi_checksum_func_get_transaction_id_raw(void +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_ALGOKIT_TRANSACT_FFI_CHECKSUM_FUNC_GROUP_TRANSACTIONS +#define UNIFFI_FFIDEF_UNIFFI_ALGOKIT_TRANSACT_FFI_CHECKSUM_FUNC_GROUP_TRANSACTIONS +uint16_t uniffi_algokit_transact_ffi_checksum_func_group_transactions(void + +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_ALGOKIT_TRANSACT_FFI_CHECKSUM_FUNC_MERGE_MULTISIGNATURES +#define UNIFFI_FFIDEF_UNIFFI_ALGOKIT_TRANSACT_FFI_CHECKSUM_FUNC_MERGE_MULTISIGNATURES +uint16_t uniffi_algokit_transact_ffi_checksum_func_merge_multisignatures(void + +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_ALGOKIT_TRANSACT_FFI_CHECKSUM_FUNC_NEW_MULTISIG_SIGNATURE +#define UNIFFI_FFIDEF_UNIFFI_ALGOKIT_TRANSACT_FFI_CHECKSUM_FUNC_NEW_MULTISIG_SIGNATURE +uint16_t uniffi_algokit_transact_ffi_checksum_func_new_multisig_signature(void + +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_ALGOKIT_TRANSACT_FFI_CHECKSUM_FUNC_PARTICIPANTS_FROM_MULTISIG_SIGNATURE +#define UNIFFI_FFIDEF_UNIFFI_ALGOKIT_TRANSACT_FFI_CHECKSUM_FUNC_PARTICIPANTS_FROM_MULTISIG_SIGNATURE +uint16_t uniffi_algokit_transact_ffi_checksum_func_participants_from_multisig_signature(void + +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_ALGOKIT_TRANSACT_FFI_CHECKSUM_FUNC_PUBLIC_KEY_FROM_ADDRESS +#define UNIFFI_FFIDEF_UNIFFI_ALGOKIT_TRANSACT_FFI_CHECKSUM_FUNC_PUBLIC_KEY_FROM_ADDRESS +uint16_t uniffi_algokit_transact_ffi_checksum_func_public_key_from_address(void + ); #endif #ifndef UNIFFI_FFIDEF_FFI_ALGOKIT_TRANSACT_FFI_UNIFFI_CONTRACT_VERSION diff --git a/packages/swift/AlgoKitTransact/Frameworks/algokit_transact.xcframework/ios-arm64/Headers/module.modulemap b/packages/swift/AlgoKitTransact/Frameworks/algokit_transact.xcframework/ios-arm64/Headers/module.modulemap index 5c45883d7..861b066ff 100644 --- a/packages/swift/AlgoKitTransact/Frameworks/algokit_transact.xcframework/ios-arm64/Headers/module.modulemap +++ b/packages/swift/AlgoKitTransact/Frameworks/algokit_transact.xcframework/ios-arm64/Headers/module.modulemap @@ -1,4 +1,7 @@ module algokit_transactFFI { header "algokit_transactFFI.h" export * + use "Darwin" + use "_Builtin_stdbool" + use "_Builtin_stdint" } \ No newline at end of file diff --git a/packages/swift/AlgoKitTransact/Frameworks/algokit_transact.xcframework/ios-arm64/libalgokit_transact_ffi.a b/packages/swift/AlgoKitTransact/Frameworks/algokit_transact.xcframework/ios-arm64/libalgokit_transact_ffi.a index 7fabe6a14..9bdd6c958 100644 Binary files a/packages/swift/AlgoKitTransact/Frameworks/algokit_transact.xcframework/ios-arm64/libalgokit_transact_ffi.a and b/packages/swift/AlgoKitTransact/Frameworks/algokit_transact.xcframework/ios-arm64/libalgokit_transact_ffi.a differ diff --git a/packages/swift/AlgoKitTransact/Frameworks/algokit_transact.xcframework/ios-arm64_x86_64-maccatalyst/Headers/algokit_transact.swift b/packages/swift/AlgoKitTransact/Frameworks/algokit_transact.xcframework/ios-arm64_x86_64-maccatalyst/Headers/algokit_transact.swift index 8fe29c207..92e86dfc8 100644 --- a/packages/swift/AlgoKitTransact/Frameworks/algokit_transact.xcframework/ios-arm64_x86_64-maccatalyst/Headers/algokit_transact.swift +++ b/packages/swift/AlgoKitTransact/Frameworks/algokit_transact.xcframework/ios-arm64_x86_64-maccatalyst/Headers/algokit_transact.swift @@ -281,7 +281,7 @@ private func makeRustCall( _ callback: (UnsafeMutablePointer) -> T, errorHandler: ((RustBuffer) throws -> E)? ) throws -> T { - uniffiEnsureInitialized() + uniffiEnsureAlgokitTransactFfiInitialized() var callStatus = RustCallStatus.init() let returnedVal = callback(&callStatus) try uniffiCheckCallStatus(callStatus: callStatus, errorHandler: errorHandler) @@ -352,9 +352,10 @@ private func uniffiTraitInterfaceCallWithError( callStatus.pointee.errorBuf = FfiConverterString.lower(String(describing: error)) } } -fileprivate class UniffiHandleMap { - private var map: [UInt64: T] = [:] +fileprivate final class UniffiHandleMap: @unchecked Sendable { + // All mutation happens with this lock held, which is why we implement @unchecked Sendable. private let lock = NSLock() + private var map: [UInt64: T] = [:] private var currentHandle: UInt64 = 1 func insert(obj: T) -> UInt64 { @@ -396,6 +397,38 @@ fileprivate class UniffiHandleMap { // Public interface members begin here. +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +fileprivate struct FfiConverterUInt8: FfiConverterPrimitive { + typealias FfiType = UInt8 + typealias SwiftType = UInt8 + + public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> UInt8 { + return try lift(readInt(&buf)) + } + + public static func write(_ value: UInt8, into buf: inout [UInt8]) { + writeInt(&buf, lower(value)) + } +} + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +fileprivate struct FfiConverterUInt32: FfiConverterPrimitive { + typealias FfiType = UInt32 + typealias SwiftType = UInt32 + + public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> UInt32 { + return try lift(readInt(&buf)) + } + + public static func write(_ value: SwiftType, into buf: inout [UInt8]) { + writeInt(&buf, lower(value)) + } +} + #if swift(>=5.8) @_documentation(visibility: private) #endif @@ -412,6 +445,30 @@ fileprivate struct FfiConverterUInt64: FfiConverterPrimitive { } } +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +fileprivate struct FfiConverterBool : FfiConverter { + typealias FfiType = Int8 + typealias SwiftType = Bool + + public static func lift(_ value: Int8) throws -> Bool { + return value != 0 + } + + public static func lower(_ value: Bool) -> Int8 { + return value ? 1 : 0 + } + + public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> Bool { + return try lift(readInt(&buf)) + } + + public static func write(_ value: Bool, into buf: inout [UInt8]) { + writeInt(&buf, lower(value)) + } +} + #if swift(>=5.8) @_documentation(visibility: private) #endif @@ -472,53 +529,269 @@ fileprivate struct FfiConverterData: FfiConverterRustBuffer { } -public struct Address { - public var address: String - public var pubKey: ByteBuf +/** + * Represents an app call transaction that interacts with Algorand Smart Contracts. + * + * App call transactions are used to create, update, delete, opt-in to, + * close out of, or clear state from Algorand applications (smart contracts). + */ +public struct AppCallTransactionFields { + /** + * ID of the app being called. + * + * Set this to 0 to indicate an app creation call. + */ + public var appId: UInt64 + /** + * Defines what additional actions occur with the transaction. + */ + public var onComplete: OnApplicationComplete + /** + * Logic executed for every app call transaction, except when + * on-completion is set to "clear". + * + * Approval programs may reject the transaction. + * Only required for app creation and update transactions. + */ + public var approvalProgram: Data? + /** + * Logic executed for app call transactions with on-completion set to "clear". + * + * Clear state programs cannot reject the transaction. + * Only required for app creation and update transactions. + */ + public var clearStateProgram: Data? + /** + * Holds the maximum number of global state values. + * + * Only required for app creation transactions. + * This cannot be changed after creation. + */ + public var globalStateSchema: StateSchema? + /** + * Holds the maximum number of local state values. + * + * Only required for app creation transactions. + * This cannot be changed after creation. + */ + public var localStateSchema: StateSchema? + /** + * Number of additional pages allocated to the app's approval + * and clear state programs. + * + * Each extra program page is 2048 bytes. The sum of approval program + * and clear state program may not exceed 2048*(1+extra_program_pages) bytes. + * Currently, the maximum value is 3. + * This cannot be changed after creation. + */ + public var extraProgramPages: UInt32? + /** + * Transaction specific arguments available in the app's + * approval program and clear state program. + */ + public var args: [Data]? + /** + * List of accounts in addition to the sender that may be accessed + * from the app's approval program and clear state program. + */ + public var accountReferences: [String]? + /** + * List of apps in addition to the current app that may be called + * from the app's approval program and clear state program. + */ + public var appReferences: [UInt64]? + /** + * Lists the assets whose parameters may be accessed by this app's + * approval program and clear state program. + * + * The access is read-only. + */ + public var assetReferences: [UInt64]? + /** + * The boxes that should be made available for the runtime of the program. + */ + public var boxReferences: [BoxReference]? // Default memberwise initializers are never public by default, so we // declare one manually. - public init(address: String, pubKey: ByteBuf) { - self.address = address - self.pubKey = pubKey - } -} - + public init( + /** + * ID of the app being called. + * + * Set this to 0 to indicate an app creation call. + */appId: UInt64, + /** + * Defines what additional actions occur with the transaction. + */onComplete: OnApplicationComplete, + /** + * Logic executed for every app call transaction, except when + * on-completion is set to "clear". + * + * Approval programs may reject the transaction. + * Only required for app creation and update transactions. + */approvalProgram: Data? = nil, + /** + * Logic executed for app call transactions with on-completion set to "clear". + * + * Clear state programs cannot reject the transaction. + * Only required for app creation and update transactions. + */clearStateProgram: Data? = nil, + /** + * Holds the maximum number of global state values. + * + * Only required for app creation transactions. + * This cannot be changed after creation. + */globalStateSchema: StateSchema? = nil, + /** + * Holds the maximum number of local state values. + * + * Only required for app creation transactions. + * This cannot be changed after creation. + */localStateSchema: StateSchema? = nil, + /** + * Number of additional pages allocated to the app's approval + * and clear state programs. + * + * Each extra program page is 2048 bytes. The sum of approval program + * and clear state program may not exceed 2048*(1+extra_program_pages) bytes. + * Currently, the maximum value is 3. + * This cannot be changed after creation. + */extraProgramPages: UInt32? = nil, + /** + * Transaction specific arguments available in the app's + * approval program and clear state program. + */args: [Data]? = nil, + /** + * List of accounts in addition to the sender that may be accessed + * from the app's approval program and clear state program. + */accountReferences: [String]? = nil, + /** + * List of apps in addition to the current app that may be called + * from the app's approval program and clear state program. + */appReferences: [UInt64]? = nil, + /** + * Lists the assets whose parameters may be accessed by this app's + * approval program and clear state program. + * + * The access is read-only. + */assetReferences: [UInt64]? = nil, + /** + * The boxes that should be made available for the runtime of the program. + */boxReferences: [BoxReference]? = nil) { + self.appId = appId + self.onComplete = onComplete + self.approvalProgram = approvalProgram + self.clearStateProgram = clearStateProgram + self.globalStateSchema = globalStateSchema + self.localStateSchema = localStateSchema + self.extraProgramPages = extraProgramPages + self.args = args + self.accountReferences = accountReferences + self.appReferences = appReferences + self.assetReferences = assetReferences + self.boxReferences = boxReferences + } +} + +#if compiler(>=6) +extension AppCallTransactionFields: Sendable {} +#endif -extension Address: Equatable, Hashable { - public static func ==(lhs: Address, rhs: Address) -> Bool { - if lhs.address != rhs.address { +extension AppCallTransactionFields: Equatable, Hashable { + public static func ==(lhs: AppCallTransactionFields, rhs: AppCallTransactionFields) -> Bool { + if lhs.appId != rhs.appId { return false } - if lhs.pubKey != rhs.pubKey { + if lhs.onComplete != rhs.onComplete { + return false + } + if lhs.approvalProgram != rhs.approvalProgram { + return false + } + if lhs.clearStateProgram != rhs.clearStateProgram { + return false + } + if lhs.globalStateSchema != rhs.globalStateSchema { + return false + } + if lhs.localStateSchema != rhs.localStateSchema { + return false + } + if lhs.extraProgramPages != rhs.extraProgramPages { + return false + } + if lhs.args != rhs.args { + return false + } + if lhs.accountReferences != rhs.accountReferences { + return false + } + if lhs.appReferences != rhs.appReferences { + return false + } + if lhs.assetReferences != rhs.assetReferences { + return false + } + if lhs.boxReferences != rhs.boxReferences { return false } return true } public func hash(into hasher: inout Hasher) { - hasher.combine(address) - hasher.combine(pubKey) + hasher.combine(appId) + hasher.combine(onComplete) + hasher.combine(approvalProgram) + hasher.combine(clearStateProgram) + hasher.combine(globalStateSchema) + hasher.combine(localStateSchema) + hasher.combine(extraProgramPages) + hasher.combine(args) + hasher.combine(accountReferences) + hasher.combine(appReferences) + hasher.combine(assetReferences) + hasher.combine(boxReferences) } } + #if swift(>=5.8) @_documentation(visibility: private) #endif -public struct FfiConverterTypeAddress: FfiConverterRustBuffer { - public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> Address { +public struct FfiConverterTypeAppCallTransactionFields: FfiConverterRustBuffer { + public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> AppCallTransactionFields { return - try Address( - address: FfiConverterString.read(from: &buf), - pubKey: FfiConverterTypeByteBuf.read(from: &buf) + try AppCallTransactionFields( + appId: FfiConverterUInt64.read(from: &buf), + onComplete: FfiConverterTypeOnApplicationComplete.read(from: &buf), + approvalProgram: FfiConverterOptionData.read(from: &buf), + clearStateProgram: FfiConverterOptionData.read(from: &buf), + globalStateSchema: FfiConverterOptionTypeStateSchema.read(from: &buf), + localStateSchema: FfiConverterOptionTypeStateSchema.read(from: &buf), + extraProgramPages: FfiConverterOptionUInt32.read(from: &buf), + args: FfiConverterOptionSequenceData.read(from: &buf), + accountReferences: FfiConverterOptionSequenceString.read(from: &buf), + appReferences: FfiConverterOptionSequenceUInt64.read(from: &buf), + assetReferences: FfiConverterOptionSequenceUInt64.read(from: &buf), + boxReferences: FfiConverterOptionSequenceTypeBoxReference.read(from: &buf) ) } - public static func write(_ value: Address, into buf: inout [UInt8]) { - FfiConverterString.write(value.address, into: &buf) - FfiConverterTypeByteBuf.write(value.pubKey, into: &buf) + public static func write(_ value: AppCallTransactionFields, into buf: inout [UInt8]) { + FfiConverterUInt64.write(value.appId, into: &buf) + FfiConverterTypeOnApplicationComplete.write(value.onComplete, into: &buf) + FfiConverterOptionData.write(value.approvalProgram, into: &buf) + FfiConverterOptionData.write(value.clearStateProgram, into: &buf) + FfiConverterOptionTypeStateSchema.write(value.globalStateSchema, into: &buf) + FfiConverterOptionTypeStateSchema.write(value.localStateSchema, into: &buf) + FfiConverterOptionUInt32.write(value.extraProgramPages, into: &buf) + FfiConverterOptionSequenceData.write(value.args, into: &buf) + FfiConverterOptionSequenceString.write(value.accountReferences, into: &buf) + FfiConverterOptionSequenceUInt64.write(value.appReferences, into: &buf) + FfiConverterOptionSequenceUInt64.write(value.assetReferences, into: &buf) + FfiConverterOptionSequenceTypeBoxReference.write(value.boxReferences, into: &buf) } } @@ -526,53 +799,306 @@ public struct FfiConverterTypeAddress: FfiConverterRustBuffer { #if swift(>=5.8) @_documentation(visibility: private) #endif -public func FfiConverterTypeAddress_lift(_ buf: RustBuffer) throws -> Address { - return try FfiConverterTypeAddress.lift(buf) +public func FfiConverterTypeAppCallTransactionFields_lift(_ buf: RustBuffer) throws -> AppCallTransactionFields { + return try FfiConverterTypeAppCallTransactionFields.lift(buf) } #if swift(>=5.8) @_documentation(visibility: private) #endif -public func FfiConverterTypeAddress_lower(_ value: Address) -> RustBuffer { - return FfiConverterTypeAddress.lower(value) +public func FfiConverterTypeAppCallTransactionFields_lower(_ value: AppCallTransactionFields) -> RustBuffer { + return FfiConverterTypeAppCallTransactionFields.lower(value) } -public struct AssetTransferTransactionFields { +/** + * Parameters to define an asset config transaction. + * + * For asset creation, the asset ID field must be 0. + * For asset reconfiguration, the asset ID field must be set. Only fields manager, reserve, freeze, and clawback can be set. + * For asset destroy, the asset ID field must be set, all other fields must not be set. + * + * **Note:** The manager, reserve, freeze, and clawback addresses + * are immutably empty if they are not set. If manager is not set then + * all fields are immutable from that point forward. + */ +public struct AssetConfigTransactionFields { + /** + * ID of the asset to operate on. + * + * For asset creation, this must be 0. + * For asset reconfiguration this is the ID of the existing asset to be reconfigured, + * For asset destroy this is the ID of the existing asset to be destroyed. + */ public var assetId: UInt64 - public var amount: UInt64 - public var receiver: Address - public var assetSender: Address? - public var closeRemainderTo: Address? + /** + * The total amount of the smallest divisible (decimal) unit to create. + * + * Required when creating a new asset. + * For example, if creating a asset with 2 decimals and wanting a total supply of 100 units, this value should be 10000. + * + * This field can only be specified upon asset creation. + */ + public var total: UInt64? + /** + * The amount of decimal places the asset should have. + * + * If unspecified then the asset will be in whole units (i.e. `0`). + * * If 0, the asset is not divisible; + * * If 1, the base unit of the asset is in tenths; + * * If 2, the base unit of the asset is in hundredths; + * * If 3, the base unit of the asset is in thousandths; + * + * and so on up to 19 decimal places. + * + * This field can only be specified upon asset creation. + */ + public var decimals: UInt32? + /** + * Whether the asset is frozen by default for all accounts. + * Defaults to `false`. + * + * If `true` then for anyone apart from the creator to hold the + * asset it needs to be unfrozen per account using an asset freeze + * transaction from the `freeze` account, which must be set on creation. + * + * This field can only be specified upon asset creation. + */ + public var defaultFrozen: Bool? + /** + * The optional name of the asset. + * + * Max size is 32 bytes. + * + * This field can only be specified upon asset creation. + */ + public var assetName: String? + /** + * The optional name of the unit of this asset (e.g. ticker name). + * + * Max size is 8 bytes. + * + * This field can only be specified upon asset creation. + */ + public var unitName: String? + /** + * Specifies an optional URL where more information about the asset can be retrieved (e.g. metadata). + * + * Max size is 96 bytes. + * + * This field can only be specified upon asset creation. + */ + public var url: String? + /** + * 32-byte hash of some metadata that is relevant to your asset and/or asset holders. + * + * The format of this metadata is up to the application. + * + * This field can only be specified upon asset creation. + */ + public var metadataHash: Data? + /** + * The address of the optional account that can manage the configuration of the asset and destroy it. + * + * The fields it can change are `manager`, `reserve`, `clawback`, and `freeze`. + * + * If not set or set to the Zero address the asset becomes permanently immutable. + */ + public var manager: String? + /** + * The address of the optional account that holds the reserve (uncirculated supply) units of the asset. + * + * This address has no specific authority in the protocol itself and is informational only. + * + * Some standards like [ARC-19](https://github.com/algorandfoundation/ARCs/blob/main/ARCs/arc-0019.md) + * rely on this field to hold meaningful data. + * + * It can be used in the case where you want to signal to holders of your asset that the uncirculated units + * of the asset reside in an account that is different from the default creator account. + * + * If not set or set to the Zero address is permanently empty. + */ + public var reserve: String? + /** + * The address of the optional account that can be used to freeze or unfreeze holdings of this asset for any account. + * + * If empty, freezing is not permitted. + * + * If not set or set to the Zero address is permanently empty. + */ + public var freeze: String? + /** + * The address of the optional account that can clawback holdings of this asset from any account. + * + * **This field should be used with caution** as the clawback account has the ability to **unconditionally take assets from any account**. + * + * If empty, clawback is not permitted. + * + * If not set or set to the Zero address is permanently empty. + */ + public var clawback: String? // Default memberwise initializers are never public by default, so we // declare one manually. - public init(assetId: UInt64, amount: UInt64, receiver: Address, assetSender: Address? = nil, closeRemainderTo: Address? = nil) { + public init( + /** + * ID of the asset to operate on. + * + * For asset creation, this must be 0. + * For asset reconfiguration this is the ID of the existing asset to be reconfigured, + * For asset destroy this is the ID of the existing asset to be destroyed. + */assetId: UInt64, + /** + * The total amount of the smallest divisible (decimal) unit to create. + * + * Required when creating a new asset. + * For example, if creating a asset with 2 decimals and wanting a total supply of 100 units, this value should be 10000. + * + * This field can only be specified upon asset creation. + */total: UInt64? = nil, + /** + * The amount of decimal places the asset should have. + * + * If unspecified then the asset will be in whole units (i.e. `0`). + * * If 0, the asset is not divisible; + * * If 1, the base unit of the asset is in tenths; + * * If 2, the base unit of the asset is in hundredths; + * * If 3, the base unit of the asset is in thousandths; + * + * and so on up to 19 decimal places. + * + * This field can only be specified upon asset creation. + */decimals: UInt32? = nil, + /** + * Whether the asset is frozen by default for all accounts. + * Defaults to `false`. + * + * If `true` then for anyone apart from the creator to hold the + * asset it needs to be unfrozen per account using an asset freeze + * transaction from the `freeze` account, which must be set on creation. + * + * This field can only be specified upon asset creation. + */defaultFrozen: Bool? = nil, + /** + * The optional name of the asset. + * + * Max size is 32 bytes. + * + * This field can only be specified upon asset creation. + */assetName: String? = nil, + /** + * The optional name of the unit of this asset (e.g. ticker name). + * + * Max size is 8 bytes. + * + * This field can only be specified upon asset creation. + */unitName: String? = nil, + /** + * Specifies an optional URL where more information about the asset can be retrieved (e.g. metadata). + * + * Max size is 96 bytes. + * + * This field can only be specified upon asset creation. + */url: String? = nil, + /** + * 32-byte hash of some metadata that is relevant to your asset and/or asset holders. + * + * The format of this metadata is up to the application. + * + * This field can only be specified upon asset creation. + */metadataHash: Data? = nil, + /** + * The address of the optional account that can manage the configuration of the asset and destroy it. + * + * The fields it can change are `manager`, `reserve`, `clawback`, and `freeze`. + * + * If not set or set to the Zero address the asset becomes permanently immutable. + */manager: String? = nil, + /** + * The address of the optional account that holds the reserve (uncirculated supply) units of the asset. + * + * This address has no specific authority in the protocol itself and is informational only. + * + * Some standards like [ARC-19](https://github.com/algorandfoundation/ARCs/blob/main/ARCs/arc-0019.md) + * rely on this field to hold meaningful data. + * + * It can be used in the case where you want to signal to holders of your asset that the uncirculated units + * of the asset reside in an account that is different from the default creator account. + * + * If not set or set to the Zero address is permanently empty. + */reserve: String? = nil, + /** + * The address of the optional account that can be used to freeze or unfreeze holdings of this asset for any account. + * + * If empty, freezing is not permitted. + * + * If not set or set to the Zero address is permanently empty. + */freeze: String? = nil, + /** + * The address of the optional account that can clawback holdings of this asset from any account. + * + * **This field should be used with caution** as the clawback account has the ability to **unconditionally take assets from any account**. + * + * If empty, clawback is not permitted. + * + * If not set or set to the Zero address is permanently empty. + */clawback: String? = nil) { self.assetId = assetId - self.amount = amount - self.receiver = receiver - self.assetSender = assetSender - self.closeRemainderTo = closeRemainderTo - } -} - + self.total = total + self.decimals = decimals + self.defaultFrozen = defaultFrozen + self.assetName = assetName + self.unitName = unitName + self.url = url + self.metadataHash = metadataHash + self.manager = manager + self.reserve = reserve + self.freeze = freeze + self.clawback = clawback + } +} + +#if compiler(>=6) +extension AssetConfigTransactionFields: Sendable {} +#endif -extension AssetTransferTransactionFields: Equatable, Hashable { - public static func ==(lhs: AssetTransferTransactionFields, rhs: AssetTransferTransactionFields) -> Bool { +extension AssetConfigTransactionFields: Equatable, Hashable { + public static func ==(lhs: AssetConfigTransactionFields, rhs: AssetConfigTransactionFields) -> Bool { if lhs.assetId != rhs.assetId { return false } - if lhs.amount != rhs.amount { + if lhs.total != rhs.total { return false } - if lhs.receiver != rhs.receiver { + if lhs.decimals != rhs.decimals { return false } - if lhs.assetSender != rhs.assetSender { + if lhs.defaultFrozen != rhs.defaultFrozen { return false } - if lhs.closeRemainderTo != rhs.closeRemainderTo { + if lhs.assetName != rhs.assetName { + return false + } + if lhs.unitName != rhs.unitName { + return false + } + if lhs.url != rhs.url { + return false + } + if lhs.metadataHash != rhs.metadataHash { + return false + } + if lhs.manager != rhs.manager { + return false + } + if lhs.reserve != rhs.reserve { + return false + } + if lhs.freeze != rhs.freeze { + return false + } + if lhs.clawback != rhs.clawback { return false } return true @@ -580,35 +1106,57 @@ extension AssetTransferTransactionFields: Equatable, Hashable { public func hash(into hasher: inout Hasher) { hasher.combine(assetId) - hasher.combine(amount) - hasher.combine(receiver) - hasher.combine(assetSender) - hasher.combine(closeRemainderTo) + hasher.combine(total) + hasher.combine(decimals) + hasher.combine(defaultFrozen) + hasher.combine(assetName) + hasher.combine(unitName) + hasher.combine(url) + hasher.combine(metadataHash) + hasher.combine(manager) + hasher.combine(reserve) + hasher.combine(freeze) + hasher.combine(clawback) } } + #if swift(>=5.8) @_documentation(visibility: private) #endif -public struct FfiConverterTypeAssetTransferTransactionFields: FfiConverterRustBuffer { - public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> AssetTransferTransactionFields { +public struct FfiConverterTypeAssetConfigTransactionFields: FfiConverterRustBuffer { + public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> AssetConfigTransactionFields { return - try AssetTransferTransactionFields( + try AssetConfigTransactionFields( assetId: FfiConverterUInt64.read(from: &buf), - amount: FfiConverterUInt64.read(from: &buf), - receiver: FfiConverterTypeAddress.read(from: &buf), - assetSender: FfiConverterOptionTypeAddress.read(from: &buf), - closeRemainderTo: FfiConverterOptionTypeAddress.read(from: &buf) + total: FfiConverterOptionUInt64.read(from: &buf), + decimals: FfiConverterOptionUInt32.read(from: &buf), + defaultFrozen: FfiConverterOptionBool.read(from: &buf), + assetName: FfiConverterOptionString.read(from: &buf), + unitName: FfiConverterOptionString.read(from: &buf), + url: FfiConverterOptionString.read(from: &buf), + metadataHash: FfiConverterOptionData.read(from: &buf), + manager: FfiConverterOptionString.read(from: &buf), + reserve: FfiConverterOptionString.read(from: &buf), + freeze: FfiConverterOptionString.read(from: &buf), + clawback: FfiConverterOptionString.read(from: &buf) ) } - public static func write(_ value: AssetTransferTransactionFields, into buf: inout [UInt8]) { + public static func write(_ value: AssetConfigTransactionFields, into buf: inout [UInt8]) { FfiConverterUInt64.write(value.assetId, into: &buf) - FfiConverterUInt64.write(value.amount, into: &buf) - FfiConverterTypeAddress.write(value.receiver, into: &buf) - FfiConverterOptionTypeAddress.write(value.assetSender, into: &buf) - FfiConverterOptionTypeAddress.write(value.closeRemainderTo, into: &buf) + FfiConverterOptionUInt64.write(value.total, into: &buf) + FfiConverterOptionUInt32.write(value.decimals, into: &buf) + FfiConverterOptionBool.write(value.defaultFrozen, into: &buf) + FfiConverterOptionString.write(value.assetName, into: &buf) + FfiConverterOptionString.write(value.unitName, into: &buf) + FfiConverterOptionString.write(value.url, into: &buf) + FfiConverterOptionData.write(value.metadataHash, into: &buf) + FfiConverterOptionString.write(value.manager, into: &buf) + FfiConverterOptionString.write(value.reserve, into: &buf) + FfiConverterOptionString.write(value.freeze, into: &buf) + FfiConverterOptionString.write(value.clawback, into: &buf) } } @@ -616,73 +1164,107 @@ public struct FfiConverterTypeAssetTransferTransactionFields: FfiConverterRustBu #if swift(>=5.8) @_documentation(visibility: private) #endif -public func FfiConverterTypeAssetTransferTransactionFields_lift(_ buf: RustBuffer) throws -> AssetTransferTransactionFields { - return try FfiConverterTypeAssetTransferTransactionFields.lift(buf) +public func FfiConverterTypeAssetConfigTransactionFields_lift(_ buf: RustBuffer) throws -> AssetConfigTransactionFields { + return try FfiConverterTypeAssetConfigTransactionFields.lift(buf) } #if swift(>=5.8) @_documentation(visibility: private) #endif -public func FfiConverterTypeAssetTransferTransactionFields_lower(_ value: AssetTransferTransactionFields) -> RustBuffer { - return FfiConverterTypeAssetTransferTransactionFields.lower(value) +public func FfiConverterTypeAssetConfigTransactionFields_lower(_ value: AssetConfigTransactionFields) -> RustBuffer { + return FfiConverterTypeAssetConfigTransactionFields.lower(value) } -public struct PaymentTransactionFields { - public var receiver: Address - public var amount: UInt64 - public var closeRemainderTo: Address? +/** + * Represents an asset freeze transaction that freezes or unfreezes asset holdings. + * + * Asset freeze transactions are used by the asset freeze account to control + * whether a specific account can transfer a particular asset. + */ +public struct AssetFreezeTransactionFields { + /** + * The ID of the asset being frozen/unfrozen. + */ + public var assetId: UInt64 + /** + * The target account whose asset holdings will be affected. + */ + public var freezeTarget: String + /** + * The new freeze status. + * + * `true` to freeze the asset holdings (prevent transfers), + * `false` to unfreeze the asset holdings (allow transfers). + */ + public var frozen: Bool // Default memberwise initializers are never public by default, so we // declare one manually. - public init(receiver: Address, amount: UInt64, closeRemainderTo: Address? = nil) { - self.receiver = receiver - self.amount = amount - self.closeRemainderTo = closeRemainderTo + public init( + /** + * The ID of the asset being frozen/unfrozen. + */assetId: UInt64, + /** + * The target account whose asset holdings will be affected. + */freezeTarget: String, + /** + * The new freeze status. + * + * `true` to freeze the asset holdings (prevent transfers), + * `false` to unfreeze the asset holdings (allow transfers). + */frozen: Bool) { + self.assetId = assetId + self.freezeTarget = freezeTarget + self.frozen = frozen } } +#if compiler(>=6) +extension AssetFreezeTransactionFields: Sendable {} +#endif -extension PaymentTransactionFields: Equatable, Hashable { - public static func ==(lhs: PaymentTransactionFields, rhs: PaymentTransactionFields) -> Bool { - if lhs.receiver != rhs.receiver { +extension AssetFreezeTransactionFields: Equatable, Hashable { + public static func ==(lhs: AssetFreezeTransactionFields, rhs: AssetFreezeTransactionFields) -> Bool { + if lhs.assetId != rhs.assetId { return false } - if lhs.amount != rhs.amount { + if lhs.freezeTarget != rhs.freezeTarget { return false } - if lhs.closeRemainderTo != rhs.closeRemainderTo { + if lhs.frozen != rhs.frozen { return false } return true } public func hash(into hasher: inout Hasher) { - hasher.combine(receiver) - hasher.combine(amount) - hasher.combine(closeRemainderTo) + hasher.combine(assetId) + hasher.combine(freezeTarget) + hasher.combine(frozen) } } + #if swift(>=5.8) @_documentation(visibility: private) #endif -public struct FfiConverterTypePaymentTransactionFields: FfiConverterRustBuffer { - public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> PaymentTransactionFields { +public struct FfiConverterTypeAssetFreezeTransactionFields: FfiConverterRustBuffer { + public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> AssetFreezeTransactionFields { return - try PaymentTransactionFields( - receiver: FfiConverterTypeAddress.read(from: &buf), - amount: FfiConverterUInt64.read(from: &buf), - closeRemainderTo: FfiConverterOptionTypeAddress.read(from: &buf) + try AssetFreezeTransactionFields( + assetId: FfiConverterUInt64.read(from: &buf), + freezeTarget: FfiConverterString.read(from: &buf), + frozen: FfiConverterBool.read(from: &buf) ) } - public static func write(_ value: PaymentTransactionFields, into buf: inout [UInt8]) { - FfiConverterTypeAddress.write(value.receiver, into: &buf) - FfiConverterUInt64.write(value.amount, into: &buf) - FfiConverterOptionTypeAddress.write(value.closeRemainderTo, into: &buf) + public static func write(_ value: AssetFreezeTransactionFields, into buf: inout [UInt8]) { + FfiConverterUInt64.write(value.assetId, into: &buf) + FfiConverterString.write(value.freezeTarget, into: &buf) + FfiConverterBool.write(value.frozen, into: &buf) } } @@ -690,38 +1272,993 @@ public struct FfiConverterTypePaymentTransactionFields: FfiConverterRustBuffer { #if swift(>=5.8) @_documentation(visibility: private) #endif -public func FfiConverterTypePaymentTransactionFields_lift(_ buf: RustBuffer) throws -> PaymentTransactionFields { - return try FfiConverterTypePaymentTransactionFields.lift(buf) +public func FfiConverterTypeAssetFreezeTransactionFields_lift(_ buf: RustBuffer) throws -> AssetFreezeTransactionFields { + return try FfiConverterTypeAssetFreezeTransactionFields.lift(buf) } #if swift(>=5.8) @_documentation(visibility: private) #endif -public func FfiConverterTypePaymentTransactionFields_lower(_ value: PaymentTransactionFields) -> RustBuffer { - return FfiConverterTypePaymentTransactionFields.lower(value) +public func FfiConverterTypeAssetFreezeTransactionFields_lower(_ value: AssetFreezeTransactionFields) -> RustBuffer { + return FfiConverterTypeAssetFreezeTransactionFields.lower(value) } -public struct Transaction { - /** - * The type of transaction - */ - public var transactionType: TransactionType - /** - * The sender of the transaction - */ - public var sender: Address - public var fee: UInt64 - public var firstValid: UInt64 - public var lastValid: UInt64 - public var genesisHash: ByteBuf? - public var genesisId: String? - public var note: ByteBuf? - public var rekeyTo: Address? - public var lease: ByteBuf? - public var group: ByteBuf? - public var payment: PaymentTransactionFields? - public var assetTransfer: AssetTransferTransactionFields? +public struct AssetTransferTransactionFields { + public var assetId: UInt64 + public var amount: UInt64 + public var receiver: String + public var assetSender: String? + public var closeRemainderTo: String? + + // Default memberwise initializers are never public by default, so we + // declare one manually. + public init(assetId: UInt64, amount: UInt64, receiver: String, assetSender: String? = nil, closeRemainderTo: String? = nil) { + self.assetId = assetId + self.amount = amount + self.receiver = receiver + self.assetSender = assetSender + self.closeRemainderTo = closeRemainderTo + } +} + +#if compiler(>=6) +extension AssetTransferTransactionFields: Sendable {} +#endif + + +extension AssetTransferTransactionFields: Equatable, Hashable { + public static func ==(lhs: AssetTransferTransactionFields, rhs: AssetTransferTransactionFields) -> Bool { + if lhs.assetId != rhs.assetId { + return false + } + if lhs.amount != rhs.amount { + return false + } + if lhs.receiver != rhs.receiver { + return false + } + if lhs.assetSender != rhs.assetSender { + return false + } + if lhs.closeRemainderTo != rhs.closeRemainderTo { + return false + } + return true + } + + public func hash(into hasher: inout Hasher) { + hasher.combine(assetId) + hasher.combine(amount) + hasher.combine(receiver) + hasher.combine(assetSender) + hasher.combine(closeRemainderTo) + } +} + + + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +public struct FfiConverterTypeAssetTransferTransactionFields: FfiConverterRustBuffer { + public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> AssetTransferTransactionFields { + return + try AssetTransferTransactionFields( + assetId: FfiConverterUInt64.read(from: &buf), + amount: FfiConverterUInt64.read(from: &buf), + receiver: FfiConverterString.read(from: &buf), + assetSender: FfiConverterOptionString.read(from: &buf), + closeRemainderTo: FfiConverterOptionString.read(from: &buf) + ) + } + + public static func write(_ value: AssetTransferTransactionFields, into buf: inout [UInt8]) { + FfiConverterUInt64.write(value.assetId, into: &buf) + FfiConverterUInt64.write(value.amount, into: &buf) + FfiConverterString.write(value.receiver, into: &buf) + FfiConverterOptionString.write(value.assetSender, into: &buf) + FfiConverterOptionString.write(value.closeRemainderTo, into: &buf) + } +} + + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +public func FfiConverterTypeAssetTransferTransactionFields_lift(_ buf: RustBuffer) throws -> AssetTransferTransactionFields { + return try FfiConverterTypeAssetTransferTransactionFields.lift(buf) +} + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +public func FfiConverterTypeAssetTransferTransactionFields_lower(_ value: AssetTransferTransactionFields) -> RustBuffer { + return FfiConverterTypeAssetTransferTransactionFields.lower(value) +} + + +/** + * Box reference for app call transactions. + * + * References a specific box that should be made available for the runtime + * of the program. + */ +public struct BoxReference { + /** + * App ID that owns the box. + * A value of 0 indicates the current app. + */ + public var appId: UInt64 + /** + * Name of the box. + */ + public var name: Data + + // Default memberwise initializers are never public by default, so we + // declare one manually. + public init( + /** + * App ID that owns the box. + * A value of 0 indicates the current app. + */appId: UInt64, + /** + * Name of the box. + */name: Data) { + self.appId = appId + self.name = name + } +} + +#if compiler(>=6) +extension BoxReference: Sendable {} +#endif + + +extension BoxReference: Equatable, Hashable { + public static func ==(lhs: BoxReference, rhs: BoxReference) -> Bool { + if lhs.appId != rhs.appId { + return false + } + if lhs.name != rhs.name { + return false + } + return true + } + + public func hash(into hasher: inout Hasher) { + hasher.combine(appId) + hasher.combine(name) + } +} + + + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +public struct FfiConverterTypeBoxReference: FfiConverterRustBuffer { + public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> BoxReference { + return + try BoxReference( + appId: FfiConverterUInt64.read(from: &buf), + name: FfiConverterData.read(from: &buf) + ) + } + + public static func write(_ value: BoxReference, into buf: inout [UInt8]) { + FfiConverterUInt64.write(value.appId, into: &buf) + FfiConverterData.write(value.name, into: &buf) + } +} + + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +public func FfiConverterTypeBoxReference_lift(_ buf: RustBuffer) throws -> BoxReference { + return try FfiConverterTypeBoxReference.lift(buf) +} + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +public func FfiConverterTypeBoxReference_lower(_ value: BoxReference) -> RustBuffer { + return FfiConverterTypeBoxReference.lower(value) +} + + +public struct FeeParams { + public var feePerByte: UInt64 + public var minFee: UInt64 + public var extraFee: UInt64? + public var maxFee: UInt64? + + // Default memberwise initializers are never public by default, so we + // declare one manually. + public init(feePerByte: UInt64, minFee: UInt64, extraFee: UInt64? = nil, maxFee: UInt64? = nil) { + self.feePerByte = feePerByte + self.minFee = minFee + self.extraFee = extraFee + self.maxFee = maxFee + } +} + +#if compiler(>=6) +extension FeeParams: Sendable {} +#endif + + +extension FeeParams: Equatable, Hashable { + public static func ==(lhs: FeeParams, rhs: FeeParams) -> Bool { + if lhs.feePerByte != rhs.feePerByte { + return false + } + if lhs.minFee != rhs.minFee { + return false + } + if lhs.extraFee != rhs.extraFee { + return false + } + if lhs.maxFee != rhs.maxFee { + return false + } + return true + } + + public func hash(into hasher: inout Hasher) { + hasher.combine(feePerByte) + hasher.combine(minFee) + hasher.combine(extraFee) + hasher.combine(maxFee) + } +} + + + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +public struct FfiConverterTypeFeeParams: FfiConverterRustBuffer { + public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> FeeParams { + return + try FeeParams( + feePerByte: FfiConverterUInt64.read(from: &buf), + minFee: FfiConverterUInt64.read(from: &buf), + extraFee: FfiConverterOptionUInt64.read(from: &buf), + maxFee: FfiConverterOptionUInt64.read(from: &buf) + ) + } + + public static func write(_ value: FeeParams, into buf: inout [UInt8]) { + FfiConverterUInt64.write(value.feePerByte, into: &buf) + FfiConverterUInt64.write(value.minFee, into: &buf) + FfiConverterOptionUInt64.write(value.extraFee, into: &buf) + FfiConverterOptionUInt64.write(value.maxFee, into: &buf) + } +} + + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +public func FfiConverterTypeFeeParams_lift(_ buf: RustBuffer) throws -> FeeParams { + return try FfiConverterTypeFeeParams.lift(buf) +} + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +public func FfiConverterTypeFeeParams_lower(_ value: FeeParams) -> RustBuffer { + return FfiConverterTypeFeeParams.lower(value) +} + + +public struct KeyPairAccount { + public var pubKey: Data + + // Default memberwise initializers are never public by default, so we + // declare one manually. + public init(pubKey: Data) { + self.pubKey = pubKey + } +} + +#if compiler(>=6) +extension KeyPairAccount: Sendable {} +#endif + + +extension KeyPairAccount: Equatable, Hashable { + public static func ==(lhs: KeyPairAccount, rhs: KeyPairAccount) -> Bool { + if lhs.pubKey != rhs.pubKey { + return false + } + return true + } + + public func hash(into hasher: inout Hasher) { + hasher.combine(pubKey) + } +} + + + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +public struct FfiConverterTypeKeyPairAccount: FfiConverterRustBuffer { + public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> KeyPairAccount { + return + try KeyPairAccount( + pubKey: FfiConverterData.read(from: &buf) + ) + } + + public static func write(_ value: KeyPairAccount, into buf: inout [UInt8]) { + FfiConverterData.write(value.pubKey, into: &buf) + } +} + + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +public func FfiConverterTypeKeyPairAccount_lift(_ buf: RustBuffer) throws -> KeyPairAccount { + return try FfiConverterTypeKeyPairAccount.lift(buf) +} + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +public func FfiConverterTypeKeyPairAccount_lower(_ value: KeyPairAccount) -> RustBuffer { + return FfiConverterTypeKeyPairAccount.lower(value) +} + + +public struct KeyRegistrationTransactionFields { + /** + * Root participation public key (32 bytes) + */ + public var voteKey: Data? + /** + * VRF public key (32 bytes) + */ + public var selectionKey: Data? + /** + * State proof key (64 bytes) + */ + public var stateProofKey: Data? + /** + * First round for which the participation key is valid + */ + public var voteFirst: UInt64? + /** + * Last round for which the participation key is valid + */ + public var voteLast: UInt64? + /** + * Key dilution for the 2-level participation key + */ + public var voteKeyDilution: UInt64? + /** + * Mark account as non-reward earning + */ + public var nonParticipation: Bool? + + // Default memberwise initializers are never public by default, so we + // declare one manually. + public init( + /** + * Root participation public key (32 bytes) + */voteKey: Data? = nil, + /** + * VRF public key (32 bytes) + */selectionKey: Data? = nil, + /** + * State proof key (64 bytes) + */stateProofKey: Data? = nil, + /** + * First round for which the participation key is valid + */voteFirst: UInt64? = nil, + /** + * Last round for which the participation key is valid + */voteLast: UInt64? = nil, + /** + * Key dilution for the 2-level participation key + */voteKeyDilution: UInt64? = nil, + /** + * Mark account as non-reward earning + */nonParticipation: Bool? = nil) { + self.voteKey = voteKey + self.selectionKey = selectionKey + self.stateProofKey = stateProofKey + self.voteFirst = voteFirst + self.voteLast = voteLast + self.voteKeyDilution = voteKeyDilution + self.nonParticipation = nonParticipation + } +} + +#if compiler(>=6) +extension KeyRegistrationTransactionFields: Sendable {} +#endif + + +extension KeyRegistrationTransactionFields: Equatable, Hashable { + public static func ==(lhs: KeyRegistrationTransactionFields, rhs: KeyRegistrationTransactionFields) -> Bool { + if lhs.voteKey != rhs.voteKey { + return false + } + if lhs.selectionKey != rhs.selectionKey { + return false + } + if lhs.stateProofKey != rhs.stateProofKey { + return false + } + if lhs.voteFirst != rhs.voteFirst { + return false + } + if lhs.voteLast != rhs.voteLast { + return false + } + if lhs.voteKeyDilution != rhs.voteKeyDilution { + return false + } + if lhs.nonParticipation != rhs.nonParticipation { + return false + } + return true + } + + public func hash(into hasher: inout Hasher) { + hasher.combine(voteKey) + hasher.combine(selectionKey) + hasher.combine(stateProofKey) + hasher.combine(voteFirst) + hasher.combine(voteLast) + hasher.combine(voteKeyDilution) + hasher.combine(nonParticipation) + } +} + + + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +public struct FfiConverterTypeKeyRegistrationTransactionFields: FfiConverterRustBuffer { + public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> KeyRegistrationTransactionFields { + return + try KeyRegistrationTransactionFields( + voteKey: FfiConverterOptionData.read(from: &buf), + selectionKey: FfiConverterOptionData.read(from: &buf), + stateProofKey: FfiConverterOptionData.read(from: &buf), + voteFirst: FfiConverterOptionUInt64.read(from: &buf), + voteLast: FfiConverterOptionUInt64.read(from: &buf), + voteKeyDilution: FfiConverterOptionUInt64.read(from: &buf), + nonParticipation: FfiConverterOptionBool.read(from: &buf) + ) + } + + public static func write(_ value: KeyRegistrationTransactionFields, into buf: inout [UInt8]) { + FfiConverterOptionData.write(value.voteKey, into: &buf) + FfiConverterOptionData.write(value.selectionKey, into: &buf) + FfiConverterOptionData.write(value.stateProofKey, into: &buf) + FfiConverterOptionUInt64.write(value.voteFirst, into: &buf) + FfiConverterOptionUInt64.write(value.voteLast, into: &buf) + FfiConverterOptionUInt64.write(value.voteKeyDilution, into: &buf) + FfiConverterOptionBool.write(value.nonParticipation, into: &buf) + } +} + + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +public func FfiConverterTypeKeyRegistrationTransactionFields_lift(_ buf: RustBuffer) throws -> KeyRegistrationTransactionFields { + return try FfiConverterTypeKeyRegistrationTransactionFields.lift(buf) +} + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +public func FfiConverterTypeKeyRegistrationTransactionFields_lower(_ value: KeyRegistrationTransactionFields) -> RustBuffer { + return FfiConverterTypeKeyRegistrationTransactionFields.lower(value) +} + + +/** + * Representation of an Algorand multisignature signature. + */ +public struct MultisigSignature { + /** + * Multisig version. + */ + public var version: UInt8 + /** + * Minimum number of signatures required. + */ + public var threshold: UInt8 + /** + * List of subsignatures for each participant. + */ + public var subsignatures: [MultisigSubsignature] + + // Default memberwise initializers are never public by default, so we + // declare one manually. + public init( + /** + * Multisig version. + */version: UInt8, + /** + * Minimum number of signatures required. + */threshold: UInt8, + /** + * List of subsignatures for each participant. + */subsignatures: [MultisigSubsignature]) { + self.version = version + self.threshold = threshold + self.subsignatures = subsignatures + } +} + +#if compiler(>=6) +extension MultisigSignature: Sendable {} +#endif + + +extension MultisigSignature: Equatable, Hashable { + public static func ==(lhs: MultisigSignature, rhs: MultisigSignature) -> Bool { + if lhs.version != rhs.version { + return false + } + if lhs.threshold != rhs.threshold { + return false + } + if lhs.subsignatures != rhs.subsignatures { + return false + } + return true + } + + public func hash(into hasher: inout Hasher) { + hasher.combine(version) + hasher.combine(threshold) + hasher.combine(subsignatures) + } +} + + + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +public struct FfiConverterTypeMultisigSignature: FfiConverterRustBuffer { + public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> MultisigSignature { + return + try MultisigSignature( + version: FfiConverterUInt8.read(from: &buf), + threshold: FfiConverterUInt8.read(from: &buf), + subsignatures: FfiConverterSequenceTypeMultisigSubsignature.read(from: &buf) + ) + } + + public static func write(_ value: MultisigSignature, into buf: inout [UInt8]) { + FfiConverterUInt8.write(value.version, into: &buf) + FfiConverterUInt8.write(value.threshold, into: &buf) + FfiConverterSequenceTypeMultisigSubsignature.write(value.subsignatures, into: &buf) + } +} + + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +public func FfiConverterTypeMultisigSignature_lift(_ buf: RustBuffer) throws -> MultisigSignature { + return try FfiConverterTypeMultisigSignature.lift(buf) +} + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +public func FfiConverterTypeMultisigSignature_lower(_ value: MultisigSignature) -> RustBuffer { + return FfiConverterTypeMultisigSignature.lower(value) +} + + +/** + * Representation of a single subsignature in a multisignature transaction. + * + * Each subsignature contains the participant's address and an optional signature. + */ +public struct MultisigSubsignature { + /** + * Address of the participant. + */ + public var address: String + /** + * Optional signature bytes for the participant. + */ + public var signature: Data? + + // Default memberwise initializers are never public by default, so we + // declare one manually. + public init( + /** + * Address of the participant. + */address: String, + /** + * Optional signature bytes for the participant. + */signature: Data? = nil) { + self.address = address + self.signature = signature + } +} + +#if compiler(>=6) +extension MultisigSubsignature: Sendable {} +#endif + + +extension MultisigSubsignature: Equatable, Hashable { + public static func ==(lhs: MultisigSubsignature, rhs: MultisigSubsignature) -> Bool { + if lhs.address != rhs.address { + return false + } + if lhs.signature != rhs.signature { + return false + } + return true + } + + public func hash(into hasher: inout Hasher) { + hasher.combine(address) + hasher.combine(signature) + } +} + + + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +public struct FfiConverterTypeMultisigSubsignature: FfiConverterRustBuffer { + public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> MultisigSubsignature { + return + try MultisigSubsignature( + address: FfiConverterString.read(from: &buf), + signature: FfiConverterOptionData.read(from: &buf) + ) + } + + public static func write(_ value: MultisigSubsignature, into buf: inout [UInt8]) { + FfiConverterString.write(value.address, into: &buf) + FfiConverterOptionData.write(value.signature, into: &buf) + } +} + + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +public func FfiConverterTypeMultisigSubsignature_lift(_ buf: RustBuffer) throws -> MultisigSubsignature { + return try FfiConverterTypeMultisigSubsignature.lift(buf) +} + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +public func FfiConverterTypeMultisigSubsignature_lower(_ value: MultisigSubsignature) -> RustBuffer { + return FfiConverterTypeMultisigSubsignature.lower(value) +} + + +public struct PaymentTransactionFields { + public var receiver: String + public var amount: UInt64 + public var closeRemainderTo: String? + + // Default memberwise initializers are never public by default, so we + // declare one manually. + public init(receiver: String, amount: UInt64, closeRemainderTo: String? = nil) { + self.receiver = receiver + self.amount = amount + self.closeRemainderTo = closeRemainderTo + } +} + +#if compiler(>=6) +extension PaymentTransactionFields: Sendable {} +#endif + + +extension PaymentTransactionFields: Equatable, Hashable { + public static func ==(lhs: PaymentTransactionFields, rhs: PaymentTransactionFields) -> Bool { + if lhs.receiver != rhs.receiver { + return false + } + if lhs.amount != rhs.amount { + return false + } + if lhs.closeRemainderTo != rhs.closeRemainderTo { + return false + } + return true + } + + public func hash(into hasher: inout Hasher) { + hasher.combine(receiver) + hasher.combine(amount) + hasher.combine(closeRemainderTo) + } +} + + + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +public struct FfiConverterTypePaymentTransactionFields: FfiConverterRustBuffer { + public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> PaymentTransactionFields { + return + try PaymentTransactionFields( + receiver: FfiConverterString.read(from: &buf), + amount: FfiConverterUInt64.read(from: &buf), + closeRemainderTo: FfiConverterOptionString.read(from: &buf) + ) + } + + public static func write(_ value: PaymentTransactionFields, into buf: inout [UInt8]) { + FfiConverterString.write(value.receiver, into: &buf) + FfiConverterUInt64.write(value.amount, into: &buf) + FfiConverterOptionString.write(value.closeRemainderTo, into: &buf) + } +} + + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +public func FfiConverterTypePaymentTransactionFields_lift(_ buf: RustBuffer) throws -> PaymentTransactionFields { + return try FfiConverterTypePaymentTransactionFields.lift(buf) +} + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +public func FfiConverterTypePaymentTransactionFields_lower(_ value: PaymentTransactionFields) -> RustBuffer { + return FfiConverterTypePaymentTransactionFields.lower(value) +} + + +public struct SignedTransaction { + /** + * The transaction that has been signed. + */ + public var transaction: Transaction + /** + * Optional Ed25519 signature authorizing the transaction. + */ + public var signature: Data? + /** + * Optional auth address applicable if the transaction sender is a rekeyed account. + */ + public var authAddress: String? + /** + * Optional multisig signature if the transaction is a multisig transaction. + */ + public var multisignature: MultisigSignature? + + // Default memberwise initializers are never public by default, so we + // declare one manually. + public init( + /** + * The transaction that has been signed. + */transaction: Transaction, + /** + * Optional Ed25519 signature authorizing the transaction. + */signature: Data? = nil, + /** + * Optional auth address applicable if the transaction sender is a rekeyed account. + */authAddress: String? = nil, + /** + * Optional multisig signature if the transaction is a multisig transaction. + */multisignature: MultisigSignature? = nil) { + self.transaction = transaction + self.signature = signature + self.authAddress = authAddress + self.multisignature = multisignature + } +} + +#if compiler(>=6) +extension SignedTransaction: Sendable {} +#endif + + +extension SignedTransaction: Equatable, Hashable { + public static func ==(lhs: SignedTransaction, rhs: SignedTransaction) -> Bool { + if lhs.transaction != rhs.transaction { + return false + } + if lhs.signature != rhs.signature { + return false + } + if lhs.authAddress != rhs.authAddress { + return false + } + if lhs.multisignature != rhs.multisignature { + return false + } + return true + } + + public func hash(into hasher: inout Hasher) { + hasher.combine(transaction) + hasher.combine(signature) + hasher.combine(authAddress) + hasher.combine(multisignature) + } +} + + + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +public struct FfiConverterTypeSignedTransaction: FfiConverterRustBuffer { + public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> SignedTransaction { + return + try SignedTransaction( + transaction: FfiConverterTypeTransaction.read(from: &buf), + signature: FfiConverterOptionData.read(from: &buf), + authAddress: FfiConverterOptionString.read(from: &buf), + multisignature: FfiConverterOptionTypeMultisigSignature.read(from: &buf) + ) + } + + public static func write(_ value: SignedTransaction, into buf: inout [UInt8]) { + FfiConverterTypeTransaction.write(value.transaction, into: &buf) + FfiConverterOptionData.write(value.signature, into: &buf) + FfiConverterOptionString.write(value.authAddress, into: &buf) + FfiConverterOptionTypeMultisigSignature.write(value.multisignature, into: &buf) + } +} + + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +public func FfiConverterTypeSignedTransaction_lift(_ buf: RustBuffer) throws -> SignedTransaction { + return try FfiConverterTypeSignedTransaction.lift(buf) +} + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +public func FfiConverterTypeSignedTransaction_lower(_ value: SignedTransaction) -> RustBuffer { + return FfiConverterTypeSignedTransaction.lower(value) +} + + +/** + * Schema for app state storage. + * + * Defines the maximum number of values that may be stored in app + * key/value storage for both global and local state. + */ +public struct StateSchema { + /** + * Maximum number of integer values that may be stored. + */ + public var numUints: UInt32 + /** + * Maximum number of byte slice values that may be stored. + */ + public var numByteSlices: UInt32 + + // Default memberwise initializers are never public by default, so we + // declare one manually. + public init( + /** + * Maximum number of integer values that may be stored. + */numUints: UInt32, + /** + * Maximum number of byte slice values that may be stored. + */numByteSlices: UInt32) { + self.numUints = numUints + self.numByteSlices = numByteSlices + } +} + +#if compiler(>=6) +extension StateSchema: Sendable {} +#endif + + +extension StateSchema: Equatable, Hashable { + public static func ==(lhs: StateSchema, rhs: StateSchema) -> Bool { + if lhs.numUints != rhs.numUints { + return false + } + if lhs.numByteSlices != rhs.numByteSlices { + return false + } + return true + } + + public func hash(into hasher: inout Hasher) { + hasher.combine(numUints) + hasher.combine(numByteSlices) + } +} + + + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +public struct FfiConverterTypeStateSchema: FfiConverterRustBuffer { + public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> StateSchema { + return + try StateSchema( + numUints: FfiConverterUInt32.read(from: &buf), + numByteSlices: FfiConverterUInt32.read(from: &buf) + ) + } + + public static func write(_ value: StateSchema, into buf: inout [UInt8]) { + FfiConverterUInt32.write(value.numUints, into: &buf) + FfiConverterUInt32.write(value.numByteSlices, into: &buf) + } +} + + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +public func FfiConverterTypeStateSchema_lift(_ buf: RustBuffer) throws -> StateSchema { + return try FfiConverterTypeStateSchema.lift(buf) +} + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +public func FfiConverterTypeStateSchema_lower(_ value: StateSchema) -> RustBuffer { + return FfiConverterTypeStateSchema.lower(value) +} + + +public struct Transaction { + /** + * The type of transaction + */ + public var transactionType: TransactionType + /** + * The sender of the transaction + */ + public var sender: String + /** + * Optional transaction fee in microALGO. + * + * If not set, the fee will be interpreted as 0 by the network. + */ + public var fee: UInt64? + public var firstValid: UInt64 + public var lastValid: UInt64 + public var genesisHash: Data? + public var genesisId: String? + public var note: Data? + public var rekeyTo: String? + public var lease: Data? + public var group: Data? + public var payment: PaymentTransactionFields? + public var assetTransfer: AssetTransferTransactionFields? + public var assetConfig: AssetConfigTransactionFields? + public var appCall: AppCallTransactionFields? + public var keyRegistration: KeyRegistrationTransactionFields? + public var assetFreeze: AssetFreezeTransactionFields? // Default memberwise initializers are never public by default, so we // declare one manually. @@ -731,7 +2268,12 @@ public struct Transaction { */transactionType: TransactionType, /** * The sender of the transaction - */sender: Address, fee: UInt64, firstValid: UInt64, lastValid: UInt64, genesisHash: ByteBuf?, genesisId: String?, note: ByteBuf? = nil, rekeyTo: Address? = nil, lease: ByteBuf? = nil, group: ByteBuf? = nil, payment: PaymentTransactionFields? = nil, assetTransfer: AssetTransferTransactionFields? = nil) { + */sender: String, + /** + * Optional transaction fee in microALGO. + * + * If not set, the fee will be interpreted as 0 by the network. + */fee: UInt64? = nil, firstValid: UInt64, lastValid: UInt64, genesisHash: Data?, genesisId: String?, note: Data? = nil, rekeyTo: String? = nil, lease: Data? = nil, group: Data? = nil, payment: PaymentTransactionFields? = nil, assetTransfer: AssetTransferTransactionFields? = nil, assetConfig: AssetConfigTransactionFields? = nil, appCall: AppCallTransactionFields? = nil, keyRegistration: KeyRegistrationTransactionFields? = nil, assetFreeze: AssetFreezeTransactionFields? = nil) { self.transactionType = transactionType self.sender = sender self.fee = fee @@ -745,9 +2287,16 @@ public struct Transaction { self.group = group self.payment = payment self.assetTransfer = assetTransfer + self.assetConfig = assetConfig + self.appCall = appCall + self.keyRegistration = keyRegistration + self.assetFreeze = assetFreeze } } +#if compiler(>=6) +extension Transaction: Sendable {} +#endif extension Transaction: Equatable, Hashable { @@ -791,6 +2340,18 @@ extension Transaction: Equatable, Hashable { if lhs.assetTransfer != rhs.assetTransfer { return false } + if lhs.assetConfig != rhs.assetConfig { + return false + } + if lhs.appCall != rhs.appCall { + return false + } + if lhs.keyRegistration != rhs.keyRegistration { + return false + } + if lhs.assetFreeze != rhs.assetFreeze { + return false + } return true } @@ -808,10 +2369,15 @@ extension Transaction: Equatable, Hashable { hasher.combine(group) hasher.combine(payment) hasher.combine(assetTransfer) + hasher.combine(assetConfig) + hasher.combine(appCall) + hasher.combine(keyRegistration) + hasher.combine(assetFreeze) } } + #if swift(>=5.8) @_documentation(visibility: private) #endif @@ -820,35 +2386,43 @@ public struct FfiConverterTypeTransaction: FfiConverterRustBuffer { return try Transaction( transactionType: FfiConverterTypeTransactionType.read(from: &buf), - sender: FfiConverterTypeAddress.read(from: &buf), - fee: FfiConverterUInt64.read(from: &buf), + sender: FfiConverterString.read(from: &buf), + fee: FfiConverterOptionUInt64.read(from: &buf), firstValid: FfiConverterUInt64.read(from: &buf), lastValid: FfiConverterUInt64.read(from: &buf), - genesisHash: FfiConverterOptionTypeByteBuf.read(from: &buf), + genesisHash: FfiConverterOptionData.read(from: &buf), genesisId: FfiConverterOptionString.read(from: &buf), - note: FfiConverterOptionTypeByteBuf.read(from: &buf), - rekeyTo: FfiConverterOptionTypeAddress.read(from: &buf), - lease: FfiConverterOptionTypeByteBuf.read(from: &buf), - group: FfiConverterOptionTypeByteBuf.read(from: &buf), + note: FfiConverterOptionData.read(from: &buf), + rekeyTo: FfiConverterOptionString.read(from: &buf), + lease: FfiConverterOptionData.read(from: &buf), + group: FfiConverterOptionData.read(from: &buf), payment: FfiConverterOptionTypePaymentTransactionFields.read(from: &buf), - assetTransfer: FfiConverterOptionTypeAssetTransferTransactionFields.read(from: &buf) + assetTransfer: FfiConverterOptionTypeAssetTransferTransactionFields.read(from: &buf), + assetConfig: FfiConverterOptionTypeAssetConfigTransactionFields.read(from: &buf), + appCall: FfiConverterOptionTypeAppCallTransactionFields.read(from: &buf), + keyRegistration: FfiConverterOptionTypeKeyRegistrationTransactionFields.read(from: &buf), + assetFreeze: FfiConverterOptionTypeAssetFreezeTransactionFields.read(from: &buf) ) } public static func write(_ value: Transaction, into buf: inout [UInt8]) { FfiConverterTypeTransactionType.write(value.transactionType, into: &buf) - FfiConverterTypeAddress.write(value.sender, into: &buf) - FfiConverterUInt64.write(value.fee, into: &buf) + FfiConverterString.write(value.sender, into: &buf) + FfiConverterOptionUInt64.write(value.fee, into: &buf) FfiConverterUInt64.write(value.firstValid, into: &buf) FfiConverterUInt64.write(value.lastValid, into: &buf) - FfiConverterOptionTypeByteBuf.write(value.genesisHash, into: &buf) + FfiConverterOptionData.write(value.genesisHash, into: &buf) FfiConverterOptionString.write(value.genesisId, into: &buf) - FfiConverterOptionTypeByteBuf.write(value.note, into: &buf) - FfiConverterOptionTypeAddress.write(value.rekeyTo, into: &buf) - FfiConverterOptionTypeByteBuf.write(value.lease, into: &buf) - FfiConverterOptionTypeByteBuf.write(value.group, into: &buf) + FfiConverterOptionData.write(value.note, into: &buf) + FfiConverterOptionString.write(value.rekeyTo, into: &buf) + FfiConverterOptionData.write(value.lease, into: &buf) + FfiConverterOptionData.write(value.group, into: &buf) FfiConverterOptionTypePaymentTransactionFields.write(value.payment, into: &buf) FfiConverterOptionTypeAssetTransferTransactionFields.write(value.assetTransfer, into: &buf) + FfiConverterOptionTypeAssetConfigTransactionFields.write(value.assetConfig, into: &buf) + FfiConverterOptionTypeAppCallTransactionFields.write(value.appCall, into: &buf) + FfiConverterOptionTypeKeyRegistrationTransactionFields.write(value.keyRegistration, into: &buf) + FfiConverterOptionTypeAssetFreezeTransactionFields.write(value.assetFreeze, into: &buf) } } @@ -868,13 +2442,17 @@ public func FfiConverterTypeTransaction_lower(_ value: Transaction) -> RustBuffe } -public enum AlgoKitTransactError { +public enum AlgoKitTransactError: Swift.Error { - case EncodingError(String + case EncodingError(errorMsg: String + ) + case DecodingError(errorMsg: String ) - case DecodingError(String + case InputError(errorMsg: String + ) + case MsgPackError(errorMsg: String ) } @@ -893,10 +2471,16 @@ public struct FfiConverterTypeAlgoKitTransactError: FfiConverterRustBuffer { case 1: return .EncodingError( - try FfiConverterString.read(from: &buf) + errorMsg: try FfiConverterString.read(from: &buf) ) case 2: return .DecodingError( - try FfiConverterString.read(from: &buf) + errorMsg: try FfiConverterString.read(from: &buf) + ) + case 3: return .InputError( + errorMsg: try FfiConverterString.read(from: &buf) + ) + case 4: return .MsgPackError( + errorMsg: try FfiConverterString.read(from: &buf) ) default: throw UniffiInternalError.unexpectedEnumCase @@ -910,126 +2494,300 @@ public struct FfiConverterTypeAlgoKitTransactError: FfiConverterRustBuffer { - case let .EncodingError(v1): + case let .EncodingError(errorMsg): writeInt(&buf, Int32(1)) - FfiConverterString.write(v1, into: &buf) + FfiConverterString.write(errorMsg, into: &buf) - case let .DecodingError(v1): + case let .DecodingError(errorMsg): writeInt(&buf, Int32(2)) - FfiConverterString.write(v1, into: &buf) + FfiConverterString.write(errorMsg, into: &buf) + + + case let .InputError(errorMsg): + writeInt(&buf, Int32(3)) + FfiConverterString.write(errorMsg, into: &buf) + + + case let .MsgPackError(errorMsg): + writeInt(&buf, Int32(4)) + FfiConverterString.write(errorMsg, into: &buf) } } } -extension AlgoKitTransactError: Equatable, Hashable {} +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +public func FfiConverterTypeAlgoKitTransactError_lift(_ buf: RustBuffer) throws -> AlgoKitTransactError { + return try FfiConverterTypeAlgoKitTransactError.lift(buf) +} + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +public func FfiConverterTypeAlgoKitTransactError_lower(_ value: AlgoKitTransactError) -> RustBuffer { + return FfiConverterTypeAlgoKitTransactError.lower(value) +} + + +extension AlgoKitTransactError: Equatable, Hashable {} + + + + +extension AlgoKitTransactError: Foundation.LocalizedError { + public var errorDescription: String? { + String(reflecting: self) + } +} + + + + +// Note that we don't yet support `indirect` for enums. +// See https://github.com/mozilla/uniffi-rs/issues/396 for further discussion. +/** + * Enum containing all constants used in this crate. + */ + +public enum AlgorandConstant { + + /** + * Length of hash digests (32) + */ + case hashLength + /** + * Length of the checksum used in Algorand addresses (4) + */ + case checksumLength + /** + * Length of a base32-encoded Algorand address (58) + */ + case addressLength + /** + * Length of an Algorand public key in bytes (32) + */ + case publicKeyLength + /** + * Length of an Algorand secret key in bytes (32) + */ + case secretKeyLength + /** + * Length of an Algorand signature in bytes (64) + */ + case signatureLength + /** + * Increment in the encoded byte size when a signature is attached to a transaction (75) + */ + case signatureEncodingIncrLength + /** + * The maximum number of transactions in a group (16) + */ + case maxTxGroupSize +} + + +#if compiler(>=6) +extension AlgorandConstant: Sendable {} +#endif + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +public struct FfiConverterTypeAlgorandConstant: FfiConverterRustBuffer { + typealias SwiftType = AlgorandConstant + + public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> AlgorandConstant { + let variant: Int32 = try readInt(&buf) + switch variant { + + case 1: return .hashLength + + case 2: return .checksumLength + + case 3: return .addressLength + + case 4: return .publicKeyLength + + case 5: return .secretKeyLength + + case 6: return .signatureLength + + case 7: return .signatureEncodingIncrLength + + case 8: return .maxTxGroupSize + + default: throw UniffiInternalError.unexpectedEnumCase + } + } + + public static func write(_ value: AlgorandConstant, into buf: inout [UInt8]) { + switch value { + + + case .hashLength: + writeInt(&buf, Int32(1)) + + + case .checksumLength: + writeInt(&buf, Int32(2)) + + + case .addressLength: + writeInt(&buf, Int32(3)) + + + case .publicKeyLength: + writeInt(&buf, Int32(4)) + + + case .secretKeyLength: + writeInt(&buf, Int32(5)) + + + case .signatureLength: + writeInt(&buf, Int32(6)) + + + case .signatureEncodingIncrLength: + writeInt(&buf, Int32(7)) + + + case .maxTxGroupSize: + writeInt(&buf, Int32(8)) + + } + } +} + + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +public func FfiConverterTypeAlgorandConstant_lift(_ buf: RustBuffer) throws -> AlgorandConstant { + return try FfiConverterTypeAlgorandConstant.lift(buf) +} + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +public func FfiConverterTypeAlgorandConstant_lower(_ value: AlgorandConstant) -> RustBuffer { + return FfiConverterTypeAlgorandConstant.lower(value) +} + + +extension AlgorandConstant: Equatable, Hashable {} + + + + -extension AlgoKitTransactError: Foundation.LocalizedError { - public var errorDescription: String? { - String(reflecting: self) - } -} // Note that we don't yet support `indirect` for enums. // See https://github.com/mozilla/uniffi-rs/issues/396 for further discussion. /** - * Enum containing all constants used in this crate. + * On-completion actions for app transactions. + * + * These values define what additional actions occur with the transaction. */ -public enum AlgorandConstant { +public enum OnApplicationComplete { /** - * Length of hash digests (32) - */ - case hashLength - /** - * Length of the checksum used in Algorand addresses (4) + * NoOp indicates that an app transaction will simply call its + * approval program without any additional action. */ - case checksumLength + case noOp /** - * Length of a base32-encoded Algorand address (58) + * OptIn indicates that an app transaction will allocate some + * local state for the app in the sender's account. */ - case addressLength + case optIn /** - * Length of an Algorand public key in bytes (32) + * CloseOut indicates that an app transaction will deallocate + * some local state for the app from the user's account. */ - case publicKeyLength + case closeOut /** - * Length of an Algorand secret key in bytes (32) + * ClearState is similar to CloseOut, but may never fail. This + * allows users to reclaim their minimum balance from an app + * they no longer wish to opt in to. */ - case secretKeyLength + case clearState /** - * Length of an Algorand signature in bytes (64) + * UpdateApplication indicates that an app transaction will + * update the approval program and clear state program for the app. */ - case signatureLength + case updateApplication /** - * Increment in the encoded byte size when a signature is attached to a transaction (75) + * DeleteApplication indicates that an app transaction will + * delete the app parameters for the app from the creator's + * balance record. */ - case signatureEncodingIncrLength + case deleteApplication } +#if compiler(>=6) +extension OnApplicationComplete: Sendable {} +#endif + #if swift(>=5.8) @_documentation(visibility: private) #endif -public struct FfiConverterTypeAlgorandConstant: FfiConverterRustBuffer { - typealias SwiftType = AlgorandConstant +public struct FfiConverterTypeOnApplicationComplete: FfiConverterRustBuffer { + typealias SwiftType = OnApplicationComplete - public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> AlgorandConstant { + public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> OnApplicationComplete { let variant: Int32 = try readInt(&buf) switch variant { - case 1: return .hashLength - - case 2: return .checksumLength + case 1: return .noOp - case 3: return .addressLength + case 2: return .optIn - case 4: return .publicKeyLength + case 3: return .closeOut - case 5: return .secretKeyLength + case 4: return .clearState - case 6: return .signatureLength + case 5: return .updateApplication - case 7: return .signatureEncodingIncrLength + case 6: return .deleteApplication default: throw UniffiInternalError.unexpectedEnumCase } } - public static func write(_ value: AlgorandConstant, into buf: inout [UInt8]) { + public static func write(_ value: OnApplicationComplete, into buf: inout [UInt8]) { switch value { - case .hashLength: + case .noOp: writeInt(&buf, Int32(1)) - case .checksumLength: + case .optIn: writeInt(&buf, Int32(2)) - case .addressLength: + case .closeOut: writeInt(&buf, Int32(3)) - case .publicKeyLength: + case .clearState: writeInt(&buf, Int32(4)) - case .secretKeyLength: + case .updateApplication: writeInt(&buf, Int32(5)) - case .signatureLength: + case .deleteApplication: writeInt(&buf, Int32(6)) - - case .signatureEncodingIncrLength: - writeInt(&buf, Int32(7)) - } } } @@ -1038,20 +2796,22 @@ public struct FfiConverterTypeAlgorandConstant: FfiConverterRustBuffer { #if swift(>=5.8) @_documentation(visibility: private) #endif -public func FfiConverterTypeAlgorandConstant_lift(_ buf: RustBuffer) throws -> AlgorandConstant { - return try FfiConverterTypeAlgorandConstant.lift(buf) +public func FfiConverterTypeOnApplicationComplete_lift(_ buf: RustBuffer) throws -> OnApplicationComplete { + return try FfiConverterTypeOnApplicationComplete.lift(buf) } #if swift(>=5.8) @_documentation(visibility: private) #endif -public func FfiConverterTypeAlgorandConstant_lower(_ value: AlgorandConstant) -> RustBuffer { - return FfiConverterTypeAlgorandConstant.lower(value) +public func FfiConverterTypeOnApplicationComplete_lower(_ value: OnApplicationComplete) -> RustBuffer { + return FfiConverterTypeOnApplicationComplete.lower(value) } +extension OnApplicationComplete: Equatable, Hashable {} + + -extension AlgorandConstant: Equatable, Hashable {} @@ -1065,10 +2825,14 @@ public enum TransactionType { case assetFreeze case assetConfig case keyRegistration - case applicationCall + case appCall } +#if compiler(>=6) +extension TransactionType: Sendable {} +#endif + #if swift(>=5.8) @_documentation(visibility: private) #endif @@ -1089,7 +2853,7 @@ public struct FfiConverterTypeTransactionType: FfiConverterRustBuffer { case 5: return .keyRegistration - case 6: return .applicationCall + case 6: return .appCall default: throw UniffiInternalError.unexpectedEnumCase } @@ -1119,39 +2883,329 @@ public struct FfiConverterTypeTransactionType: FfiConverterRustBuffer { writeInt(&buf, Int32(5)) - case .applicationCall: + case .appCall: writeInt(&buf, Int32(6)) } } -} +} + + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +public func FfiConverterTypeTransactionType_lift(_ buf: RustBuffer) throws -> TransactionType { + return try FfiConverterTypeTransactionType.lift(buf) +} + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +public func FfiConverterTypeTransactionType_lower(_ value: TransactionType) -> RustBuffer { + return FfiConverterTypeTransactionType.lower(value) +} + + +extension TransactionType: Equatable, Hashable {} + + + + + + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +fileprivate struct FfiConverterOptionUInt32: FfiConverterRustBuffer { + typealias SwiftType = UInt32? + + public static func write(_ value: SwiftType, into buf: inout [UInt8]) { + guard let value = value else { + writeInt(&buf, Int8(0)) + return + } + writeInt(&buf, Int8(1)) + FfiConverterUInt32.write(value, into: &buf) + } + + public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> SwiftType { + switch try readInt(&buf) as Int8 { + case 0: return nil + case 1: return try FfiConverterUInt32.read(from: &buf) + default: throw UniffiInternalError.unexpectedOptionalTag + } + } +} + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +fileprivate struct FfiConverterOptionUInt64: FfiConverterRustBuffer { + typealias SwiftType = UInt64? + + public static func write(_ value: SwiftType, into buf: inout [UInt8]) { + guard let value = value else { + writeInt(&buf, Int8(0)) + return + } + writeInt(&buf, Int8(1)) + FfiConverterUInt64.write(value, into: &buf) + } + + public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> SwiftType { + switch try readInt(&buf) as Int8 { + case 0: return nil + case 1: return try FfiConverterUInt64.read(from: &buf) + default: throw UniffiInternalError.unexpectedOptionalTag + } + } +} + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +fileprivate struct FfiConverterOptionBool: FfiConverterRustBuffer { + typealias SwiftType = Bool? + + public static func write(_ value: SwiftType, into buf: inout [UInt8]) { + guard let value = value else { + writeInt(&buf, Int8(0)) + return + } + writeInt(&buf, Int8(1)) + FfiConverterBool.write(value, into: &buf) + } + + public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> SwiftType { + switch try readInt(&buf) as Int8 { + case 0: return nil + case 1: return try FfiConverterBool.read(from: &buf) + default: throw UniffiInternalError.unexpectedOptionalTag + } + } +} + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +fileprivate struct FfiConverterOptionString: FfiConverterRustBuffer { + typealias SwiftType = String? + + public static func write(_ value: SwiftType, into buf: inout [UInt8]) { + guard let value = value else { + writeInt(&buf, Int8(0)) + return + } + writeInt(&buf, Int8(1)) + FfiConverterString.write(value, into: &buf) + } + + public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> SwiftType { + switch try readInt(&buf) as Int8 { + case 0: return nil + case 1: return try FfiConverterString.read(from: &buf) + default: throw UniffiInternalError.unexpectedOptionalTag + } + } +} + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +fileprivate struct FfiConverterOptionData: FfiConverterRustBuffer { + typealias SwiftType = Data? + + public static func write(_ value: SwiftType, into buf: inout [UInt8]) { + guard let value = value else { + writeInt(&buf, Int8(0)) + return + } + writeInt(&buf, Int8(1)) + FfiConverterData.write(value, into: &buf) + } + + public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> SwiftType { + switch try readInt(&buf) as Int8 { + case 0: return nil + case 1: return try FfiConverterData.read(from: &buf) + default: throw UniffiInternalError.unexpectedOptionalTag + } + } +} + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +fileprivate struct FfiConverterOptionTypeAppCallTransactionFields: FfiConverterRustBuffer { + typealias SwiftType = AppCallTransactionFields? + + public static func write(_ value: SwiftType, into buf: inout [UInt8]) { + guard let value = value else { + writeInt(&buf, Int8(0)) + return + } + writeInt(&buf, Int8(1)) + FfiConverterTypeAppCallTransactionFields.write(value, into: &buf) + } + + public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> SwiftType { + switch try readInt(&buf) as Int8 { + case 0: return nil + case 1: return try FfiConverterTypeAppCallTransactionFields.read(from: &buf) + default: throw UniffiInternalError.unexpectedOptionalTag + } + } +} + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +fileprivate struct FfiConverterOptionTypeAssetConfigTransactionFields: FfiConverterRustBuffer { + typealias SwiftType = AssetConfigTransactionFields? + + public static func write(_ value: SwiftType, into buf: inout [UInt8]) { + guard let value = value else { + writeInt(&buf, Int8(0)) + return + } + writeInt(&buf, Int8(1)) + FfiConverterTypeAssetConfigTransactionFields.write(value, into: &buf) + } + + public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> SwiftType { + switch try readInt(&buf) as Int8 { + case 0: return nil + case 1: return try FfiConverterTypeAssetConfigTransactionFields.read(from: &buf) + default: throw UniffiInternalError.unexpectedOptionalTag + } + } +} + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +fileprivate struct FfiConverterOptionTypeAssetFreezeTransactionFields: FfiConverterRustBuffer { + typealias SwiftType = AssetFreezeTransactionFields? + + public static func write(_ value: SwiftType, into buf: inout [UInt8]) { + guard let value = value else { + writeInt(&buf, Int8(0)) + return + } + writeInt(&buf, Int8(1)) + FfiConverterTypeAssetFreezeTransactionFields.write(value, into: &buf) + } + + public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> SwiftType { + switch try readInt(&buf) as Int8 { + case 0: return nil + case 1: return try FfiConverterTypeAssetFreezeTransactionFields.read(from: &buf) + default: throw UniffiInternalError.unexpectedOptionalTag + } + } +} + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +fileprivate struct FfiConverterOptionTypeAssetTransferTransactionFields: FfiConverterRustBuffer { + typealias SwiftType = AssetTransferTransactionFields? + + public static func write(_ value: SwiftType, into buf: inout [UInt8]) { + guard let value = value else { + writeInt(&buf, Int8(0)) + return + } + writeInt(&buf, Int8(1)) + FfiConverterTypeAssetTransferTransactionFields.write(value, into: &buf) + } + public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> SwiftType { + switch try readInt(&buf) as Int8 { + case 0: return nil + case 1: return try FfiConverterTypeAssetTransferTransactionFields.read(from: &buf) + default: throw UniffiInternalError.unexpectedOptionalTag + } + } +} #if swift(>=5.8) @_documentation(visibility: private) #endif -public func FfiConverterTypeTransactionType_lift(_ buf: RustBuffer) throws -> TransactionType { - return try FfiConverterTypeTransactionType.lift(buf) +fileprivate struct FfiConverterOptionTypeKeyRegistrationTransactionFields: FfiConverterRustBuffer { + typealias SwiftType = KeyRegistrationTransactionFields? + + public static func write(_ value: SwiftType, into buf: inout [UInt8]) { + guard let value = value else { + writeInt(&buf, Int8(0)) + return + } + writeInt(&buf, Int8(1)) + FfiConverterTypeKeyRegistrationTransactionFields.write(value, into: &buf) + } + + public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> SwiftType { + switch try readInt(&buf) as Int8 { + case 0: return nil + case 1: return try FfiConverterTypeKeyRegistrationTransactionFields.read(from: &buf) + default: throw UniffiInternalError.unexpectedOptionalTag + } + } } #if swift(>=5.8) @_documentation(visibility: private) #endif -public func FfiConverterTypeTransactionType_lower(_ value: TransactionType) -> RustBuffer { - return FfiConverterTypeTransactionType.lower(value) -} +fileprivate struct FfiConverterOptionTypeMultisigSignature: FfiConverterRustBuffer { + typealias SwiftType = MultisigSignature? + public static func write(_ value: SwiftType, into buf: inout [UInt8]) { + guard let value = value else { + writeInt(&buf, Int8(0)) + return + } + writeInt(&buf, Int8(1)) + FfiConverterTypeMultisigSignature.write(value, into: &buf) + } + public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> SwiftType { + switch try readInt(&buf) as Int8 { + case 0: return nil + case 1: return try FfiConverterTypeMultisigSignature.read(from: &buf) + default: throw UniffiInternalError.unexpectedOptionalTag + } + } +} -extension TransactionType: Equatable, Hashable {} +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +fileprivate struct FfiConverterOptionTypePaymentTransactionFields: FfiConverterRustBuffer { + typealias SwiftType = PaymentTransactionFields? + public static func write(_ value: SwiftType, into buf: inout [UInt8]) { + guard let value = value else { + writeInt(&buf, Int8(0)) + return + } + writeInt(&buf, Int8(1)) + FfiConverterTypePaymentTransactionFields.write(value, into: &buf) + } + public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> SwiftType { + switch try readInt(&buf) as Int8 { + case 0: return nil + case 1: return try FfiConverterTypePaymentTransactionFields.read(from: &buf) + default: throw UniffiInternalError.unexpectedOptionalTag + } + } +} #if swift(>=5.8) @_documentation(visibility: private) #endif -fileprivate struct FfiConverterOptionString: FfiConverterRustBuffer { - typealias SwiftType = String? +fileprivate struct FfiConverterOptionTypeStateSchema: FfiConverterRustBuffer { + typealias SwiftType = StateSchema? public static func write(_ value: SwiftType, into buf: inout [UInt8]) { guard let value = value else { @@ -1159,13 +3213,13 @@ fileprivate struct FfiConverterOptionString: FfiConverterRustBuffer { return } writeInt(&buf, Int8(1)) - FfiConverterString.write(value, into: &buf) + FfiConverterTypeStateSchema.write(value, into: &buf) } public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> SwiftType { switch try readInt(&buf) as Int8 { case 0: return nil - case 1: return try FfiConverterString.read(from: &buf) + case 1: return try FfiConverterTypeStateSchema.read(from: &buf) default: throw UniffiInternalError.unexpectedOptionalTag } } @@ -1174,8 +3228,8 @@ fileprivate struct FfiConverterOptionString: FfiConverterRustBuffer { #if swift(>=5.8) @_documentation(visibility: private) #endif -fileprivate struct FfiConverterOptionTypeAddress: FfiConverterRustBuffer { - typealias SwiftType = Address? +fileprivate struct FfiConverterOptionSequenceUInt64: FfiConverterRustBuffer { + typealias SwiftType = [UInt64]? public static func write(_ value: SwiftType, into buf: inout [UInt8]) { guard let value = value else { @@ -1183,13 +3237,13 @@ fileprivate struct FfiConverterOptionTypeAddress: FfiConverterRustBuffer { return } writeInt(&buf, Int8(1)) - FfiConverterTypeAddress.write(value, into: &buf) + FfiConverterSequenceUInt64.write(value, into: &buf) } public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> SwiftType { switch try readInt(&buf) as Int8 { case 0: return nil - case 1: return try FfiConverterTypeAddress.read(from: &buf) + case 1: return try FfiConverterSequenceUInt64.read(from: &buf) default: throw UniffiInternalError.unexpectedOptionalTag } } @@ -1198,8 +3252,8 @@ fileprivate struct FfiConverterOptionTypeAddress: FfiConverterRustBuffer { #if swift(>=5.8) @_documentation(visibility: private) #endif -fileprivate struct FfiConverterOptionTypeAssetTransferTransactionFields: FfiConverterRustBuffer { - typealias SwiftType = AssetTransferTransactionFields? +fileprivate struct FfiConverterOptionSequenceString: FfiConverterRustBuffer { + typealias SwiftType = [String]? public static func write(_ value: SwiftType, into buf: inout [UInt8]) { guard let value = value else { @@ -1207,13 +3261,13 @@ fileprivate struct FfiConverterOptionTypeAssetTransferTransactionFields: FfiConv return } writeInt(&buf, Int8(1)) - FfiConverterTypeAssetTransferTransactionFields.write(value, into: &buf) + FfiConverterSequenceString.write(value, into: &buf) } public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> SwiftType { switch try readInt(&buf) as Int8 { case 0: return nil - case 1: return try FfiConverterTypeAssetTransferTransactionFields.read(from: &buf) + case 1: return try FfiConverterSequenceString.read(from: &buf) default: throw UniffiInternalError.unexpectedOptionalTag } } @@ -1222,8 +3276,8 @@ fileprivate struct FfiConverterOptionTypeAssetTransferTransactionFields: FfiConv #if swift(>=5.8) @_documentation(visibility: private) #endif -fileprivate struct FfiConverterOptionTypePaymentTransactionFields: FfiConverterRustBuffer { - typealias SwiftType = PaymentTransactionFields? +fileprivate struct FfiConverterOptionSequenceData: FfiConverterRustBuffer { + typealias SwiftType = [Data]? public static func write(_ value: SwiftType, into buf: inout [UInt8]) { guard let value = value else { @@ -1231,13 +3285,13 @@ fileprivate struct FfiConverterOptionTypePaymentTransactionFields: FfiConverterR return } writeInt(&buf, Int8(1)) - FfiConverterTypePaymentTransactionFields.write(value, into: &buf) + FfiConverterSequenceData.write(value, into: &buf) } public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> SwiftType { switch try readInt(&buf) as Int8 { case 0: return nil - case 1: return try FfiConverterTypePaymentTransactionFields.read(from: &buf) + case 1: return try FfiConverterSequenceData.read(from: &buf) default: throw UniffiInternalError.unexpectedOptionalTag } } @@ -1246,8 +3300,8 @@ fileprivate struct FfiConverterOptionTypePaymentTransactionFields: FfiConverterR #if swift(>=5.8) @_documentation(visibility: private) #endif -fileprivate struct FfiConverterOptionTypeByteBuf: FfiConverterRustBuffer { - typealias SwiftType = ByteBuf? +fileprivate struct FfiConverterOptionSequenceTypeBoxReference: FfiConverterRustBuffer { + typealias SwiftType = [BoxReference]? public static func write(_ value: SwiftType, into buf: inout [UInt8]) { guard let value = value else { @@ -1255,97 +3309,351 @@ fileprivate struct FfiConverterOptionTypeByteBuf: FfiConverterRustBuffer { return } writeInt(&buf, Int8(1)) - FfiConverterTypeByteBuf.write(value, into: &buf) + FfiConverterSequenceTypeBoxReference.write(value, into: &buf) } public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> SwiftType { switch try readInt(&buf) as Int8 { case 0: return nil - case 1: return try FfiConverterTypeByteBuf.read(from: &buf) + case 1: return try FfiConverterSequenceTypeBoxReference.read(from: &buf) default: throw UniffiInternalError.unexpectedOptionalTag } } } +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +fileprivate struct FfiConverterSequenceUInt64: FfiConverterRustBuffer { + typealias SwiftType = [UInt64] -/** - * Typealias from the type name used in the UDL file to the builtin type. This - * is needed because the UDL type name is used in function/method signatures. - */ -public typealias ByteBuf = Data + public static func write(_ value: [UInt64], into buf: inout [UInt8]) { + let len = Int32(value.count) + writeInt(&buf, len) + for item in value { + FfiConverterUInt64.write(item, into: &buf) + } + } + + public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> [UInt64] { + let len: Int32 = try readInt(&buf) + var seq = [UInt64]() + seq.reserveCapacity(Int(len)) + for _ in 0 ..< len { + seq.append(try FfiConverterUInt64.read(from: &buf)) + } + return seq + } +} #if swift(>=5.8) @_documentation(visibility: private) #endif -public struct FfiConverterTypeByteBuf: FfiConverter { - public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> ByteBuf { - return try FfiConverterData.read(from: &buf) +fileprivate struct FfiConverterSequenceString: FfiConverterRustBuffer { + typealias SwiftType = [String] + + public static func write(_ value: [String], into buf: inout [UInt8]) { + let len = Int32(value.count) + writeInt(&buf, len) + for item in value { + FfiConverterString.write(item, into: &buf) + } } - public static func write(_ value: ByteBuf, into buf: inout [UInt8]) { - return FfiConverterData.write(value, into: &buf) + public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> [String] { + let len: Int32 = try readInt(&buf) + var seq = [String]() + seq.reserveCapacity(Int(len)) + for _ in 0 ..< len { + seq.append(try FfiConverterString.read(from: &buf)) + } + return seq } +} + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +fileprivate struct FfiConverterSequenceData: FfiConverterRustBuffer { + typealias SwiftType = [Data] - public static func lift(_ value: RustBuffer) throws -> ByteBuf { - return try FfiConverterData.lift(value) + public static func write(_ value: [Data], into buf: inout [UInt8]) { + let len = Int32(value.count) + writeInt(&buf, len) + for item in value { + FfiConverterData.write(item, into: &buf) + } } - public static func lower(_ value: ByteBuf) -> RustBuffer { - return FfiConverterData.lower(value) + public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> [Data] { + let len: Int32 = try readInt(&buf) + var seq = [Data]() + seq.reserveCapacity(Int(len)) + for _ in 0 ..< len { + seq.append(try FfiConverterData.read(from: &buf)) + } + return seq } } +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +fileprivate struct FfiConverterSequenceTypeBoxReference: FfiConverterRustBuffer { + typealias SwiftType = [BoxReference] + + public static func write(_ value: [BoxReference], into buf: inout [UInt8]) { + let len = Int32(value.count) + writeInt(&buf, len) + for item in value { + FfiConverterTypeBoxReference.write(item, into: &buf) + } + } + + public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> [BoxReference] { + let len: Int32 = try readInt(&buf) + var seq = [BoxReference]() + seq.reserveCapacity(Int(len)) + for _ in 0 ..< len { + seq.append(try FfiConverterTypeBoxReference.read(from: &buf)) + } + return seq + } +} #if swift(>=5.8) @_documentation(visibility: private) #endif -public func FfiConverterTypeByteBuf_lift(_ value: RustBuffer) throws -> ByteBuf { - return try FfiConverterTypeByteBuf.lift(value) +fileprivate struct FfiConverterSequenceTypeMultisigSubsignature: FfiConverterRustBuffer { + typealias SwiftType = [MultisigSubsignature] + + public static func write(_ value: [MultisigSubsignature], into buf: inout [UInt8]) { + let len = Int32(value.count) + writeInt(&buf, len) + for item in value { + FfiConverterTypeMultisigSubsignature.write(item, into: &buf) + } + } + + public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> [MultisigSubsignature] { + let len: Int32 = try readInt(&buf) + var seq = [MultisigSubsignature]() + seq.reserveCapacity(Int(len)) + for _ in 0 ..< len { + seq.append(try FfiConverterTypeMultisigSubsignature.read(from: &buf)) + } + return seq + } } #if swift(>=5.8) @_documentation(visibility: private) #endif -public func FfiConverterTypeByteBuf_lower(_ value: ByteBuf) -> RustBuffer { - return FfiConverterTypeByteBuf.lower(value) +fileprivate struct FfiConverterSequenceTypeSignedTransaction: FfiConverterRustBuffer { + typealias SwiftType = [SignedTransaction] + + public static func write(_ value: [SignedTransaction], into buf: inout [UInt8]) { + let len = Int32(value.count) + writeInt(&buf, len) + for item in value { + FfiConverterTypeSignedTransaction.write(item, into: &buf) + } + } + + public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> [SignedTransaction] { + let len: Int32 = try readInt(&buf) + var seq = [SignedTransaction]() + seq.reserveCapacity(Int(len)) + for _ in 0 ..< len { + seq.append(try FfiConverterTypeSignedTransaction.read(from: &buf)) + } + return seq + } } -public func addressFromPubKey(pubKey: Data)throws -> Address { - return try FfiConverterTypeAddress.lift(try rustCallWithError(FfiConverterTypeAlgoKitTransactError.lift) { - uniffi_algokit_transact_ffi_fn_func_address_from_pub_key( - FfiConverterData.lower(pubKey),$0 +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +fileprivate struct FfiConverterSequenceTypeTransaction: FfiConverterRustBuffer { + typealias SwiftType = [Transaction] + + public static func write(_ value: [Transaction], into buf: inout [UInt8]) { + let len = Int32(value.count) + writeInt(&buf, len) + for item in value { + FfiConverterTypeTransaction.write(item, into: &buf) + } + } + + public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> [Transaction] { + let len: Int32 = try readInt(&buf) + var seq = [Transaction]() + seq.reserveCapacity(Int(len)) + for _ in 0 ..< len { + seq.append(try FfiConverterTypeTransaction.read(from: &buf)) + } + return seq + } +} +/** + * Returns the address of the multisignature account. + * + * # Errors + * /// Returns [`AlgoKitTransactError`] if the multisignature signature is invalid or the address cannot be derived. + */ +public func addressFromMultisigSignature(multisigSignature: MultisigSignature)throws -> String { + return try FfiConverterString.lift(try rustCallWithError(FfiConverterTypeAlgoKitTransactError_lift) { + uniffi_algokit_transact_ffi_fn_func_address_from_multisig_signature( + FfiConverterTypeMultisigSignature_lower(multisigSignature),$0 ) }) } -public func addressFromString(address: String)throws -> Address { - return try FfiConverterTypeAddress.lift(try rustCallWithError(FfiConverterTypeAlgoKitTransactError.lift) { - uniffi_algokit_transact_ffi_fn_func_address_from_string( - FfiConverterString.lower(address),$0 +public func addressFromPublicKey(publicKey: Data)throws -> String { + return try FfiConverterString.lift(try rustCallWithError(FfiConverterTypeAlgoKitTransactError_lift) { + uniffi_algokit_transact_ffi_fn_func_address_from_public_key( + FfiConverterData.lower(publicKey),$0 + ) +}) +} +/** + * Applies a subsignature for a participant to a multisignature signature, replacing any existing signature. + * + * # Errors + * + * Returns [`AlgoKitTransactError`] if the participant address is invalid or not found, or if the signature bytes are invalid. + */ +public func applyMultisigSubsignature(multisigSignature: MultisigSignature, participant: String, subsignature: Data)throws -> MultisigSignature { + return try FfiConverterTypeMultisigSignature_lift(try rustCallWithError(FfiConverterTypeAlgoKitTransactError_lift) { + uniffi_algokit_transact_ffi_fn_func_apply_multisig_subsignature( + FfiConverterTypeMultisigSignature_lower(multisigSignature), + FfiConverterString.lower(participant), + FfiConverterData.lower(subsignature),$0 + ) +}) +} +public func assignFee(transaction: Transaction, feeParams: FeeParams)throws -> Transaction { + return try FfiConverterTypeTransaction_lift(try rustCallWithError(FfiConverterTypeAlgoKitTransactError_lift) { + uniffi_algokit_transact_ffi_fn_func_assign_fee( + FfiConverterTypeTransaction_lower(transaction), + FfiConverterTypeFeeParams_lower(feeParams),$0 + ) +}) +} +public func calculateFee(transaction: Transaction, feeParams: FeeParams)throws -> UInt64 { + return try FfiConverterUInt64.lift(try rustCallWithError(FfiConverterTypeAlgoKitTransactError_lift) { + uniffi_algokit_transact_ffi_fn_func_calculate_fee( + FfiConverterTypeTransaction_lower(transaction), + FfiConverterTypeFeeParams_lower(feeParams),$0 + ) +}) +} +/** + * Decodes a signed transaction. + * + * # Parameters + * * `encoded_signed_transaction` - The MsgPack encoded signed transaction bytes + * + * # Returns + * The decoded SignedTransaction or an error if decoding fails. + */ +public func decodeSignedTransaction(encodedSignedTransaction: Data)throws -> SignedTransaction { + return try FfiConverterTypeSignedTransaction_lift(try rustCallWithError(FfiConverterTypeAlgoKitTransactError_lift) { + uniffi_algokit_transact_ffi_fn_func_decode_signed_transaction( + FfiConverterData.lower(encodedSignedTransaction),$0 ) }) } -public func attachSignature(encodedTx: Data, signature: Data)throws -> Data { - return try FfiConverterData.lift(try rustCallWithError(FfiConverterTypeAlgoKitTransactError.lift) { - uniffi_algokit_transact_ffi_fn_func_attach_signature( - FfiConverterData.lower(encodedTx), - FfiConverterData.lower(signature),$0 +/** + * Decodes a collection of MsgPack bytes into a signed transaction collection. + * + * # Parameters + * * `encoded_signed_transactions` - A collection of MsgPack encoded bytes, each representing a signed transaction. + * + * # Returns + * A collection of decoded signed transactions or an error if decoding fails. + */ +public func decodeSignedTransactions(encodedSignedTransactions: [Data])throws -> [SignedTransaction] { + return try FfiConverterSequenceTypeSignedTransaction.lift(try rustCallWithError(FfiConverterTypeAlgoKitTransactError_lift) { + uniffi_algokit_transact_ffi_fn_func_decode_signed_transactions( + FfiConverterSequenceData.lower(encodedSignedTransactions),$0 ) }) } -public func decodeTransaction(bytes: Data)throws -> Transaction { - return try FfiConverterTypeTransaction.lift(try rustCallWithError(FfiConverterTypeAlgoKitTransactError.lift) { +/** + * Decodes MsgPack bytes into a transaction. + * + * # Parameters + * * `encoded_tx` - MsgPack encoded bytes representing a transaction. + * + * # Returns + * A decoded transaction or an error if decoding fails. + */ +public func decodeTransaction(encodedTx: Data)throws -> Transaction { + return try FfiConverterTypeTransaction_lift(try rustCallWithError(FfiConverterTypeAlgoKitTransactError_lift) { uniffi_algokit_transact_ffi_fn_func_decode_transaction( - FfiConverterData.lower(bytes),$0 + FfiConverterData.lower(encodedTx),$0 + ) +}) +} +/** + * Decodes a collection of MsgPack bytes into a transaction collection. + * + * # Parameters + * * `encoded_txs` - A collection of MsgPack encoded bytes, each representing a transaction. + * + * # Returns + * A collection of decoded transactions or an error if decoding fails. + */ +public func decodeTransactions(encodedTxs: [Data])throws -> [Transaction] { + return try FfiConverterSequenceTypeTransaction.lift(try rustCallWithError(FfiConverterTypeAlgoKitTransactError_lift) { + uniffi_algokit_transact_ffi_fn_func_decode_transactions( + FfiConverterSequenceData.lower(encodedTxs),$0 + ) +}) +} +/** + * Encode a signed transaction to MsgPack for sending on the network. + * + * This method performs canonical encoding. No domain separation prefix is applicable. + * + * # Parameters + * * `signed_transaction` - The signed transaction to encode + * + * # Returns + * The MsgPack encoded bytes or an error if encoding fails. + */ +public func encodeSignedTransaction(signedTransaction: SignedTransaction)throws -> Data { + return try FfiConverterData.lift(try rustCallWithError(FfiConverterTypeAlgoKitTransactError_lift) { + uniffi_algokit_transact_ffi_fn_func_encode_signed_transaction( + FfiConverterTypeSignedTransaction_lower(signedTransaction),$0 + ) +}) +} +/** + * Encode signed transactions to MsgPack for sending on the network. + * + * This method performs canonical encoding. No domain separation prefix is applicable. + * + * # Parameters + * * `signed_transactions` - A collection of signed transactions to encode + * + * # Returns + * A collection of MsgPack encoded bytes or an error if encoding fails. + */ +public func encodeSignedTransactions(signedTransactions: [SignedTransaction])throws -> [Data] { + return try FfiConverterSequenceData.lift(try rustCallWithError(FfiConverterTypeAlgoKitTransactError_lift) { + uniffi_algokit_transact_ffi_fn_func_encode_signed_transactions( + FfiConverterSequenceTypeSignedTransaction.lower(signedTransactions),$0 ) }) } /** * Encode the transaction with the domain separation (e.g. "TX") prefix */ -public func encodeTransaction(tx: Transaction)throws -> Data { - return try FfiConverterData.lift(try rustCallWithError(FfiConverterTypeAlgoKitTransactError.lift) { +public func encodeTransaction(transaction: Transaction)throws -> Data { + return try FfiConverterData.lift(try rustCallWithError(FfiConverterTypeAlgoKitTransactError_lift) { uniffi_algokit_transact_ffi_fn_func_encode_transaction( - FfiConverterTypeTransaction.lower(tx),$0 + FfiConverterTypeTransaction_lower(transaction),$0 ) }) } @@ -1353,10 +3661,26 @@ public func encodeTransaction(tx: Transaction)throws -> Data { * Encode the transaction without the domain separation (e.g. "TX") prefix * This is useful for encoding the transaction for signing with tools that automatically add "TX" prefix to the transaction bytes. */ -public func encodeTransactionRaw(tx: Transaction)throws -> Data { - return try FfiConverterData.lift(try rustCallWithError(FfiConverterTypeAlgoKitTransactError.lift) { +public func encodeTransactionRaw(transaction: Transaction)throws -> Data { + return try FfiConverterData.lift(try rustCallWithError(FfiConverterTypeAlgoKitTransactError_lift) { uniffi_algokit_transact_ffi_fn_func_encode_transaction_raw( - FfiConverterTypeTransaction.lower(tx),$0 + FfiConverterTypeTransaction_lower(transaction),$0 + ) +}) +} +/** + * Encode transactions to MsgPack with the domain separation (e.g. "TX") prefix. + * + * # Parameters + * * `transactions` - A collection of transactions to encode + * + * # Returns + * A collection of MsgPack encoded bytes or an error if encoding fails. + */ +public func encodeTransactions(transactions: [Transaction])throws -> [Data] { + return try FfiConverterSequenceData.lift(try rustCallWithError(FfiConverterTypeAlgoKitTransactError_lift) { + uniffi_algokit_transact_ffi_fn_func_encode_transactions( + FfiConverterSequenceTypeTransaction.lower(transactions),$0 ) }) } @@ -1364,17 +3688,17 @@ public func encodeTransactionRaw(tx: Transaction)throws -> Data { * Return the size of the transaction in bytes as if it was already signed and encoded. * This is useful for estimating the fee for the transaction. */ -public func estimateTransactionSize(transaction: Transaction)throws -> UInt64 { - return try FfiConverterUInt64.lift(try rustCallWithError(FfiConverterTypeAlgoKitTransactError.lift) { +public func estimateTransactionSize(transaction: Transaction)throws -> UInt64 { + return try FfiConverterUInt64.lift(try rustCallWithError(FfiConverterTypeAlgoKitTransactError_lift) { uniffi_algokit_transact_ffi_fn_func_estimate_transaction_size( - FfiConverterTypeTransaction.lower(transaction),$0 + FfiConverterTypeTransaction_lower(transaction),$0 ) }) } -public func getAlgorandConstant(constant: AlgorandConstant) -> UInt64 { +public func getAlgorandConstant(constant: AlgorandConstant) -> UInt64 { return try! FfiConverterUInt64.lift(try! rustCall() { uniffi_algokit_transact_ffi_fn_func_get_algorand_constant( - FfiConverterTypeAlgorandConstant.lower(constant),$0 + FfiConverterTypeAlgorandConstant_lower(constant),$0 ) }) } @@ -1382,30 +3706,91 @@ public func getAlgorandConstant(constant: AlgorandConstant) -> UInt64 { * Get the transaction type from the encoded transaction. * This is particularly useful when decoding a transaction that has an unknown type */ -public func getEncodedTransactionType(bytes: Data)throws -> TransactionType { - return try FfiConverterTypeTransactionType.lift(try rustCallWithError(FfiConverterTypeAlgoKitTransactError.lift) { +public func getEncodedTransactionType(encodedTransaction: Data)throws -> TransactionType { + return try FfiConverterTypeTransactionType_lift(try rustCallWithError(FfiConverterTypeAlgoKitTransactError_lift) { uniffi_algokit_transact_ffi_fn_func_get_encoded_transaction_type( - FfiConverterData.lower(bytes),$0 + FfiConverterData.lower(encodedTransaction),$0 ) }) } /** * Get the base32 transaction ID string for a transaction. */ -public func getTransactionId(tx: Transaction)throws -> String { - return try FfiConverterString.lift(try rustCallWithError(FfiConverterTypeAlgoKitTransactError.lift) { +public func getTransactionId(transaction: Transaction)throws -> String { + return try FfiConverterString.lift(try rustCallWithError(FfiConverterTypeAlgoKitTransactError_lift) { uniffi_algokit_transact_ffi_fn_func_get_transaction_id( - FfiConverterTypeTransaction.lower(tx),$0 + FfiConverterTypeTransaction_lower(transaction),$0 ) }) } /** * Get the raw 32-byte transaction ID for a transaction. */ -public func getTransactionIdRaw(tx: Transaction)throws -> Data { - return try FfiConverterData.lift(try rustCallWithError(FfiConverterTypeAlgoKitTransactError.lift) { +public func getTransactionIdRaw(transaction: Transaction)throws -> Data { + return try FfiConverterData.lift(try rustCallWithError(FfiConverterTypeAlgoKitTransactError_lift) { uniffi_algokit_transact_ffi_fn_func_get_transaction_id_raw( - FfiConverterTypeTransaction.lower(tx),$0 + FfiConverterTypeTransaction_lower(transaction),$0 + ) +}) +} +/** + * Groups a collection of transactions by calculating and assigning the group to each transaction. + */ +public func groupTransactions(transactions: [Transaction])throws -> [Transaction] { + return try FfiConverterSequenceTypeTransaction.lift(try rustCallWithError(FfiConverterTypeAlgoKitTransactError_lift) { + uniffi_algokit_transact_ffi_fn_func_group_transactions( + FfiConverterSequenceTypeTransaction.lower(transactions),$0 + ) +}) +} +/** + * Merges two multisignature signatures, replacing signatures in the first with those from the second where present. + * + * # Errors + * + * Returns [`AlgoKitTransactError`] if the multisignature parameters or participants do not match. + */ +public func mergeMultisignatures(multisigSignatureA: MultisigSignature, multisigSignatureB: MultisigSignature)throws -> MultisigSignature { + return try FfiConverterTypeMultisigSignature_lift(try rustCallWithError(FfiConverterTypeAlgoKitTransactError_lift) { + uniffi_algokit_transact_ffi_fn_func_merge_multisignatures( + FfiConverterTypeMultisigSignature_lower(multisigSignatureA), + FfiConverterTypeMultisigSignature_lower(multisigSignatureB),$0 + ) +}) +} +/** + * Creates an empty multisignature signature from a list of participant addresses. + * + * # Errors + * + * Returns [`AlgoKitTransactError`] if any address is invalid or the multisignature parameters are invalid. + */ +public func newMultisigSignature(version: UInt8, threshold: UInt8, participants: [String])throws -> MultisigSignature { + return try FfiConverterTypeMultisigSignature_lift(try rustCallWithError(FfiConverterTypeAlgoKitTransactError_lift) { + uniffi_algokit_transact_ffi_fn_func_new_multisig_signature( + FfiConverterUInt8.lower(version), + FfiConverterUInt8.lower(threshold), + FfiConverterSequenceString.lower(participants),$0 + ) +}) +} +/** + * Returns the list of participant addresses from a multisignature signature. + * + * # Errors + * Returns [`AlgoKitTransactError`] if the multisignature is invalid. + */ +public func participantsFromMultisigSignature(multisigSignature: MultisigSignature)throws -> [String] { + return try FfiConverterSequenceString.lift(try rustCallWithError(FfiConverterTypeAlgoKitTransactError_lift) { + uniffi_algokit_transact_ffi_fn_func_participants_from_multisig_signature( + FfiConverterTypeMultisigSignature_lower(multisigSignature),$0 + ) +}) +} +public func publicKeyFromAddress(address: String)throws -> Data { + return try FfiConverterData.lift(try rustCallWithError(FfiConverterTypeAlgoKitTransactError_lift) { + uniffi_algokit_transact_ffi_fn_func_public_key_from_address( + FfiConverterString.lower(address),$0 ) }) } @@ -1419,28 +3804,52 @@ private enum InitializationResult { // the code inside is only computed once. private let initializationResult: InitializationResult = { // Get the bindings contract version from our ComponentInterface - let bindings_contract_version = 26 + let bindings_contract_version = 29 // Get the scaffolding contract version by calling the into the dylib let scaffolding_contract_version = ffi_algokit_transact_ffi_uniffi_contract_version() if bindings_contract_version != scaffolding_contract_version { return InitializationResult.contractVersionMismatch } - if (uniffi_algokit_transact_ffi_checksum_func_address_from_pub_key() != 65205) { + if (uniffi_algokit_transact_ffi_checksum_func_address_from_multisig_signature() != 51026) { + return InitializationResult.apiChecksumMismatch + } + if (uniffi_algokit_transact_ffi_checksum_func_address_from_public_key() != 10716) { + return InitializationResult.apiChecksumMismatch + } + if (uniffi_algokit_transact_ffi_checksum_func_apply_multisig_subsignature() != 42634) { + return InitializationResult.apiChecksumMismatch + } + if (uniffi_algokit_transact_ffi_checksum_func_assign_fee() != 35003) { + return InitializationResult.apiChecksumMismatch + } + if (uniffi_algokit_transact_ffi_checksum_func_calculate_fee() != 7537) { + return InitializationResult.apiChecksumMismatch + } + if (uniffi_algokit_transact_ffi_checksum_func_decode_signed_transaction() != 43569) { return InitializationResult.apiChecksumMismatch } - if (uniffi_algokit_transact_ffi_checksum_func_address_from_string() != 56499) { + if (uniffi_algokit_transact_ffi_checksum_func_decode_signed_transactions() != 62888) { return InitializationResult.apiChecksumMismatch } - if (uniffi_algokit_transact_ffi_checksum_func_attach_signature() != 7369) { + if (uniffi_algokit_transact_ffi_checksum_func_decode_transaction() != 56405) { return InitializationResult.apiChecksumMismatch } - if (uniffi_algokit_transact_ffi_checksum_func_decode_transaction() != 38127) { + if (uniffi_algokit_transact_ffi_checksum_func_decode_transactions() != 26956) { return InitializationResult.apiChecksumMismatch } - if (uniffi_algokit_transact_ffi_checksum_func_encode_transaction() != 62809) { + if (uniffi_algokit_transact_ffi_checksum_func_encode_signed_transaction() != 47064) { return InitializationResult.apiChecksumMismatch } - if (uniffi_algokit_transact_ffi_checksum_func_encode_transaction_raw() != 1774) { + if (uniffi_algokit_transact_ffi_checksum_func_encode_signed_transactions() != 1956) { + return InitializationResult.apiChecksumMismatch + } + if (uniffi_algokit_transact_ffi_checksum_func_encode_transaction() != 11275) { + return InitializationResult.apiChecksumMismatch + } + if (uniffi_algokit_transact_ffi_checksum_func_encode_transaction_raw() != 384) { + return InitializationResult.apiChecksumMismatch + } + if (uniffi_algokit_transact_ffi_checksum_func_encode_transactions() != 59611) { return InitializationResult.apiChecksumMismatch } if (uniffi_algokit_transact_ffi_checksum_func_estimate_transaction_size() != 60858) { @@ -1449,20 +3858,37 @@ private let initializationResult: InitializationResult = { if (uniffi_algokit_transact_ffi_checksum_func_get_algorand_constant() != 49400) { return InitializationResult.apiChecksumMismatch } - if (uniffi_algokit_transact_ffi_checksum_func_get_encoded_transaction_type() != 9866) { + if (uniffi_algokit_transact_ffi_checksum_func_get_encoded_transaction_type() != 42551) { + return InitializationResult.apiChecksumMismatch + } + if (uniffi_algokit_transact_ffi_checksum_func_get_transaction_id() != 10957) { + return InitializationResult.apiChecksumMismatch + } + if (uniffi_algokit_transact_ffi_checksum_func_get_transaction_id_raw() != 48975) { + return InitializationResult.apiChecksumMismatch + } + if (uniffi_algokit_transact_ffi_checksum_func_group_transactions() != 18193) { + return InitializationResult.apiChecksumMismatch + } + if (uniffi_algokit_transact_ffi_checksum_func_merge_multisignatures() != 58688) { + return InitializationResult.apiChecksumMismatch + } + if (uniffi_algokit_transact_ffi_checksum_func_new_multisig_signature() != 29314) { return InitializationResult.apiChecksumMismatch } - if (uniffi_algokit_transact_ffi_checksum_func_get_transaction_id() != 20463) { + if (uniffi_algokit_transact_ffi_checksum_func_participants_from_multisig_signature() != 25095) { return InitializationResult.apiChecksumMismatch } - if (uniffi_algokit_transact_ffi_checksum_func_get_transaction_id_raw() != 37098) { + if (uniffi_algokit_transact_ffi_checksum_func_public_key_from_address() != 58152) { return InitializationResult.apiChecksumMismatch } return InitializationResult.ok }() -private func uniffiEnsureInitialized() { +// Make the ensure init function public so that other modules which have external type references to +// our types can call it. +public func uniffiEnsureAlgokitTransactFfiInitialized() { switch initializationResult { case .ok: break diff --git a/packages/swift/AlgoKitTransact/Frameworks/algokit_transact.xcframework/ios-arm64_x86_64-maccatalyst/Headers/algokit_transactFFI.h b/packages/swift/AlgoKitTransact/Frameworks/algokit_transact.xcframework/ios-arm64_x86_64-maccatalyst/Headers/algokit_transactFFI.h index 5f1185624..d6dd1e874 100644 --- a/packages/swift/AlgoKitTransact/Frameworks/algokit_transact.xcframework/ios-arm64_x86_64-maccatalyst/Headers/algokit_transactFFI.h +++ b/packages/swift/AlgoKitTransact/Frameworks/algokit_transact.xcframework/ios-arm64_x86_64-maccatalyst/Headers/algokit_transactFFI.h @@ -251,34 +251,74 @@ typedef void (*UniffiForeignFutureCompleteVoid)(uint64_t, UniffiForeignFutureStr ); #endif -#ifndef UNIFFI_FFIDEF_UNIFFI_ALGOKIT_TRANSACT_FFI_FN_FUNC_ADDRESS_FROM_PUB_KEY -#define UNIFFI_FFIDEF_UNIFFI_ALGOKIT_TRANSACT_FFI_FN_FUNC_ADDRESS_FROM_PUB_KEY -RustBuffer uniffi_algokit_transact_ffi_fn_func_address_from_pub_key(RustBuffer pub_key, RustCallStatus *_Nonnull out_status +#ifndef UNIFFI_FFIDEF_UNIFFI_ALGOKIT_TRANSACT_FFI_FN_FUNC_ADDRESS_FROM_MULTISIG_SIGNATURE +#define UNIFFI_FFIDEF_UNIFFI_ALGOKIT_TRANSACT_FFI_FN_FUNC_ADDRESS_FROM_MULTISIG_SIGNATURE +RustBuffer uniffi_algokit_transact_ffi_fn_func_address_from_multisig_signature(RustBuffer multisig_signature, RustCallStatus *_Nonnull out_status ); #endif -#ifndef UNIFFI_FFIDEF_UNIFFI_ALGOKIT_TRANSACT_FFI_FN_FUNC_ADDRESS_FROM_STRING -#define UNIFFI_FFIDEF_UNIFFI_ALGOKIT_TRANSACT_FFI_FN_FUNC_ADDRESS_FROM_STRING -RustBuffer uniffi_algokit_transact_ffi_fn_func_address_from_string(RustBuffer address, RustCallStatus *_Nonnull out_status +#ifndef UNIFFI_FFIDEF_UNIFFI_ALGOKIT_TRANSACT_FFI_FN_FUNC_ADDRESS_FROM_PUBLIC_KEY +#define UNIFFI_FFIDEF_UNIFFI_ALGOKIT_TRANSACT_FFI_FN_FUNC_ADDRESS_FROM_PUBLIC_KEY +RustBuffer uniffi_algokit_transact_ffi_fn_func_address_from_public_key(RustBuffer public_key, RustCallStatus *_Nonnull out_status ); #endif -#ifndef UNIFFI_FFIDEF_UNIFFI_ALGOKIT_TRANSACT_FFI_FN_FUNC_ATTACH_SIGNATURE -#define UNIFFI_FFIDEF_UNIFFI_ALGOKIT_TRANSACT_FFI_FN_FUNC_ATTACH_SIGNATURE -RustBuffer uniffi_algokit_transact_ffi_fn_func_attach_signature(RustBuffer encoded_tx, RustBuffer signature, RustCallStatus *_Nonnull out_status +#ifndef UNIFFI_FFIDEF_UNIFFI_ALGOKIT_TRANSACT_FFI_FN_FUNC_APPLY_MULTISIG_SUBSIGNATURE +#define UNIFFI_FFIDEF_UNIFFI_ALGOKIT_TRANSACT_FFI_FN_FUNC_APPLY_MULTISIG_SUBSIGNATURE +RustBuffer uniffi_algokit_transact_ffi_fn_func_apply_multisig_subsignature(RustBuffer multisig_signature, RustBuffer participant, RustBuffer subsignature, RustCallStatus *_Nonnull out_status +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_ALGOKIT_TRANSACT_FFI_FN_FUNC_ASSIGN_FEE +#define UNIFFI_FFIDEF_UNIFFI_ALGOKIT_TRANSACT_FFI_FN_FUNC_ASSIGN_FEE +RustBuffer uniffi_algokit_transact_ffi_fn_func_assign_fee(RustBuffer transaction, RustBuffer fee_params, RustCallStatus *_Nonnull out_status +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_ALGOKIT_TRANSACT_FFI_FN_FUNC_CALCULATE_FEE +#define UNIFFI_FFIDEF_UNIFFI_ALGOKIT_TRANSACT_FFI_FN_FUNC_CALCULATE_FEE +uint64_t uniffi_algokit_transact_ffi_fn_func_calculate_fee(RustBuffer transaction, RustBuffer fee_params, RustCallStatus *_Nonnull out_status +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_ALGOKIT_TRANSACT_FFI_FN_FUNC_DECODE_SIGNED_TRANSACTION +#define UNIFFI_FFIDEF_UNIFFI_ALGOKIT_TRANSACT_FFI_FN_FUNC_DECODE_SIGNED_TRANSACTION +RustBuffer uniffi_algokit_transact_ffi_fn_func_decode_signed_transaction(RustBuffer encoded_signed_transaction, RustCallStatus *_Nonnull out_status +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_ALGOKIT_TRANSACT_FFI_FN_FUNC_DECODE_SIGNED_TRANSACTIONS +#define UNIFFI_FFIDEF_UNIFFI_ALGOKIT_TRANSACT_FFI_FN_FUNC_DECODE_SIGNED_TRANSACTIONS +RustBuffer uniffi_algokit_transact_ffi_fn_func_decode_signed_transactions(RustBuffer encoded_signed_transactions, RustCallStatus *_Nonnull out_status ); #endif #ifndef UNIFFI_FFIDEF_UNIFFI_ALGOKIT_TRANSACT_FFI_FN_FUNC_DECODE_TRANSACTION #define UNIFFI_FFIDEF_UNIFFI_ALGOKIT_TRANSACT_FFI_FN_FUNC_DECODE_TRANSACTION -RustBuffer uniffi_algokit_transact_ffi_fn_func_decode_transaction(RustBuffer bytes, RustCallStatus *_Nonnull out_status +RustBuffer uniffi_algokit_transact_ffi_fn_func_decode_transaction(RustBuffer encoded_tx, RustCallStatus *_Nonnull out_status +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_ALGOKIT_TRANSACT_FFI_FN_FUNC_DECODE_TRANSACTIONS +#define UNIFFI_FFIDEF_UNIFFI_ALGOKIT_TRANSACT_FFI_FN_FUNC_DECODE_TRANSACTIONS +RustBuffer uniffi_algokit_transact_ffi_fn_func_decode_transactions(RustBuffer encoded_txs, RustCallStatus *_Nonnull out_status +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_ALGOKIT_TRANSACT_FFI_FN_FUNC_ENCODE_SIGNED_TRANSACTION +#define UNIFFI_FFIDEF_UNIFFI_ALGOKIT_TRANSACT_FFI_FN_FUNC_ENCODE_SIGNED_TRANSACTION +RustBuffer uniffi_algokit_transact_ffi_fn_func_encode_signed_transaction(RustBuffer signed_transaction, RustCallStatus *_Nonnull out_status +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_ALGOKIT_TRANSACT_FFI_FN_FUNC_ENCODE_SIGNED_TRANSACTIONS +#define UNIFFI_FFIDEF_UNIFFI_ALGOKIT_TRANSACT_FFI_FN_FUNC_ENCODE_SIGNED_TRANSACTIONS +RustBuffer uniffi_algokit_transact_ffi_fn_func_encode_signed_transactions(RustBuffer signed_transactions, RustCallStatus *_Nonnull out_status ); #endif #ifndef UNIFFI_FFIDEF_UNIFFI_ALGOKIT_TRANSACT_FFI_FN_FUNC_ENCODE_TRANSACTION #define UNIFFI_FFIDEF_UNIFFI_ALGOKIT_TRANSACT_FFI_FN_FUNC_ENCODE_TRANSACTION -RustBuffer uniffi_algokit_transact_ffi_fn_func_encode_transaction(RustBuffer tx, RustCallStatus *_Nonnull out_status +RustBuffer uniffi_algokit_transact_ffi_fn_func_encode_transaction(RustBuffer transaction, RustCallStatus *_Nonnull out_status ); #endif #ifndef UNIFFI_FFIDEF_UNIFFI_ALGOKIT_TRANSACT_FFI_FN_FUNC_ENCODE_TRANSACTION_RAW #define UNIFFI_FFIDEF_UNIFFI_ALGOKIT_TRANSACT_FFI_FN_FUNC_ENCODE_TRANSACTION_RAW -RustBuffer uniffi_algokit_transact_ffi_fn_func_encode_transaction_raw(RustBuffer tx, RustCallStatus *_Nonnull out_status +RustBuffer uniffi_algokit_transact_ffi_fn_func_encode_transaction_raw(RustBuffer transaction, RustCallStatus *_Nonnull out_status +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_ALGOKIT_TRANSACT_FFI_FN_FUNC_ENCODE_TRANSACTIONS +#define UNIFFI_FFIDEF_UNIFFI_ALGOKIT_TRANSACT_FFI_FN_FUNC_ENCODE_TRANSACTIONS +RustBuffer uniffi_algokit_transact_ffi_fn_func_encode_transactions(RustBuffer transactions, RustCallStatus *_Nonnull out_status ); #endif #ifndef UNIFFI_FFIDEF_UNIFFI_ALGOKIT_TRANSACT_FFI_FN_FUNC_ESTIMATE_TRANSACTION_SIZE @@ -293,17 +333,42 @@ uint64_t uniffi_algokit_transact_ffi_fn_func_get_algorand_constant(RustBuffer co #endif #ifndef UNIFFI_FFIDEF_UNIFFI_ALGOKIT_TRANSACT_FFI_FN_FUNC_GET_ENCODED_TRANSACTION_TYPE #define UNIFFI_FFIDEF_UNIFFI_ALGOKIT_TRANSACT_FFI_FN_FUNC_GET_ENCODED_TRANSACTION_TYPE -RustBuffer uniffi_algokit_transact_ffi_fn_func_get_encoded_transaction_type(RustBuffer bytes, RustCallStatus *_Nonnull out_status +RustBuffer uniffi_algokit_transact_ffi_fn_func_get_encoded_transaction_type(RustBuffer encoded_transaction, RustCallStatus *_Nonnull out_status ); #endif #ifndef UNIFFI_FFIDEF_UNIFFI_ALGOKIT_TRANSACT_FFI_FN_FUNC_GET_TRANSACTION_ID #define UNIFFI_FFIDEF_UNIFFI_ALGOKIT_TRANSACT_FFI_FN_FUNC_GET_TRANSACTION_ID -RustBuffer uniffi_algokit_transact_ffi_fn_func_get_transaction_id(RustBuffer tx, RustCallStatus *_Nonnull out_status +RustBuffer uniffi_algokit_transact_ffi_fn_func_get_transaction_id(RustBuffer transaction, RustCallStatus *_Nonnull out_status ); #endif #ifndef UNIFFI_FFIDEF_UNIFFI_ALGOKIT_TRANSACT_FFI_FN_FUNC_GET_TRANSACTION_ID_RAW #define UNIFFI_FFIDEF_UNIFFI_ALGOKIT_TRANSACT_FFI_FN_FUNC_GET_TRANSACTION_ID_RAW -RustBuffer uniffi_algokit_transact_ffi_fn_func_get_transaction_id_raw(RustBuffer tx, RustCallStatus *_Nonnull out_status +RustBuffer uniffi_algokit_transact_ffi_fn_func_get_transaction_id_raw(RustBuffer transaction, RustCallStatus *_Nonnull out_status +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_ALGOKIT_TRANSACT_FFI_FN_FUNC_GROUP_TRANSACTIONS +#define UNIFFI_FFIDEF_UNIFFI_ALGOKIT_TRANSACT_FFI_FN_FUNC_GROUP_TRANSACTIONS +RustBuffer uniffi_algokit_transact_ffi_fn_func_group_transactions(RustBuffer transactions, RustCallStatus *_Nonnull out_status +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_ALGOKIT_TRANSACT_FFI_FN_FUNC_MERGE_MULTISIGNATURES +#define UNIFFI_FFIDEF_UNIFFI_ALGOKIT_TRANSACT_FFI_FN_FUNC_MERGE_MULTISIGNATURES +RustBuffer uniffi_algokit_transact_ffi_fn_func_merge_multisignatures(RustBuffer multisig_signature_a, RustBuffer multisig_signature_b, RustCallStatus *_Nonnull out_status +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_ALGOKIT_TRANSACT_FFI_FN_FUNC_NEW_MULTISIG_SIGNATURE +#define UNIFFI_FFIDEF_UNIFFI_ALGOKIT_TRANSACT_FFI_FN_FUNC_NEW_MULTISIG_SIGNATURE +RustBuffer uniffi_algokit_transact_ffi_fn_func_new_multisig_signature(uint8_t version, uint8_t threshold, RustBuffer participants, RustCallStatus *_Nonnull out_status +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_ALGOKIT_TRANSACT_FFI_FN_FUNC_PARTICIPANTS_FROM_MULTISIG_SIGNATURE +#define UNIFFI_FFIDEF_UNIFFI_ALGOKIT_TRANSACT_FFI_FN_FUNC_PARTICIPANTS_FROM_MULTISIG_SIGNATURE +RustBuffer uniffi_algokit_transact_ffi_fn_func_participants_from_multisig_signature(RustBuffer multisig_signature, RustCallStatus *_Nonnull out_status +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_ALGOKIT_TRANSACT_FFI_FN_FUNC_PUBLIC_KEY_FROM_ADDRESS +#define UNIFFI_FFIDEF_UNIFFI_ALGOKIT_TRANSACT_FFI_FN_FUNC_PUBLIC_KEY_FROM_ADDRESS +RustBuffer uniffi_algokit_transact_ffi_fn_func_public_key_from_address(RustBuffer address, RustCallStatus *_Nonnull out_status ); #endif #ifndef UNIFFI_FFIDEF_FFI_ALGOKIT_TRANSACT_FFI_RUSTBUFFER_ALLOC @@ -586,21 +651,45 @@ void ffi_algokit_transact_ffi_rust_future_free_void(uint64_t handle void ffi_algokit_transact_ffi_rust_future_complete_void(uint64_t handle, RustCallStatus *_Nonnull out_status ); #endif -#ifndef UNIFFI_FFIDEF_UNIFFI_ALGOKIT_TRANSACT_FFI_CHECKSUM_FUNC_ADDRESS_FROM_PUB_KEY -#define UNIFFI_FFIDEF_UNIFFI_ALGOKIT_TRANSACT_FFI_CHECKSUM_FUNC_ADDRESS_FROM_PUB_KEY -uint16_t uniffi_algokit_transact_ffi_checksum_func_address_from_pub_key(void +#ifndef UNIFFI_FFIDEF_UNIFFI_ALGOKIT_TRANSACT_FFI_CHECKSUM_FUNC_ADDRESS_FROM_MULTISIG_SIGNATURE +#define UNIFFI_FFIDEF_UNIFFI_ALGOKIT_TRANSACT_FFI_CHECKSUM_FUNC_ADDRESS_FROM_MULTISIG_SIGNATURE +uint16_t uniffi_algokit_transact_ffi_checksum_func_address_from_multisig_signature(void + +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_ALGOKIT_TRANSACT_FFI_CHECKSUM_FUNC_ADDRESS_FROM_PUBLIC_KEY +#define UNIFFI_FFIDEF_UNIFFI_ALGOKIT_TRANSACT_FFI_CHECKSUM_FUNC_ADDRESS_FROM_PUBLIC_KEY +uint16_t uniffi_algokit_transact_ffi_checksum_func_address_from_public_key(void ); #endif -#ifndef UNIFFI_FFIDEF_UNIFFI_ALGOKIT_TRANSACT_FFI_CHECKSUM_FUNC_ADDRESS_FROM_STRING -#define UNIFFI_FFIDEF_UNIFFI_ALGOKIT_TRANSACT_FFI_CHECKSUM_FUNC_ADDRESS_FROM_STRING -uint16_t uniffi_algokit_transact_ffi_checksum_func_address_from_string(void +#ifndef UNIFFI_FFIDEF_UNIFFI_ALGOKIT_TRANSACT_FFI_CHECKSUM_FUNC_APPLY_MULTISIG_SUBSIGNATURE +#define UNIFFI_FFIDEF_UNIFFI_ALGOKIT_TRANSACT_FFI_CHECKSUM_FUNC_APPLY_MULTISIG_SUBSIGNATURE +uint16_t uniffi_algokit_transact_ffi_checksum_func_apply_multisig_subsignature(void ); #endif -#ifndef UNIFFI_FFIDEF_UNIFFI_ALGOKIT_TRANSACT_FFI_CHECKSUM_FUNC_ATTACH_SIGNATURE -#define UNIFFI_FFIDEF_UNIFFI_ALGOKIT_TRANSACT_FFI_CHECKSUM_FUNC_ATTACH_SIGNATURE -uint16_t uniffi_algokit_transact_ffi_checksum_func_attach_signature(void +#ifndef UNIFFI_FFIDEF_UNIFFI_ALGOKIT_TRANSACT_FFI_CHECKSUM_FUNC_ASSIGN_FEE +#define UNIFFI_FFIDEF_UNIFFI_ALGOKIT_TRANSACT_FFI_CHECKSUM_FUNC_ASSIGN_FEE +uint16_t uniffi_algokit_transact_ffi_checksum_func_assign_fee(void + +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_ALGOKIT_TRANSACT_FFI_CHECKSUM_FUNC_CALCULATE_FEE +#define UNIFFI_FFIDEF_UNIFFI_ALGOKIT_TRANSACT_FFI_CHECKSUM_FUNC_CALCULATE_FEE +uint16_t uniffi_algokit_transact_ffi_checksum_func_calculate_fee(void + +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_ALGOKIT_TRANSACT_FFI_CHECKSUM_FUNC_DECODE_SIGNED_TRANSACTION +#define UNIFFI_FFIDEF_UNIFFI_ALGOKIT_TRANSACT_FFI_CHECKSUM_FUNC_DECODE_SIGNED_TRANSACTION +uint16_t uniffi_algokit_transact_ffi_checksum_func_decode_signed_transaction(void + +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_ALGOKIT_TRANSACT_FFI_CHECKSUM_FUNC_DECODE_SIGNED_TRANSACTIONS +#define UNIFFI_FFIDEF_UNIFFI_ALGOKIT_TRANSACT_FFI_CHECKSUM_FUNC_DECODE_SIGNED_TRANSACTIONS +uint16_t uniffi_algokit_transact_ffi_checksum_func_decode_signed_transactions(void ); #endif @@ -608,6 +697,24 @@ uint16_t uniffi_algokit_transact_ffi_checksum_func_attach_signature(void #define UNIFFI_FFIDEF_UNIFFI_ALGOKIT_TRANSACT_FFI_CHECKSUM_FUNC_DECODE_TRANSACTION uint16_t uniffi_algokit_transact_ffi_checksum_func_decode_transaction(void +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_ALGOKIT_TRANSACT_FFI_CHECKSUM_FUNC_DECODE_TRANSACTIONS +#define UNIFFI_FFIDEF_UNIFFI_ALGOKIT_TRANSACT_FFI_CHECKSUM_FUNC_DECODE_TRANSACTIONS +uint16_t uniffi_algokit_transact_ffi_checksum_func_decode_transactions(void + +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_ALGOKIT_TRANSACT_FFI_CHECKSUM_FUNC_ENCODE_SIGNED_TRANSACTION +#define UNIFFI_FFIDEF_UNIFFI_ALGOKIT_TRANSACT_FFI_CHECKSUM_FUNC_ENCODE_SIGNED_TRANSACTION +uint16_t uniffi_algokit_transact_ffi_checksum_func_encode_signed_transaction(void + +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_ALGOKIT_TRANSACT_FFI_CHECKSUM_FUNC_ENCODE_SIGNED_TRANSACTIONS +#define UNIFFI_FFIDEF_UNIFFI_ALGOKIT_TRANSACT_FFI_CHECKSUM_FUNC_ENCODE_SIGNED_TRANSACTIONS +uint16_t uniffi_algokit_transact_ffi_checksum_func_encode_signed_transactions(void + ); #endif #ifndef UNIFFI_FFIDEF_UNIFFI_ALGOKIT_TRANSACT_FFI_CHECKSUM_FUNC_ENCODE_TRANSACTION @@ -620,6 +727,12 @@ uint16_t uniffi_algokit_transact_ffi_checksum_func_encode_transaction(void #define UNIFFI_FFIDEF_UNIFFI_ALGOKIT_TRANSACT_FFI_CHECKSUM_FUNC_ENCODE_TRANSACTION_RAW uint16_t uniffi_algokit_transact_ffi_checksum_func_encode_transaction_raw(void +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_ALGOKIT_TRANSACT_FFI_CHECKSUM_FUNC_ENCODE_TRANSACTIONS +#define UNIFFI_FFIDEF_UNIFFI_ALGOKIT_TRANSACT_FFI_CHECKSUM_FUNC_ENCODE_TRANSACTIONS +uint16_t uniffi_algokit_transact_ffi_checksum_func_encode_transactions(void + ); #endif #ifndef UNIFFI_FFIDEF_UNIFFI_ALGOKIT_TRANSACT_FFI_CHECKSUM_FUNC_ESTIMATE_TRANSACTION_SIZE @@ -650,6 +763,36 @@ uint16_t uniffi_algokit_transact_ffi_checksum_func_get_transaction_id(void #define UNIFFI_FFIDEF_UNIFFI_ALGOKIT_TRANSACT_FFI_CHECKSUM_FUNC_GET_TRANSACTION_ID_RAW uint16_t uniffi_algokit_transact_ffi_checksum_func_get_transaction_id_raw(void +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_ALGOKIT_TRANSACT_FFI_CHECKSUM_FUNC_GROUP_TRANSACTIONS +#define UNIFFI_FFIDEF_UNIFFI_ALGOKIT_TRANSACT_FFI_CHECKSUM_FUNC_GROUP_TRANSACTIONS +uint16_t uniffi_algokit_transact_ffi_checksum_func_group_transactions(void + +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_ALGOKIT_TRANSACT_FFI_CHECKSUM_FUNC_MERGE_MULTISIGNATURES +#define UNIFFI_FFIDEF_UNIFFI_ALGOKIT_TRANSACT_FFI_CHECKSUM_FUNC_MERGE_MULTISIGNATURES +uint16_t uniffi_algokit_transact_ffi_checksum_func_merge_multisignatures(void + +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_ALGOKIT_TRANSACT_FFI_CHECKSUM_FUNC_NEW_MULTISIG_SIGNATURE +#define UNIFFI_FFIDEF_UNIFFI_ALGOKIT_TRANSACT_FFI_CHECKSUM_FUNC_NEW_MULTISIG_SIGNATURE +uint16_t uniffi_algokit_transact_ffi_checksum_func_new_multisig_signature(void + +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_ALGOKIT_TRANSACT_FFI_CHECKSUM_FUNC_PARTICIPANTS_FROM_MULTISIG_SIGNATURE +#define UNIFFI_FFIDEF_UNIFFI_ALGOKIT_TRANSACT_FFI_CHECKSUM_FUNC_PARTICIPANTS_FROM_MULTISIG_SIGNATURE +uint16_t uniffi_algokit_transact_ffi_checksum_func_participants_from_multisig_signature(void + +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_ALGOKIT_TRANSACT_FFI_CHECKSUM_FUNC_PUBLIC_KEY_FROM_ADDRESS +#define UNIFFI_FFIDEF_UNIFFI_ALGOKIT_TRANSACT_FFI_CHECKSUM_FUNC_PUBLIC_KEY_FROM_ADDRESS +uint16_t uniffi_algokit_transact_ffi_checksum_func_public_key_from_address(void + ); #endif #ifndef UNIFFI_FFIDEF_FFI_ALGOKIT_TRANSACT_FFI_UNIFFI_CONTRACT_VERSION diff --git a/packages/swift/AlgoKitTransact/Frameworks/algokit_transact.xcframework/ios-arm64_x86_64-maccatalyst/Headers/module.modulemap b/packages/swift/AlgoKitTransact/Frameworks/algokit_transact.xcframework/ios-arm64_x86_64-maccatalyst/Headers/module.modulemap index 5c45883d7..861b066ff 100644 --- a/packages/swift/AlgoKitTransact/Frameworks/algokit_transact.xcframework/ios-arm64_x86_64-maccatalyst/Headers/module.modulemap +++ b/packages/swift/AlgoKitTransact/Frameworks/algokit_transact.xcframework/ios-arm64_x86_64-maccatalyst/Headers/module.modulemap @@ -1,4 +1,7 @@ module algokit_transactFFI { header "algokit_transactFFI.h" export * + use "Darwin" + use "_Builtin_stdbool" + use "_Builtin_stdint" } \ No newline at end of file diff --git a/packages/swift/AlgoKitTransact/Frameworks/algokit_transact.xcframework/ios-arm64_x86_64-maccatalyst/libalgokit_transact_ffi-catalyst.a b/packages/swift/AlgoKitTransact/Frameworks/algokit_transact.xcframework/ios-arm64_x86_64-maccatalyst/libalgokit_transact_ffi-catalyst.a index c90b22393..3611308e5 100644 Binary files a/packages/swift/AlgoKitTransact/Frameworks/algokit_transact.xcframework/ios-arm64_x86_64-maccatalyst/libalgokit_transact_ffi-catalyst.a and b/packages/swift/AlgoKitTransact/Frameworks/algokit_transact.xcframework/ios-arm64_x86_64-maccatalyst/libalgokit_transact_ffi-catalyst.a differ diff --git a/packages/swift/AlgoKitTransact/Frameworks/algokit_transact.xcframework/ios-arm64_x86_64-simulator/Headers/algokit_transact.swift b/packages/swift/AlgoKitTransact/Frameworks/algokit_transact.xcframework/ios-arm64_x86_64-simulator/Headers/algokit_transact.swift index 8fe29c207..92e86dfc8 100644 --- a/packages/swift/AlgoKitTransact/Frameworks/algokit_transact.xcframework/ios-arm64_x86_64-simulator/Headers/algokit_transact.swift +++ b/packages/swift/AlgoKitTransact/Frameworks/algokit_transact.xcframework/ios-arm64_x86_64-simulator/Headers/algokit_transact.swift @@ -281,7 +281,7 @@ private func makeRustCall( _ callback: (UnsafeMutablePointer) -> T, errorHandler: ((RustBuffer) throws -> E)? ) throws -> T { - uniffiEnsureInitialized() + uniffiEnsureAlgokitTransactFfiInitialized() var callStatus = RustCallStatus.init() let returnedVal = callback(&callStatus) try uniffiCheckCallStatus(callStatus: callStatus, errorHandler: errorHandler) @@ -352,9 +352,10 @@ private func uniffiTraitInterfaceCallWithError( callStatus.pointee.errorBuf = FfiConverterString.lower(String(describing: error)) } } -fileprivate class UniffiHandleMap { - private var map: [UInt64: T] = [:] +fileprivate final class UniffiHandleMap: @unchecked Sendable { + // All mutation happens with this lock held, which is why we implement @unchecked Sendable. private let lock = NSLock() + private var map: [UInt64: T] = [:] private var currentHandle: UInt64 = 1 func insert(obj: T) -> UInt64 { @@ -396,6 +397,38 @@ fileprivate class UniffiHandleMap { // Public interface members begin here. +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +fileprivate struct FfiConverterUInt8: FfiConverterPrimitive { + typealias FfiType = UInt8 + typealias SwiftType = UInt8 + + public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> UInt8 { + return try lift(readInt(&buf)) + } + + public static func write(_ value: UInt8, into buf: inout [UInt8]) { + writeInt(&buf, lower(value)) + } +} + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +fileprivate struct FfiConverterUInt32: FfiConverterPrimitive { + typealias FfiType = UInt32 + typealias SwiftType = UInt32 + + public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> UInt32 { + return try lift(readInt(&buf)) + } + + public static func write(_ value: SwiftType, into buf: inout [UInt8]) { + writeInt(&buf, lower(value)) + } +} + #if swift(>=5.8) @_documentation(visibility: private) #endif @@ -412,6 +445,30 @@ fileprivate struct FfiConverterUInt64: FfiConverterPrimitive { } } +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +fileprivate struct FfiConverterBool : FfiConverter { + typealias FfiType = Int8 + typealias SwiftType = Bool + + public static func lift(_ value: Int8) throws -> Bool { + return value != 0 + } + + public static func lower(_ value: Bool) -> Int8 { + return value ? 1 : 0 + } + + public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> Bool { + return try lift(readInt(&buf)) + } + + public static func write(_ value: Bool, into buf: inout [UInt8]) { + writeInt(&buf, lower(value)) + } +} + #if swift(>=5.8) @_documentation(visibility: private) #endif @@ -472,53 +529,269 @@ fileprivate struct FfiConverterData: FfiConverterRustBuffer { } -public struct Address { - public var address: String - public var pubKey: ByteBuf +/** + * Represents an app call transaction that interacts with Algorand Smart Contracts. + * + * App call transactions are used to create, update, delete, opt-in to, + * close out of, or clear state from Algorand applications (smart contracts). + */ +public struct AppCallTransactionFields { + /** + * ID of the app being called. + * + * Set this to 0 to indicate an app creation call. + */ + public var appId: UInt64 + /** + * Defines what additional actions occur with the transaction. + */ + public var onComplete: OnApplicationComplete + /** + * Logic executed for every app call transaction, except when + * on-completion is set to "clear". + * + * Approval programs may reject the transaction. + * Only required for app creation and update transactions. + */ + public var approvalProgram: Data? + /** + * Logic executed for app call transactions with on-completion set to "clear". + * + * Clear state programs cannot reject the transaction. + * Only required for app creation and update transactions. + */ + public var clearStateProgram: Data? + /** + * Holds the maximum number of global state values. + * + * Only required for app creation transactions. + * This cannot be changed after creation. + */ + public var globalStateSchema: StateSchema? + /** + * Holds the maximum number of local state values. + * + * Only required for app creation transactions. + * This cannot be changed after creation. + */ + public var localStateSchema: StateSchema? + /** + * Number of additional pages allocated to the app's approval + * and clear state programs. + * + * Each extra program page is 2048 bytes. The sum of approval program + * and clear state program may not exceed 2048*(1+extra_program_pages) bytes. + * Currently, the maximum value is 3. + * This cannot be changed after creation. + */ + public var extraProgramPages: UInt32? + /** + * Transaction specific arguments available in the app's + * approval program and clear state program. + */ + public var args: [Data]? + /** + * List of accounts in addition to the sender that may be accessed + * from the app's approval program and clear state program. + */ + public var accountReferences: [String]? + /** + * List of apps in addition to the current app that may be called + * from the app's approval program and clear state program. + */ + public var appReferences: [UInt64]? + /** + * Lists the assets whose parameters may be accessed by this app's + * approval program and clear state program. + * + * The access is read-only. + */ + public var assetReferences: [UInt64]? + /** + * The boxes that should be made available for the runtime of the program. + */ + public var boxReferences: [BoxReference]? // Default memberwise initializers are never public by default, so we // declare one manually. - public init(address: String, pubKey: ByteBuf) { - self.address = address - self.pubKey = pubKey - } -} - + public init( + /** + * ID of the app being called. + * + * Set this to 0 to indicate an app creation call. + */appId: UInt64, + /** + * Defines what additional actions occur with the transaction. + */onComplete: OnApplicationComplete, + /** + * Logic executed for every app call transaction, except when + * on-completion is set to "clear". + * + * Approval programs may reject the transaction. + * Only required for app creation and update transactions. + */approvalProgram: Data? = nil, + /** + * Logic executed for app call transactions with on-completion set to "clear". + * + * Clear state programs cannot reject the transaction. + * Only required for app creation and update transactions. + */clearStateProgram: Data? = nil, + /** + * Holds the maximum number of global state values. + * + * Only required for app creation transactions. + * This cannot be changed after creation. + */globalStateSchema: StateSchema? = nil, + /** + * Holds the maximum number of local state values. + * + * Only required for app creation transactions. + * This cannot be changed after creation. + */localStateSchema: StateSchema? = nil, + /** + * Number of additional pages allocated to the app's approval + * and clear state programs. + * + * Each extra program page is 2048 bytes. The sum of approval program + * and clear state program may not exceed 2048*(1+extra_program_pages) bytes. + * Currently, the maximum value is 3. + * This cannot be changed after creation. + */extraProgramPages: UInt32? = nil, + /** + * Transaction specific arguments available in the app's + * approval program and clear state program. + */args: [Data]? = nil, + /** + * List of accounts in addition to the sender that may be accessed + * from the app's approval program and clear state program. + */accountReferences: [String]? = nil, + /** + * List of apps in addition to the current app that may be called + * from the app's approval program and clear state program. + */appReferences: [UInt64]? = nil, + /** + * Lists the assets whose parameters may be accessed by this app's + * approval program and clear state program. + * + * The access is read-only. + */assetReferences: [UInt64]? = nil, + /** + * The boxes that should be made available for the runtime of the program. + */boxReferences: [BoxReference]? = nil) { + self.appId = appId + self.onComplete = onComplete + self.approvalProgram = approvalProgram + self.clearStateProgram = clearStateProgram + self.globalStateSchema = globalStateSchema + self.localStateSchema = localStateSchema + self.extraProgramPages = extraProgramPages + self.args = args + self.accountReferences = accountReferences + self.appReferences = appReferences + self.assetReferences = assetReferences + self.boxReferences = boxReferences + } +} + +#if compiler(>=6) +extension AppCallTransactionFields: Sendable {} +#endif -extension Address: Equatable, Hashable { - public static func ==(lhs: Address, rhs: Address) -> Bool { - if lhs.address != rhs.address { +extension AppCallTransactionFields: Equatable, Hashable { + public static func ==(lhs: AppCallTransactionFields, rhs: AppCallTransactionFields) -> Bool { + if lhs.appId != rhs.appId { return false } - if lhs.pubKey != rhs.pubKey { + if lhs.onComplete != rhs.onComplete { + return false + } + if lhs.approvalProgram != rhs.approvalProgram { + return false + } + if lhs.clearStateProgram != rhs.clearStateProgram { + return false + } + if lhs.globalStateSchema != rhs.globalStateSchema { + return false + } + if lhs.localStateSchema != rhs.localStateSchema { + return false + } + if lhs.extraProgramPages != rhs.extraProgramPages { + return false + } + if lhs.args != rhs.args { + return false + } + if lhs.accountReferences != rhs.accountReferences { + return false + } + if lhs.appReferences != rhs.appReferences { + return false + } + if lhs.assetReferences != rhs.assetReferences { + return false + } + if lhs.boxReferences != rhs.boxReferences { return false } return true } public func hash(into hasher: inout Hasher) { - hasher.combine(address) - hasher.combine(pubKey) + hasher.combine(appId) + hasher.combine(onComplete) + hasher.combine(approvalProgram) + hasher.combine(clearStateProgram) + hasher.combine(globalStateSchema) + hasher.combine(localStateSchema) + hasher.combine(extraProgramPages) + hasher.combine(args) + hasher.combine(accountReferences) + hasher.combine(appReferences) + hasher.combine(assetReferences) + hasher.combine(boxReferences) } } + #if swift(>=5.8) @_documentation(visibility: private) #endif -public struct FfiConverterTypeAddress: FfiConverterRustBuffer { - public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> Address { +public struct FfiConverterTypeAppCallTransactionFields: FfiConverterRustBuffer { + public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> AppCallTransactionFields { return - try Address( - address: FfiConverterString.read(from: &buf), - pubKey: FfiConverterTypeByteBuf.read(from: &buf) + try AppCallTransactionFields( + appId: FfiConverterUInt64.read(from: &buf), + onComplete: FfiConverterTypeOnApplicationComplete.read(from: &buf), + approvalProgram: FfiConverterOptionData.read(from: &buf), + clearStateProgram: FfiConverterOptionData.read(from: &buf), + globalStateSchema: FfiConverterOptionTypeStateSchema.read(from: &buf), + localStateSchema: FfiConverterOptionTypeStateSchema.read(from: &buf), + extraProgramPages: FfiConverterOptionUInt32.read(from: &buf), + args: FfiConverterOptionSequenceData.read(from: &buf), + accountReferences: FfiConverterOptionSequenceString.read(from: &buf), + appReferences: FfiConverterOptionSequenceUInt64.read(from: &buf), + assetReferences: FfiConverterOptionSequenceUInt64.read(from: &buf), + boxReferences: FfiConverterOptionSequenceTypeBoxReference.read(from: &buf) ) } - public static func write(_ value: Address, into buf: inout [UInt8]) { - FfiConverterString.write(value.address, into: &buf) - FfiConverterTypeByteBuf.write(value.pubKey, into: &buf) + public static func write(_ value: AppCallTransactionFields, into buf: inout [UInt8]) { + FfiConverterUInt64.write(value.appId, into: &buf) + FfiConverterTypeOnApplicationComplete.write(value.onComplete, into: &buf) + FfiConverterOptionData.write(value.approvalProgram, into: &buf) + FfiConverterOptionData.write(value.clearStateProgram, into: &buf) + FfiConverterOptionTypeStateSchema.write(value.globalStateSchema, into: &buf) + FfiConverterOptionTypeStateSchema.write(value.localStateSchema, into: &buf) + FfiConverterOptionUInt32.write(value.extraProgramPages, into: &buf) + FfiConverterOptionSequenceData.write(value.args, into: &buf) + FfiConverterOptionSequenceString.write(value.accountReferences, into: &buf) + FfiConverterOptionSequenceUInt64.write(value.appReferences, into: &buf) + FfiConverterOptionSequenceUInt64.write(value.assetReferences, into: &buf) + FfiConverterOptionSequenceTypeBoxReference.write(value.boxReferences, into: &buf) } } @@ -526,53 +799,306 @@ public struct FfiConverterTypeAddress: FfiConverterRustBuffer { #if swift(>=5.8) @_documentation(visibility: private) #endif -public func FfiConverterTypeAddress_lift(_ buf: RustBuffer) throws -> Address { - return try FfiConverterTypeAddress.lift(buf) +public func FfiConverterTypeAppCallTransactionFields_lift(_ buf: RustBuffer) throws -> AppCallTransactionFields { + return try FfiConverterTypeAppCallTransactionFields.lift(buf) } #if swift(>=5.8) @_documentation(visibility: private) #endif -public func FfiConverterTypeAddress_lower(_ value: Address) -> RustBuffer { - return FfiConverterTypeAddress.lower(value) +public func FfiConverterTypeAppCallTransactionFields_lower(_ value: AppCallTransactionFields) -> RustBuffer { + return FfiConverterTypeAppCallTransactionFields.lower(value) } -public struct AssetTransferTransactionFields { +/** + * Parameters to define an asset config transaction. + * + * For asset creation, the asset ID field must be 0. + * For asset reconfiguration, the asset ID field must be set. Only fields manager, reserve, freeze, and clawback can be set. + * For asset destroy, the asset ID field must be set, all other fields must not be set. + * + * **Note:** The manager, reserve, freeze, and clawback addresses + * are immutably empty if they are not set. If manager is not set then + * all fields are immutable from that point forward. + */ +public struct AssetConfigTransactionFields { + /** + * ID of the asset to operate on. + * + * For asset creation, this must be 0. + * For asset reconfiguration this is the ID of the existing asset to be reconfigured, + * For asset destroy this is the ID of the existing asset to be destroyed. + */ public var assetId: UInt64 - public var amount: UInt64 - public var receiver: Address - public var assetSender: Address? - public var closeRemainderTo: Address? + /** + * The total amount of the smallest divisible (decimal) unit to create. + * + * Required when creating a new asset. + * For example, if creating a asset with 2 decimals and wanting a total supply of 100 units, this value should be 10000. + * + * This field can only be specified upon asset creation. + */ + public var total: UInt64? + /** + * The amount of decimal places the asset should have. + * + * If unspecified then the asset will be in whole units (i.e. `0`). + * * If 0, the asset is not divisible; + * * If 1, the base unit of the asset is in tenths; + * * If 2, the base unit of the asset is in hundredths; + * * If 3, the base unit of the asset is in thousandths; + * + * and so on up to 19 decimal places. + * + * This field can only be specified upon asset creation. + */ + public var decimals: UInt32? + /** + * Whether the asset is frozen by default for all accounts. + * Defaults to `false`. + * + * If `true` then for anyone apart from the creator to hold the + * asset it needs to be unfrozen per account using an asset freeze + * transaction from the `freeze` account, which must be set on creation. + * + * This field can only be specified upon asset creation. + */ + public var defaultFrozen: Bool? + /** + * The optional name of the asset. + * + * Max size is 32 bytes. + * + * This field can only be specified upon asset creation. + */ + public var assetName: String? + /** + * The optional name of the unit of this asset (e.g. ticker name). + * + * Max size is 8 bytes. + * + * This field can only be specified upon asset creation. + */ + public var unitName: String? + /** + * Specifies an optional URL where more information about the asset can be retrieved (e.g. metadata). + * + * Max size is 96 bytes. + * + * This field can only be specified upon asset creation. + */ + public var url: String? + /** + * 32-byte hash of some metadata that is relevant to your asset and/or asset holders. + * + * The format of this metadata is up to the application. + * + * This field can only be specified upon asset creation. + */ + public var metadataHash: Data? + /** + * The address of the optional account that can manage the configuration of the asset and destroy it. + * + * The fields it can change are `manager`, `reserve`, `clawback`, and `freeze`. + * + * If not set or set to the Zero address the asset becomes permanently immutable. + */ + public var manager: String? + /** + * The address of the optional account that holds the reserve (uncirculated supply) units of the asset. + * + * This address has no specific authority in the protocol itself and is informational only. + * + * Some standards like [ARC-19](https://github.com/algorandfoundation/ARCs/blob/main/ARCs/arc-0019.md) + * rely on this field to hold meaningful data. + * + * It can be used in the case where you want to signal to holders of your asset that the uncirculated units + * of the asset reside in an account that is different from the default creator account. + * + * If not set or set to the Zero address is permanently empty. + */ + public var reserve: String? + /** + * The address of the optional account that can be used to freeze or unfreeze holdings of this asset for any account. + * + * If empty, freezing is not permitted. + * + * If not set or set to the Zero address is permanently empty. + */ + public var freeze: String? + /** + * The address of the optional account that can clawback holdings of this asset from any account. + * + * **This field should be used with caution** as the clawback account has the ability to **unconditionally take assets from any account**. + * + * If empty, clawback is not permitted. + * + * If not set or set to the Zero address is permanently empty. + */ + public var clawback: String? // Default memberwise initializers are never public by default, so we // declare one manually. - public init(assetId: UInt64, amount: UInt64, receiver: Address, assetSender: Address? = nil, closeRemainderTo: Address? = nil) { + public init( + /** + * ID of the asset to operate on. + * + * For asset creation, this must be 0. + * For asset reconfiguration this is the ID of the existing asset to be reconfigured, + * For asset destroy this is the ID of the existing asset to be destroyed. + */assetId: UInt64, + /** + * The total amount of the smallest divisible (decimal) unit to create. + * + * Required when creating a new asset. + * For example, if creating a asset with 2 decimals and wanting a total supply of 100 units, this value should be 10000. + * + * This field can only be specified upon asset creation. + */total: UInt64? = nil, + /** + * The amount of decimal places the asset should have. + * + * If unspecified then the asset will be in whole units (i.e. `0`). + * * If 0, the asset is not divisible; + * * If 1, the base unit of the asset is in tenths; + * * If 2, the base unit of the asset is in hundredths; + * * If 3, the base unit of the asset is in thousandths; + * + * and so on up to 19 decimal places. + * + * This field can only be specified upon asset creation. + */decimals: UInt32? = nil, + /** + * Whether the asset is frozen by default for all accounts. + * Defaults to `false`. + * + * If `true` then for anyone apart from the creator to hold the + * asset it needs to be unfrozen per account using an asset freeze + * transaction from the `freeze` account, which must be set on creation. + * + * This field can only be specified upon asset creation. + */defaultFrozen: Bool? = nil, + /** + * The optional name of the asset. + * + * Max size is 32 bytes. + * + * This field can only be specified upon asset creation. + */assetName: String? = nil, + /** + * The optional name of the unit of this asset (e.g. ticker name). + * + * Max size is 8 bytes. + * + * This field can only be specified upon asset creation. + */unitName: String? = nil, + /** + * Specifies an optional URL where more information about the asset can be retrieved (e.g. metadata). + * + * Max size is 96 bytes. + * + * This field can only be specified upon asset creation. + */url: String? = nil, + /** + * 32-byte hash of some metadata that is relevant to your asset and/or asset holders. + * + * The format of this metadata is up to the application. + * + * This field can only be specified upon asset creation. + */metadataHash: Data? = nil, + /** + * The address of the optional account that can manage the configuration of the asset and destroy it. + * + * The fields it can change are `manager`, `reserve`, `clawback`, and `freeze`. + * + * If not set or set to the Zero address the asset becomes permanently immutable. + */manager: String? = nil, + /** + * The address of the optional account that holds the reserve (uncirculated supply) units of the asset. + * + * This address has no specific authority in the protocol itself and is informational only. + * + * Some standards like [ARC-19](https://github.com/algorandfoundation/ARCs/blob/main/ARCs/arc-0019.md) + * rely on this field to hold meaningful data. + * + * It can be used in the case where you want to signal to holders of your asset that the uncirculated units + * of the asset reside in an account that is different from the default creator account. + * + * If not set or set to the Zero address is permanently empty. + */reserve: String? = nil, + /** + * The address of the optional account that can be used to freeze or unfreeze holdings of this asset for any account. + * + * If empty, freezing is not permitted. + * + * If not set or set to the Zero address is permanently empty. + */freeze: String? = nil, + /** + * The address of the optional account that can clawback holdings of this asset from any account. + * + * **This field should be used with caution** as the clawback account has the ability to **unconditionally take assets from any account**. + * + * If empty, clawback is not permitted. + * + * If not set or set to the Zero address is permanently empty. + */clawback: String? = nil) { self.assetId = assetId - self.amount = amount - self.receiver = receiver - self.assetSender = assetSender - self.closeRemainderTo = closeRemainderTo - } -} - + self.total = total + self.decimals = decimals + self.defaultFrozen = defaultFrozen + self.assetName = assetName + self.unitName = unitName + self.url = url + self.metadataHash = metadataHash + self.manager = manager + self.reserve = reserve + self.freeze = freeze + self.clawback = clawback + } +} + +#if compiler(>=6) +extension AssetConfigTransactionFields: Sendable {} +#endif -extension AssetTransferTransactionFields: Equatable, Hashable { - public static func ==(lhs: AssetTransferTransactionFields, rhs: AssetTransferTransactionFields) -> Bool { +extension AssetConfigTransactionFields: Equatable, Hashable { + public static func ==(lhs: AssetConfigTransactionFields, rhs: AssetConfigTransactionFields) -> Bool { if lhs.assetId != rhs.assetId { return false } - if lhs.amount != rhs.amount { + if lhs.total != rhs.total { return false } - if lhs.receiver != rhs.receiver { + if lhs.decimals != rhs.decimals { return false } - if lhs.assetSender != rhs.assetSender { + if lhs.defaultFrozen != rhs.defaultFrozen { return false } - if lhs.closeRemainderTo != rhs.closeRemainderTo { + if lhs.assetName != rhs.assetName { + return false + } + if lhs.unitName != rhs.unitName { + return false + } + if lhs.url != rhs.url { + return false + } + if lhs.metadataHash != rhs.metadataHash { + return false + } + if lhs.manager != rhs.manager { + return false + } + if lhs.reserve != rhs.reserve { + return false + } + if lhs.freeze != rhs.freeze { + return false + } + if lhs.clawback != rhs.clawback { return false } return true @@ -580,35 +1106,57 @@ extension AssetTransferTransactionFields: Equatable, Hashable { public func hash(into hasher: inout Hasher) { hasher.combine(assetId) - hasher.combine(amount) - hasher.combine(receiver) - hasher.combine(assetSender) - hasher.combine(closeRemainderTo) + hasher.combine(total) + hasher.combine(decimals) + hasher.combine(defaultFrozen) + hasher.combine(assetName) + hasher.combine(unitName) + hasher.combine(url) + hasher.combine(metadataHash) + hasher.combine(manager) + hasher.combine(reserve) + hasher.combine(freeze) + hasher.combine(clawback) } } + #if swift(>=5.8) @_documentation(visibility: private) #endif -public struct FfiConverterTypeAssetTransferTransactionFields: FfiConverterRustBuffer { - public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> AssetTransferTransactionFields { +public struct FfiConverterTypeAssetConfigTransactionFields: FfiConverterRustBuffer { + public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> AssetConfigTransactionFields { return - try AssetTransferTransactionFields( + try AssetConfigTransactionFields( assetId: FfiConverterUInt64.read(from: &buf), - amount: FfiConverterUInt64.read(from: &buf), - receiver: FfiConverterTypeAddress.read(from: &buf), - assetSender: FfiConverterOptionTypeAddress.read(from: &buf), - closeRemainderTo: FfiConverterOptionTypeAddress.read(from: &buf) + total: FfiConverterOptionUInt64.read(from: &buf), + decimals: FfiConverterOptionUInt32.read(from: &buf), + defaultFrozen: FfiConverterOptionBool.read(from: &buf), + assetName: FfiConverterOptionString.read(from: &buf), + unitName: FfiConverterOptionString.read(from: &buf), + url: FfiConverterOptionString.read(from: &buf), + metadataHash: FfiConverterOptionData.read(from: &buf), + manager: FfiConverterOptionString.read(from: &buf), + reserve: FfiConverterOptionString.read(from: &buf), + freeze: FfiConverterOptionString.read(from: &buf), + clawback: FfiConverterOptionString.read(from: &buf) ) } - public static func write(_ value: AssetTransferTransactionFields, into buf: inout [UInt8]) { + public static func write(_ value: AssetConfigTransactionFields, into buf: inout [UInt8]) { FfiConverterUInt64.write(value.assetId, into: &buf) - FfiConverterUInt64.write(value.amount, into: &buf) - FfiConverterTypeAddress.write(value.receiver, into: &buf) - FfiConverterOptionTypeAddress.write(value.assetSender, into: &buf) - FfiConverterOptionTypeAddress.write(value.closeRemainderTo, into: &buf) + FfiConverterOptionUInt64.write(value.total, into: &buf) + FfiConverterOptionUInt32.write(value.decimals, into: &buf) + FfiConverterOptionBool.write(value.defaultFrozen, into: &buf) + FfiConverterOptionString.write(value.assetName, into: &buf) + FfiConverterOptionString.write(value.unitName, into: &buf) + FfiConverterOptionString.write(value.url, into: &buf) + FfiConverterOptionData.write(value.metadataHash, into: &buf) + FfiConverterOptionString.write(value.manager, into: &buf) + FfiConverterOptionString.write(value.reserve, into: &buf) + FfiConverterOptionString.write(value.freeze, into: &buf) + FfiConverterOptionString.write(value.clawback, into: &buf) } } @@ -616,73 +1164,107 @@ public struct FfiConverterTypeAssetTransferTransactionFields: FfiConverterRustBu #if swift(>=5.8) @_documentation(visibility: private) #endif -public func FfiConverterTypeAssetTransferTransactionFields_lift(_ buf: RustBuffer) throws -> AssetTransferTransactionFields { - return try FfiConverterTypeAssetTransferTransactionFields.lift(buf) +public func FfiConverterTypeAssetConfigTransactionFields_lift(_ buf: RustBuffer) throws -> AssetConfigTransactionFields { + return try FfiConverterTypeAssetConfigTransactionFields.lift(buf) } #if swift(>=5.8) @_documentation(visibility: private) #endif -public func FfiConverterTypeAssetTransferTransactionFields_lower(_ value: AssetTransferTransactionFields) -> RustBuffer { - return FfiConverterTypeAssetTransferTransactionFields.lower(value) +public func FfiConverterTypeAssetConfigTransactionFields_lower(_ value: AssetConfigTransactionFields) -> RustBuffer { + return FfiConverterTypeAssetConfigTransactionFields.lower(value) } -public struct PaymentTransactionFields { - public var receiver: Address - public var amount: UInt64 - public var closeRemainderTo: Address? +/** + * Represents an asset freeze transaction that freezes or unfreezes asset holdings. + * + * Asset freeze transactions are used by the asset freeze account to control + * whether a specific account can transfer a particular asset. + */ +public struct AssetFreezeTransactionFields { + /** + * The ID of the asset being frozen/unfrozen. + */ + public var assetId: UInt64 + /** + * The target account whose asset holdings will be affected. + */ + public var freezeTarget: String + /** + * The new freeze status. + * + * `true` to freeze the asset holdings (prevent transfers), + * `false` to unfreeze the asset holdings (allow transfers). + */ + public var frozen: Bool // Default memberwise initializers are never public by default, so we // declare one manually. - public init(receiver: Address, amount: UInt64, closeRemainderTo: Address? = nil) { - self.receiver = receiver - self.amount = amount - self.closeRemainderTo = closeRemainderTo + public init( + /** + * The ID of the asset being frozen/unfrozen. + */assetId: UInt64, + /** + * The target account whose asset holdings will be affected. + */freezeTarget: String, + /** + * The new freeze status. + * + * `true` to freeze the asset holdings (prevent transfers), + * `false` to unfreeze the asset holdings (allow transfers). + */frozen: Bool) { + self.assetId = assetId + self.freezeTarget = freezeTarget + self.frozen = frozen } } +#if compiler(>=6) +extension AssetFreezeTransactionFields: Sendable {} +#endif -extension PaymentTransactionFields: Equatable, Hashable { - public static func ==(lhs: PaymentTransactionFields, rhs: PaymentTransactionFields) -> Bool { - if lhs.receiver != rhs.receiver { +extension AssetFreezeTransactionFields: Equatable, Hashable { + public static func ==(lhs: AssetFreezeTransactionFields, rhs: AssetFreezeTransactionFields) -> Bool { + if lhs.assetId != rhs.assetId { return false } - if lhs.amount != rhs.amount { + if lhs.freezeTarget != rhs.freezeTarget { return false } - if lhs.closeRemainderTo != rhs.closeRemainderTo { + if lhs.frozen != rhs.frozen { return false } return true } public func hash(into hasher: inout Hasher) { - hasher.combine(receiver) - hasher.combine(amount) - hasher.combine(closeRemainderTo) + hasher.combine(assetId) + hasher.combine(freezeTarget) + hasher.combine(frozen) } } + #if swift(>=5.8) @_documentation(visibility: private) #endif -public struct FfiConverterTypePaymentTransactionFields: FfiConverterRustBuffer { - public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> PaymentTransactionFields { +public struct FfiConverterTypeAssetFreezeTransactionFields: FfiConverterRustBuffer { + public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> AssetFreezeTransactionFields { return - try PaymentTransactionFields( - receiver: FfiConverterTypeAddress.read(from: &buf), - amount: FfiConverterUInt64.read(from: &buf), - closeRemainderTo: FfiConverterOptionTypeAddress.read(from: &buf) + try AssetFreezeTransactionFields( + assetId: FfiConverterUInt64.read(from: &buf), + freezeTarget: FfiConverterString.read(from: &buf), + frozen: FfiConverterBool.read(from: &buf) ) } - public static func write(_ value: PaymentTransactionFields, into buf: inout [UInt8]) { - FfiConverterTypeAddress.write(value.receiver, into: &buf) - FfiConverterUInt64.write(value.amount, into: &buf) - FfiConverterOptionTypeAddress.write(value.closeRemainderTo, into: &buf) + public static func write(_ value: AssetFreezeTransactionFields, into buf: inout [UInt8]) { + FfiConverterUInt64.write(value.assetId, into: &buf) + FfiConverterString.write(value.freezeTarget, into: &buf) + FfiConverterBool.write(value.frozen, into: &buf) } } @@ -690,38 +1272,993 @@ public struct FfiConverterTypePaymentTransactionFields: FfiConverterRustBuffer { #if swift(>=5.8) @_documentation(visibility: private) #endif -public func FfiConverterTypePaymentTransactionFields_lift(_ buf: RustBuffer) throws -> PaymentTransactionFields { - return try FfiConverterTypePaymentTransactionFields.lift(buf) +public func FfiConverterTypeAssetFreezeTransactionFields_lift(_ buf: RustBuffer) throws -> AssetFreezeTransactionFields { + return try FfiConverterTypeAssetFreezeTransactionFields.lift(buf) } #if swift(>=5.8) @_documentation(visibility: private) #endif -public func FfiConverterTypePaymentTransactionFields_lower(_ value: PaymentTransactionFields) -> RustBuffer { - return FfiConverterTypePaymentTransactionFields.lower(value) +public func FfiConverterTypeAssetFreezeTransactionFields_lower(_ value: AssetFreezeTransactionFields) -> RustBuffer { + return FfiConverterTypeAssetFreezeTransactionFields.lower(value) } -public struct Transaction { - /** - * The type of transaction - */ - public var transactionType: TransactionType - /** - * The sender of the transaction - */ - public var sender: Address - public var fee: UInt64 - public var firstValid: UInt64 - public var lastValid: UInt64 - public var genesisHash: ByteBuf? - public var genesisId: String? - public var note: ByteBuf? - public var rekeyTo: Address? - public var lease: ByteBuf? - public var group: ByteBuf? - public var payment: PaymentTransactionFields? - public var assetTransfer: AssetTransferTransactionFields? +public struct AssetTransferTransactionFields { + public var assetId: UInt64 + public var amount: UInt64 + public var receiver: String + public var assetSender: String? + public var closeRemainderTo: String? + + // Default memberwise initializers are never public by default, so we + // declare one manually. + public init(assetId: UInt64, amount: UInt64, receiver: String, assetSender: String? = nil, closeRemainderTo: String? = nil) { + self.assetId = assetId + self.amount = amount + self.receiver = receiver + self.assetSender = assetSender + self.closeRemainderTo = closeRemainderTo + } +} + +#if compiler(>=6) +extension AssetTransferTransactionFields: Sendable {} +#endif + + +extension AssetTransferTransactionFields: Equatable, Hashable { + public static func ==(lhs: AssetTransferTransactionFields, rhs: AssetTransferTransactionFields) -> Bool { + if lhs.assetId != rhs.assetId { + return false + } + if lhs.amount != rhs.amount { + return false + } + if lhs.receiver != rhs.receiver { + return false + } + if lhs.assetSender != rhs.assetSender { + return false + } + if lhs.closeRemainderTo != rhs.closeRemainderTo { + return false + } + return true + } + + public func hash(into hasher: inout Hasher) { + hasher.combine(assetId) + hasher.combine(amount) + hasher.combine(receiver) + hasher.combine(assetSender) + hasher.combine(closeRemainderTo) + } +} + + + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +public struct FfiConverterTypeAssetTransferTransactionFields: FfiConverterRustBuffer { + public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> AssetTransferTransactionFields { + return + try AssetTransferTransactionFields( + assetId: FfiConverterUInt64.read(from: &buf), + amount: FfiConverterUInt64.read(from: &buf), + receiver: FfiConverterString.read(from: &buf), + assetSender: FfiConverterOptionString.read(from: &buf), + closeRemainderTo: FfiConverterOptionString.read(from: &buf) + ) + } + + public static func write(_ value: AssetTransferTransactionFields, into buf: inout [UInt8]) { + FfiConverterUInt64.write(value.assetId, into: &buf) + FfiConverterUInt64.write(value.amount, into: &buf) + FfiConverterString.write(value.receiver, into: &buf) + FfiConverterOptionString.write(value.assetSender, into: &buf) + FfiConverterOptionString.write(value.closeRemainderTo, into: &buf) + } +} + + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +public func FfiConverterTypeAssetTransferTransactionFields_lift(_ buf: RustBuffer) throws -> AssetTransferTransactionFields { + return try FfiConverterTypeAssetTransferTransactionFields.lift(buf) +} + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +public func FfiConverterTypeAssetTransferTransactionFields_lower(_ value: AssetTransferTransactionFields) -> RustBuffer { + return FfiConverterTypeAssetTransferTransactionFields.lower(value) +} + + +/** + * Box reference for app call transactions. + * + * References a specific box that should be made available for the runtime + * of the program. + */ +public struct BoxReference { + /** + * App ID that owns the box. + * A value of 0 indicates the current app. + */ + public var appId: UInt64 + /** + * Name of the box. + */ + public var name: Data + + // Default memberwise initializers are never public by default, so we + // declare one manually. + public init( + /** + * App ID that owns the box. + * A value of 0 indicates the current app. + */appId: UInt64, + /** + * Name of the box. + */name: Data) { + self.appId = appId + self.name = name + } +} + +#if compiler(>=6) +extension BoxReference: Sendable {} +#endif + + +extension BoxReference: Equatable, Hashable { + public static func ==(lhs: BoxReference, rhs: BoxReference) -> Bool { + if lhs.appId != rhs.appId { + return false + } + if lhs.name != rhs.name { + return false + } + return true + } + + public func hash(into hasher: inout Hasher) { + hasher.combine(appId) + hasher.combine(name) + } +} + + + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +public struct FfiConverterTypeBoxReference: FfiConverterRustBuffer { + public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> BoxReference { + return + try BoxReference( + appId: FfiConverterUInt64.read(from: &buf), + name: FfiConverterData.read(from: &buf) + ) + } + + public static func write(_ value: BoxReference, into buf: inout [UInt8]) { + FfiConverterUInt64.write(value.appId, into: &buf) + FfiConverterData.write(value.name, into: &buf) + } +} + + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +public func FfiConverterTypeBoxReference_lift(_ buf: RustBuffer) throws -> BoxReference { + return try FfiConverterTypeBoxReference.lift(buf) +} + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +public func FfiConverterTypeBoxReference_lower(_ value: BoxReference) -> RustBuffer { + return FfiConverterTypeBoxReference.lower(value) +} + + +public struct FeeParams { + public var feePerByte: UInt64 + public var minFee: UInt64 + public var extraFee: UInt64? + public var maxFee: UInt64? + + // Default memberwise initializers are never public by default, so we + // declare one manually. + public init(feePerByte: UInt64, minFee: UInt64, extraFee: UInt64? = nil, maxFee: UInt64? = nil) { + self.feePerByte = feePerByte + self.minFee = minFee + self.extraFee = extraFee + self.maxFee = maxFee + } +} + +#if compiler(>=6) +extension FeeParams: Sendable {} +#endif + + +extension FeeParams: Equatable, Hashable { + public static func ==(lhs: FeeParams, rhs: FeeParams) -> Bool { + if lhs.feePerByte != rhs.feePerByte { + return false + } + if lhs.minFee != rhs.minFee { + return false + } + if lhs.extraFee != rhs.extraFee { + return false + } + if lhs.maxFee != rhs.maxFee { + return false + } + return true + } + + public func hash(into hasher: inout Hasher) { + hasher.combine(feePerByte) + hasher.combine(minFee) + hasher.combine(extraFee) + hasher.combine(maxFee) + } +} + + + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +public struct FfiConverterTypeFeeParams: FfiConverterRustBuffer { + public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> FeeParams { + return + try FeeParams( + feePerByte: FfiConverterUInt64.read(from: &buf), + minFee: FfiConverterUInt64.read(from: &buf), + extraFee: FfiConverterOptionUInt64.read(from: &buf), + maxFee: FfiConverterOptionUInt64.read(from: &buf) + ) + } + + public static func write(_ value: FeeParams, into buf: inout [UInt8]) { + FfiConverterUInt64.write(value.feePerByte, into: &buf) + FfiConverterUInt64.write(value.minFee, into: &buf) + FfiConverterOptionUInt64.write(value.extraFee, into: &buf) + FfiConverterOptionUInt64.write(value.maxFee, into: &buf) + } +} + + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +public func FfiConverterTypeFeeParams_lift(_ buf: RustBuffer) throws -> FeeParams { + return try FfiConverterTypeFeeParams.lift(buf) +} + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +public func FfiConverterTypeFeeParams_lower(_ value: FeeParams) -> RustBuffer { + return FfiConverterTypeFeeParams.lower(value) +} + + +public struct KeyPairAccount { + public var pubKey: Data + + // Default memberwise initializers are never public by default, so we + // declare one manually. + public init(pubKey: Data) { + self.pubKey = pubKey + } +} + +#if compiler(>=6) +extension KeyPairAccount: Sendable {} +#endif + + +extension KeyPairAccount: Equatable, Hashable { + public static func ==(lhs: KeyPairAccount, rhs: KeyPairAccount) -> Bool { + if lhs.pubKey != rhs.pubKey { + return false + } + return true + } + + public func hash(into hasher: inout Hasher) { + hasher.combine(pubKey) + } +} + + + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +public struct FfiConverterTypeKeyPairAccount: FfiConverterRustBuffer { + public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> KeyPairAccount { + return + try KeyPairAccount( + pubKey: FfiConverterData.read(from: &buf) + ) + } + + public static func write(_ value: KeyPairAccount, into buf: inout [UInt8]) { + FfiConverterData.write(value.pubKey, into: &buf) + } +} + + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +public func FfiConverterTypeKeyPairAccount_lift(_ buf: RustBuffer) throws -> KeyPairAccount { + return try FfiConverterTypeKeyPairAccount.lift(buf) +} + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +public func FfiConverterTypeKeyPairAccount_lower(_ value: KeyPairAccount) -> RustBuffer { + return FfiConverterTypeKeyPairAccount.lower(value) +} + + +public struct KeyRegistrationTransactionFields { + /** + * Root participation public key (32 bytes) + */ + public var voteKey: Data? + /** + * VRF public key (32 bytes) + */ + public var selectionKey: Data? + /** + * State proof key (64 bytes) + */ + public var stateProofKey: Data? + /** + * First round for which the participation key is valid + */ + public var voteFirst: UInt64? + /** + * Last round for which the participation key is valid + */ + public var voteLast: UInt64? + /** + * Key dilution for the 2-level participation key + */ + public var voteKeyDilution: UInt64? + /** + * Mark account as non-reward earning + */ + public var nonParticipation: Bool? + + // Default memberwise initializers are never public by default, so we + // declare one manually. + public init( + /** + * Root participation public key (32 bytes) + */voteKey: Data? = nil, + /** + * VRF public key (32 bytes) + */selectionKey: Data? = nil, + /** + * State proof key (64 bytes) + */stateProofKey: Data? = nil, + /** + * First round for which the participation key is valid + */voteFirst: UInt64? = nil, + /** + * Last round for which the participation key is valid + */voteLast: UInt64? = nil, + /** + * Key dilution for the 2-level participation key + */voteKeyDilution: UInt64? = nil, + /** + * Mark account as non-reward earning + */nonParticipation: Bool? = nil) { + self.voteKey = voteKey + self.selectionKey = selectionKey + self.stateProofKey = stateProofKey + self.voteFirst = voteFirst + self.voteLast = voteLast + self.voteKeyDilution = voteKeyDilution + self.nonParticipation = nonParticipation + } +} + +#if compiler(>=6) +extension KeyRegistrationTransactionFields: Sendable {} +#endif + + +extension KeyRegistrationTransactionFields: Equatable, Hashable { + public static func ==(lhs: KeyRegistrationTransactionFields, rhs: KeyRegistrationTransactionFields) -> Bool { + if lhs.voteKey != rhs.voteKey { + return false + } + if lhs.selectionKey != rhs.selectionKey { + return false + } + if lhs.stateProofKey != rhs.stateProofKey { + return false + } + if lhs.voteFirst != rhs.voteFirst { + return false + } + if lhs.voteLast != rhs.voteLast { + return false + } + if lhs.voteKeyDilution != rhs.voteKeyDilution { + return false + } + if lhs.nonParticipation != rhs.nonParticipation { + return false + } + return true + } + + public func hash(into hasher: inout Hasher) { + hasher.combine(voteKey) + hasher.combine(selectionKey) + hasher.combine(stateProofKey) + hasher.combine(voteFirst) + hasher.combine(voteLast) + hasher.combine(voteKeyDilution) + hasher.combine(nonParticipation) + } +} + + + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +public struct FfiConverterTypeKeyRegistrationTransactionFields: FfiConverterRustBuffer { + public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> KeyRegistrationTransactionFields { + return + try KeyRegistrationTransactionFields( + voteKey: FfiConverterOptionData.read(from: &buf), + selectionKey: FfiConverterOptionData.read(from: &buf), + stateProofKey: FfiConverterOptionData.read(from: &buf), + voteFirst: FfiConverterOptionUInt64.read(from: &buf), + voteLast: FfiConverterOptionUInt64.read(from: &buf), + voteKeyDilution: FfiConverterOptionUInt64.read(from: &buf), + nonParticipation: FfiConverterOptionBool.read(from: &buf) + ) + } + + public static func write(_ value: KeyRegistrationTransactionFields, into buf: inout [UInt8]) { + FfiConverterOptionData.write(value.voteKey, into: &buf) + FfiConverterOptionData.write(value.selectionKey, into: &buf) + FfiConverterOptionData.write(value.stateProofKey, into: &buf) + FfiConverterOptionUInt64.write(value.voteFirst, into: &buf) + FfiConverterOptionUInt64.write(value.voteLast, into: &buf) + FfiConverterOptionUInt64.write(value.voteKeyDilution, into: &buf) + FfiConverterOptionBool.write(value.nonParticipation, into: &buf) + } +} + + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +public func FfiConverterTypeKeyRegistrationTransactionFields_lift(_ buf: RustBuffer) throws -> KeyRegistrationTransactionFields { + return try FfiConverterTypeKeyRegistrationTransactionFields.lift(buf) +} + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +public func FfiConverterTypeKeyRegistrationTransactionFields_lower(_ value: KeyRegistrationTransactionFields) -> RustBuffer { + return FfiConverterTypeKeyRegistrationTransactionFields.lower(value) +} + + +/** + * Representation of an Algorand multisignature signature. + */ +public struct MultisigSignature { + /** + * Multisig version. + */ + public var version: UInt8 + /** + * Minimum number of signatures required. + */ + public var threshold: UInt8 + /** + * List of subsignatures for each participant. + */ + public var subsignatures: [MultisigSubsignature] + + // Default memberwise initializers are never public by default, so we + // declare one manually. + public init( + /** + * Multisig version. + */version: UInt8, + /** + * Minimum number of signatures required. + */threshold: UInt8, + /** + * List of subsignatures for each participant. + */subsignatures: [MultisigSubsignature]) { + self.version = version + self.threshold = threshold + self.subsignatures = subsignatures + } +} + +#if compiler(>=6) +extension MultisigSignature: Sendable {} +#endif + + +extension MultisigSignature: Equatable, Hashable { + public static func ==(lhs: MultisigSignature, rhs: MultisigSignature) -> Bool { + if lhs.version != rhs.version { + return false + } + if lhs.threshold != rhs.threshold { + return false + } + if lhs.subsignatures != rhs.subsignatures { + return false + } + return true + } + + public func hash(into hasher: inout Hasher) { + hasher.combine(version) + hasher.combine(threshold) + hasher.combine(subsignatures) + } +} + + + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +public struct FfiConverterTypeMultisigSignature: FfiConverterRustBuffer { + public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> MultisigSignature { + return + try MultisigSignature( + version: FfiConverterUInt8.read(from: &buf), + threshold: FfiConverterUInt8.read(from: &buf), + subsignatures: FfiConverterSequenceTypeMultisigSubsignature.read(from: &buf) + ) + } + + public static func write(_ value: MultisigSignature, into buf: inout [UInt8]) { + FfiConverterUInt8.write(value.version, into: &buf) + FfiConverterUInt8.write(value.threshold, into: &buf) + FfiConverterSequenceTypeMultisigSubsignature.write(value.subsignatures, into: &buf) + } +} + + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +public func FfiConverterTypeMultisigSignature_lift(_ buf: RustBuffer) throws -> MultisigSignature { + return try FfiConverterTypeMultisigSignature.lift(buf) +} + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +public func FfiConverterTypeMultisigSignature_lower(_ value: MultisigSignature) -> RustBuffer { + return FfiConverterTypeMultisigSignature.lower(value) +} + + +/** + * Representation of a single subsignature in a multisignature transaction. + * + * Each subsignature contains the participant's address and an optional signature. + */ +public struct MultisigSubsignature { + /** + * Address of the participant. + */ + public var address: String + /** + * Optional signature bytes for the participant. + */ + public var signature: Data? + + // Default memberwise initializers are never public by default, so we + // declare one manually. + public init( + /** + * Address of the participant. + */address: String, + /** + * Optional signature bytes for the participant. + */signature: Data? = nil) { + self.address = address + self.signature = signature + } +} + +#if compiler(>=6) +extension MultisigSubsignature: Sendable {} +#endif + + +extension MultisigSubsignature: Equatable, Hashable { + public static func ==(lhs: MultisigSubsignature, rhs: MultisigSubsignature) -> Bool { + if lhs.address != rhs.address { + return false + } + if lhs.signature != rhs.signature { + return false + } + return true + } + + public func hash(into hasher: inout Hasher) { + hasher.combine(address) + hasher.combine(signature) + } +} + + + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +public struct FfiConverterTypeMultisigSubsignature: FfiConverterRustBuffer { + public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> MultisigSubsignature { + return + try MultisigSubsignature( + address: FfiConverterString.read(from: &buf), + signature: FfiConverterOptionData.read(from: &buf) + ) + } + + public static func write(_ value: MultisigSubsignature, into buf: inout [UInt8]) { + FfiConverterString.write(value.address, into: &buf) + FfiConverterOptionData.write(value.signature, into: &buf) + } +} + + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +public func FfiConverterTypeMultisigSubsignature_lift(_ buf: RustBuffer) throws -> MultisigSubsignature { + return try FfiConverterTypeMultisigSubsignature.lift(buf) +} + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +public func FfiConverterTypeMultisigSubsignature_lower(_ value: MultisigSubsignature) -> RustBuffer { + return FfiConverterTypeMultisigSubsignature.lower(value) +} + + +public struct PaymentTransactionFields { + public var receiver: String + public var amount: UInt64 + public var closeRemainderTo: String? + + // Default memberwise initializers are never public by default, so we + // declare one manually. + public init(receiver: String, amount: UInt64, closeRemainderTo: String? = nil) { + self.receiver = receiver + self.amount = amount + self.closeRemainderTo = closeRemainderTo + } +} + +#if compiler(>=6) +extension PaymentTransactionFields: Sendable {} +#endif + + +extension PaymentTransactionFields: Equatable, Hashable { + public static func ==(lhs: PaymentTransactionFields, rhs: PaymentTransactionFields) -> Bool { + if lhs.receiver != rhs.receiver { + return false + } + if lhs.amount != rhs.amount { + return false + } + if lhs.closeRemainderTo != rhs.closeRemainderTo { + return false + } + return true + } + + public func hash(into hasher: inout Hasher) { + hasher.combine(receiver) + hasher.combine(amount) + hasher.combine(closeRemainderTo) + } +} + + + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +public struct FfiConverterTypePaymentTransactionFields: FfiConverterRustBuffer { + public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> PaymentTransactionFields { + return + try PaymentTransactionFields( + receiver: FfiConverterString.read(from: &buf), + amount: FfiConverterUInt64.read(from: &buf), + closeRemainderTo: FfiConverterOptionString.read(from: &buf) + ) + } + + public static func write(_ value: PaymentTransactionFields, into buf: inout [UInt8]) { + FfiConverterString.write(value.receiver, into: &buf) + FfiConverterUInt64.write(value.amount, into: &buf) + FfiConverterOptionString.write(value.closeRemainderTo, into: &buf) + } +} + + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +public func FfiConverterTypePaymentTransactionFields_lift(_ buf: RustBuffer) throws -> PaymentTransactionFields { + return try FfiConverterTypePaymentTransactionFields.lift(buf) +} + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +public func FfiConverterTypePaymentTransactionFields_lower(_ value: PaymentTransactionFields) -> RustBuffer { + return FfiConverterTypePaymentTransactionFields.lower(value) +} + + +public struct SignedTransaction { + /** + * The transaction that has been signed. + */ + public var transaction: Transaction + /** + * Optional Ed25519 signature authorizing the transaction. + */ + public var signature: Data? + /** + * Optional auth address applicable if the transaction sender is a rekeyed account. + */ + public var authAddress: String? + /** + * Optional multisig signature if the transaction is a multisig transaction. + */ + public var multisignature: MultisigSignature? + + // Default memberwise initializers are never public by default, so we + // declare one manually. + public init( + /** + * The transaction that has been signed. + */transaction: Transaction, + /** + * Optional Ed25519 signature authorizing the transaction. + */signature: Data? = nil, + /** + * Optional auth address applicable if the transaction sender is a rekeyed account. + */authAddress: String? = nil, + /** + * Optional multisig signature if the transaction is a multisig transaction. + */multisignature: MultisigSignature? = nil) { + self.transaction = transaction + self.signature = signature + self.authAddress = authAddress + self.multisignature = multisignature + } +} + +#if compiler(>=6) +extension SignedTransaction: Sendable {} +#endif + + +extension SignedTransaction: Equatable, Hashable { + public static func ==(lhs: SignedTransaction, rhs: SignedTransaction) -> Bool { + if lhs.transaction != rhs.transaction { + return false + } + if lhs.signature != rhs.signature { + return false + } + if lhs.authAddress != rhs.authAddress { + return false + } + if lhs.multisignature != rhs.multisignature { + return false + } + return true + } + + public func hash(into hasher: inout Hasher) { + hasher.combine(transaction) + hasher.combine(signature) + hasher.combine(authAddress) + hasher.combine(multisignature) + } +} + + + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +public struct FfiConverterTypeSignedTransaction: FfiConverterRustBuffer { + public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> SignedTransaction { + return + try SignedTransaction( + transaction: FfiConverterTypeTransaction.read(from: &buf), + signature: FfiConverterOptionData.read(from: &buf), + authAddress: FfiConverterOptionString.read(from: &buf), + multisignature: FfiConverterOptionTypeMultisigSignature.read(from: &buf) + ) + } + + public static func write(_ value: SignedTransaction, into buf: inout [UInt8]) { + FfiConverterTypeTransaction.write(value.transaction, into: &buf) + FfiConverterOptionData.write(value.signature, into: &buf) + FfiConverterOptionString.write(value.authAddress, into: &buf) + FfiConverterOptionTypeMultisigSignature.write(value.multisignature, into: &buf) + } +} + + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +public func FfiConverterTypeSignedTransaction_lift(_ buf: RustBuffer) throws -> SignedTransaction { + return try FfiConverterTypeSignedTransaction.lift(buf) +} + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +public func FfiConverterTypeSignedTransaction_lower(_ value: SignedTransaction) -> RustBuffer { + return FfiConverterTypeSignedTransaction.lower(value) +} + + +/** + * Schema for app state storage. + * + * Defines the maximum number of values that may be stored in app + * key/value storage for both global and local state. + */ +public struct StateSchema { + /** + * Maximum number of integer values that may be stored. + */ + public var numUints: UInt32 + /** + * Maximum number of byte slice values that may be stored. + */ + public var numByteSlices: UInt32 + + // Default memberwise initializers are never public by default, so we + // declare one manually. + public init( + /** + * Maximum number of integer values that may be stored. + */numUints: UInt32, + /** + * Maximum number of byte slice values that may be stored. + */numByteSlices: UInt32) { + self.numUints = numUints + self.numByteSlices = numByteSlices + } +} + +#if compiler(>=6) +extension StateSchema: Sendable {} +#endif + + +extension StateSchema: Equatable, Hashable { + public static func ==(lhs: StateSchema, rhs: StateSchema) -> Bool { + if lhs.numUints != rhs.numUints { + return false + } + if lhs.numByteSlices != rhs.numByteSlices { + return false + } + return true + } + + public func hash(into hasher: inout Hasher) { + hasher.combine(numUints) + hasher.combine(numByteSlices) + } +} + + + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +public struct FfiConverterTypeStateSchema: FfiConverterRustBuffer { + public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> StateSchema { + return + try StateSchema( + numUints: FfiConverterUInt32.read(from: &buf), + numByteSlices: FfiConverterUInt32.read(from: &buf) + ) + } + + public static func write(_ value: StateSchema, into buf: inout [UInt8]) { + FfiConverterUInt32.write(value.numUints, into: &buf) + FfiConverterUInt32.write(value.numByteSlices, into: &buf) + } +} + + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +public func FfiConverterTypeStateSchema_lift(_ buf: RustBuffer) throws -> StateSchema { + return try FfiConverterTypeStateSchema.lift(buf) +} + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +public func FfiConverterTypeStateSchema_lower(_ value: StateSchema) -> RustBuffer { + return FfiConverterTypeStateSchema.lower(value) +} + + +public struct Transaction { + /** + * The type of transaction + */ + public var transactionType: TransactionType + /** + * The sender of the transaction + */ + public var sender: String + /** + * Optional transaction fee in microALGO. + * + * If not set, the fee will be interpreted as 0 by the network. + */ + public var fee: UInt64? + public var firstValid: UInt64 + public var lastValid: UInt64 + public var genesisHash: Data? + public var genesisId: String? + public var note: Data? + public var rekeyTo: String? + public var lease: Data? + public var group: Data? + public var payment: PaymentTransactionFields? + public var assetTransfer: AssetTransferTransactionFields? + public var assetConfig: AssetConfigTransactionFields? + public var appCall: AppCallTransactionFields? + public var keyRegistration: KeyRegistrationTransactionFields? + public var assetFreeze: AssetFreezeTransactionFields? // Default memberwise initializers are never public by default, so we // declare one manually. @@ -731,7 +2268,12 @@ public struct Transaction { */transactionType: TransactionType, /** * The sender of the transaction - */sender: Address, fee: UInt64, firstValid: UInt64, lastValid: UInt64, genesisHash: ByteBuf?, genesisId: String?, note: ByteBuf? = nil, rekeyTo: Address? = nil, lease: ByteBuf? = nil, group: ByteBuf? = nil, payment: PaymentTransactionFields? = nil, assetTransfer: AssetTransferTransactionFields? = nil) { + */sender: String, + /** + * Optional transaction fee in microALGO. + * + * If not set, the fee will be interpreted as 0 by the network. + */fee: UInt64? = nil, firstValid: UInt64, lastValid: UInt64, genesisHash: Data?, genesisId: String?, note: Data? = nil, rekeyTo: String? = nil, lease: Data? = nil, group: Data? = nil, payment: PaymentTransactionFields? = nil, assetTransfer: AssetTransferTransactionFields? = nil, assetConfig: AssetConfigTransactionFields? = nil, appCall: AppCallTransactionFields? = nil, keyRegistration: KeyRegistrationTransactionFields? = nil, assetFreeze: AssetFreezeTransactionFields? = nil) { self.transactionType = transactionType self.sender = sender self.fee = fee @@ -745,9 +2287,16 @@ public struct Transaction { self.group = group self.payment = payment self.assetTransfer = assetTransfer + self.assetConfig = assetConfig + self.appCall = appCall + self.keyRegistration = keyRegistration + self.assetFreeze = assetFreeze } } +#if compiler(>=6) +extension Transaction: Sendable {} +#endif extension Transaction: Equatable, Hashable { @@ -791,6 +2340,18 @@ extension Transaction: Equatable, Hashable { if lhs.assetTransfer != rhs.assetTransfer { return false } + if lhs.assetConfig != rhs.assetConfig { + return false + } + if lhs.appCall != rhs.appCall { + return false + } + if lhs.keyRegistration != rhs.keyRegistration { + return false + } + if lhs.assetFreeze != rhs.assetFreeze { + return false + } return true } @@ -808,10 +2369,15 @@ extension Transaction: Equatable, Hashable { hasher.combine(group) hasher.combine(payment) hasher.combine(assetTransfer) + hasher.combine(assetConfig) + hasher.combine(appCall) + hasher.combine(keyRegistration) + hasher.combine(assetFreeze) } } + #if swift(>=5.8) @_documentation(visibility: private) #endif @@ -820,35 +2386,43 @@ public struct FfiConverterTypeTransaction: FfiConverterRustBuffer { return try Transaction( transactionType: FfiConverterTypeTransactionType.read(from: &buf), - sender: FfiConverterTypeAddress.read(from: &buf), - fee: FfiConverterUInt64.read(from: &buf), + sender: FfiConverterString.read(from: &buf), + fee: FfiConverterOptionUInt64.read(from: &buf), firstValid: FfiConverterUInt64.read(from: &buf), lastValid: FfiConverterUInt64.read(from: &buf), - genesisHash: FfiConverterOptionTypeByteBuf.read(from: &buf), + genesisHash: FfiConverterOptionData.read(from: &buf), genesisId: FfiConverterOptionString.read(from: &buf), - note: FfiConverterOptionTypeByteBuf.read(from: &buf), - rekeyTo: FfiConverterOptionTypeAddress.read(from: &buf), - lease: FfiConverterOptionTypeByteBuf.read(from: &buf), - group: FfiConverterOptionTypeByteBuf.read(from: &buf), + note: FfiConverterOptionData.read(from: &buf), + rekeyTo: FfiConverterOptionString.read(from: &buf), + lease: FfiConverterOptionData.read(from: &buf), + group: FfiConverterOptionData.read(from: &buf), payment: FfiConverterOptionTypePaymentTransactionFields.read(from: &buf), - assetTransfer: FfiConverterOptionTypeAssetTransferTransactionFields.read(from: &buf) + assetTransfer: FfiConverterOptionTypeAssetTransferTransactionFields.read(from: &buf), + assetConfig: FfiConverterOptionTypeAssetConfigTransactionFields.read(from: &buf), + appCall: FfiConverterOptionTypeAppCallTransactionFields.read(from: &buf), + keyRegistration: FfiConverterOptionTypeKeyRegistrationTransactionFields.read(from: &buf), + assetFreeze: FfiConverterOptionTypeAssetFreezeTransactionFields.read(from: &buf) ) } public static func write(_ value: Transaction, into buf: inout [UInt8]) { FfiConverterTypeTransactionType.write(value.transactionType, into: &buf) - FfiConverterTypeAddress.write(value.sender, into: &buf) - FfiConverterUInt64.write(value.fee, into: &buf) + FfiConverterString.write(value.sender, into: &buf) + FfiConverterOptionUInt64.write(value.fee, into: &buf) FfiConverterUInt64.write(value.firstValid, into: &buf) FfiConverterUInt64.write(value.lastValid, into: &buf) - FfiConverterOptionTypeByteBuf.write(value.genesisHash, into: &buf) + FfiConverterOptionData.write(value.genesisHash, into: &buf) FfiConverterOptionString.write(value.genesisId, into: &buf) - FfiConverterOptionTypeByteBuf.write(value.note, into: &buf) - FfiConverterOptionTypeAddress.write(value.rekeyTo, into: &buf) - FfiConverterOptionTypeByteBuf.write(value.lease, into: &buf) - FfiConverterOptionTypeByteBuf.write(value.group, into: &buf) + FfiConverterOptionData.write(value.note, into: &buf) + FfiConverterOptionString.write(value.rekeyTo, into: &buf) + FfiConverterOptionData.write(value.lease, into: &buf) + FfiConverterOptionData.write(value.group, into: &buf) FfiConverterOptionTypePaymentTransactionFields.write(value.payment, into: &buf) FfiConverterOptionTypeAssetTransferTransactionFields.write(value.assetTransfer, into: &buf) + FfiConverterOptionTypeAssetConfigTransactionFields.write(value.assetConfig, into: &buf) + FfiConverterOptionTypeAppCallTransactionFields.write(value.appCall, into: &buf) + FfiConverterOptionTypeKeyRegistrationTransactionFields.write(value.keyRegistration, into: &buf) + FfiConverterOptionTypeAssetFreezeTransactionFields.write(value.assetFreeze, into: &buf) } } @@ -868,13 +2442,17 @@ public func FfiConverterTypeTransaction_lower(_ value: Transaction) -> RustBuffe } -public enum AlgoKitTransactError { +public enum AlgoKitTransactError: Swift.Error { - case EncodingError(String + case EncodingError(errorMsg: String + ) + case DecodingError(errorMsg: String ) - case DecodingError(String + case InputError(errorMsg: String + ) + case MsgPackError(errorMsg: String ) } @@ -893,10 +2471,16 @@ public struct FfiConverterTypeAlgoKitTransactError: FfiConverterRustBuffer { case 1: return .EncodingError( - try FfiConverterString.read(from: &buf) + errorMsg: try FfiConverterString.read(from: &buf) ) case 2: return .DecodingError( - try FfiConverterString.read(from: &buf) + errorMsg: try FfiConverterString.read(from: &buf) + ) + case 3: return .InputError( + errorMsg: try FfiConverterString.read(from: &buf) + ) + case 4: return .MsgPackError( + errorMsg: try FfiConverterString.read(from: &buf) ) default: throw UniffiInternalError.unexpectedEnumCase @@ -910,126 +2494,300 @@ public struct FfiConverterTypeAlgoKitTransactError: FfiConverterRustBuffer { - case let .EncodingError(v1): + case let .EncodingError(errorMsg): writeInt(&buf, Int32(1)) - FfiConverterString.write(v1, into: &buf) + FfiConverterString.write(errorMsg, into: &buf) - case let .DecodingError(v1): + case let .DecodingError(errorMsg): writeInt(&buf, Int32(2)) - FfiConverterString.write(v1, into: &buf) + FfiConverterString.write(errorMsg, into: &buf) + + + case let .InputError(errorMsg): + writeInt(&buf, Int32(3)) + FfiConverterString.write(errorMsg, into: &buf) + + + case let .MsgPackError(errorMsg): + writeInt(&buf, Int32(4)) + FfiConverterString.write(errorMsg, into: &buf) } } } -extension AlgoKitTransactError: Equatable, Hashable {} +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +public func FfiConverterTypeAlgoKitTransactError_lift(_ buf: RustBuffer) throws -> AlgoKitTransactError { + return try FfiConverterTypeAlgoKitTransactError.lift(buf) +} + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +public func FfiConverterTypeAlgoKitTransactError_lower(_ value: AlgoKitTransactError) -> RustBuffer { + return FfiConverterTypeAlgoKitTransactError.lower(value) +} + + +extension AlgoKitTransactError: Equatable, Hashable {} + + + + +extension AlgoKitTransactError: Foundation.LocalizedError { + public var errorDescription: String? { + String(reflecting: self) + } +} + + + + +// Note that we don't yet support `indirect` for enums. +// See https://github.com/mozilla/uniffi-rs/issues/396 for further discussion. +/** + * Enum containing all constants used in this crate. + */ + +public enum AlgorandConstant { + + /** + * Length of hash digests (32) + */ + case hashLength + /** + * Length of the checksum used in Algorand addresses (4) + */ + case checksumLength + /** + * Length of a base32-encoded Algorand address (58) + */ + case addressLength + /** + * Length of an Algorand public key in bytes (32) + */ + case publicKeyLength + /** + * Length of an Algorand secret key in bytes (32) + */ + case secretKeyLength + /** + * Length of an Algorand signature in bytes (64) + */ + case signatureLength + /** + * Increment in the encoded byte size when a signature is attached to a transaction (75) + */ + case signatureEncodingIncrLength + /** + * The maximum number of transactions in a group (16) + */ + case maxTxGroupSize +} + + +#if compiler(>=6) +extension AlgorandConstant: Sendable {} +#endif + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +public struct FfiConverterTypeAlgorandConstant: FfiConverterRustBuffer { + typealias SwiftType = AlgorandConstant + + public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> AlgorandConstant { + let variant: Int32 = try readInt(&buf) + switch variant { + + case 1: return .hashLength + + case 2: return .checksumLength + + case 3: return .addressLength + + case 4: return .publicKeyLength + + case 5: return .secretKeyLength + + case 6: return .signatureLength + + case 7: return .signatureEncodingIncrLength + + case 8: return .maxTxGroupSize + + default: throw UniffiInternalError.unexpectedEnumCase + } + } + + public static func write(_ value: AlgorandConstant, into buf: inout [UInt8]) { + switch value { + + + case .hashLength: + writeInt(&buf, Int32(1)) + + + case .checksumLength: + writeInt(&buf, Int32(2)) + + + case .addressLength: + writeInt(&buf, Int32(3)) + + + case .publicKeyLength: + writeInt(&buf, Int32(4)) + + + case .secretKeyLength: + writeInt(&buf, Int32(5)) + + + case .signatureLength: + writeInt(&buf, Int32(6)) + + + case .signatureEncodingIncrLength: + writeInt(&buf, Int32(7)) + + + case .maxTxGroupSize: + writeInt(&buf, Int32(8)) + + } + } +} + + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +public func FfiConverterTypeAlgorandConstant_lift(_ buf: RustBuffer) throws -> AlgorandConstant { + return try FfiConverterTypeAlgorandConstant.lift(buf) +} + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +public func FfiConverterTypeAlgorandConstant_lower(_ value: AlgorandConstant) -> RustBuffer { + return FfiConverterTypeAlgorandConstant.lower(value) +} + + +extension AlgorandConstant: Equatable, Hashable {} + + + + -extension AlgoKitTransactError: Foundation.LocalizedError { - public var errorDescription: String? { - String(reflecting: self) - } -} // Note that we don't yet support `indirect` for enums. // See https://github.com/mozilla/uniffi-rs/issues/396 for further discussion. /** - * Enum containing all constants used in this crate. + * On-completion actions for app transactions. + * + * These values define what additional actions occur with the transaction. */ -public enum AlgorandConstant { +public enum OnApplicationComplete { /** - * Length of hash digests (32) - */ - case hashLength - /** - * Length of the checksum used in Algorand addresses (4) + * NoOp indicates that an app transaction will simply call its + * approval program without any additional action. */ - case checksumLength + case noOp /** - * Length of a base32-encoded Algorand address (58) + * OptIn indicates that an app transaction will allocate some + * local state for the app in the sender's account. */ - case addressLength + case optIn /** - * Length of an Algorand public key in bytes (32) + * CloseOut indicates that an app transaction will deallocate + * some local state for the app from the user's account. */ - case publicKeyLength + case closeOut /** - * Length of an Algorand secret key in bytes (32) + * ClearState is similar to CloseOut, but may never fail. This + * allows users to reclaim their minimum balance from an app + * they no longer wish to opt in to. */ - case secretKeyLength + case clearState /** - * Length of an Algorand signature in bytes (64) + * UpdateApplication indicates that an app transaction will + * update the approval program and clear state program for the app. */ - case signatureLength + case updateApplication /** - * Increment in the encoded byte size when a signature is attached to a transaction (75) + * DeleteApplication indicates that an app transaction will + * delete the app parameters for the app from the creator's + * balance record. */ - case signatureEncodingIncrLength + case deleteApplication } +#if compiler(>=6) +extension OnApplicationComplete: Sendable {} +#endif + #if swift(>=5.8) @_documentation(visibility: private) #endif -public struct FfiConverterTypeAlgorandConstant: FfiConverterRustBuffer { - typealias SwiftType = AlgorandConstant +public struct FfiConverterTypeOnApplicationComplete: FfiConverterRustBuffer { + typealias SwiftType = OnApplicationComplete - public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> AlgorandConstant { + public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> OnApplicationComplete { let variant: Int32 = try readInt(&buf) switch variant { - case 1: return .hashLength - - case 2: return .checksumLength + case 1: return .noOp - case 3: return .addressLength + case 2: return .optIn - case 4: return .publicKeyLength + case 3: return .closeOut - case 5: return .secretKeyLength + case 4: return .clearState - case 6: return .signatureLength + case 5: return .updateApplication - case 7: return .signatureEncodingIncrLength + case 6: return .deleteApplication default: throw UniffiInternalError.unexpectedEnumCase } } - public static func write(_ value: AlgorandConstant, into buf: inout [UInt8]) { + public static func write(_ value: OnApplicationComplete, into buf: inout [UInt8]) { switch value { - case .hashLength: + case .noOp: writeInt(&buf, Int32(1)) - case .checksumLength: + case .optIn: writeInt(&buf, Int32(2)) - case .addressLength: + case .closeOut: writeInt(&buf, Int32(3)) - case .publicKeyLength: + case .clearState: writeInt(&buf, Int32(4)) - case .secretKeyLength: + case .updateApplication: writeInt(&buf, Int32(5)) - case .signatureLength: + case .deleteApplication: writeInt(&buf, Int32(6)) - - case .signatureEncodingIncrLength: - writeInt(&buf, Int32(7)) - } } } @@ -1038,20 +2796,22 @@ public struct FfiConverterTypeAlgorandConstant: FfiConverterRustBuffer { #if swift(>=5.8) @_documentation(visibility: private) #endif -public func FfiConverterTypeAlgorandConstant_lift(_ buf: RustBuffer) throws -> AlgorandConstant { - return try FfiConverterTypeAlgorandConstant.lift(buf) +public func FfiConverterTypeOnApplicationComplete_lift(_ buf: RustBuffer) throws -> OnApplicationComplete { + return try FfiConverterTypeOnApplicationComplete.lift(buf) } #if swift(>=5.8) @_documentation(visibility: private) #endif -public func FfiConverterTypeAlgorandConstant_lower(_ value: AlgorandConstant) -> RustBuffer { - return FfiConverterTypeAlgorandConstant.lower(value) +public func FfiConverterTypeOnApplicationComplete_lower(_ value: OnApplicationComplete) -> RustBuffer { + return FfiConverterTypeOnApplicationComplete.lower(value) } +extension OnApplicationComplete: Equatable, Hashable {} + + -extension AlgorandConstant: Equatable, Hashable {} @@ -1065,10 +2825,14 @@ public enum TransactionType { case assetFreeze case assetConfig case keyRegistration - case applicationCall + case appCall } +#if compiler(>=6) +extension TransactionType: Sendable {} +#endif + #if swift(>=5.8) @_documentation(visibility: private) #endif @@ -1089,7 +2853,7 @@ public struct FfiConverterTypeTransactionType: FfiConverterRustBuffer { case 5: return .keyRegistration - case 6: return .applicationCall + case 6: return .appCall default: throw UniffiInternalError.unexpectedEnumCase } @@ -1119,39 +2883,329 @@ public struct FfiConverterTypeTransactionType: FfiConverterRustBuffer { writeInt(&buf, Int32(5)) - case .applicationCall: + case .appCall: writeInt(&buf, Int32(6)) } } -} +} + + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +public func FfiConverterTypeTransactionType_lift(_ buf: RustBuffer) throws -> TransactionType { + return try FfiConverterTypeTransactionType.lift(buf) +} + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +public func FfiConverterTypeTransactionType_lower(_ value: TransactionType) -> RustBuffer { + return FfiConverterTypeTransactionType.lower(value) +} + + +extension TransactionType: Equatable, Hashable {} + + + + + + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +fileprivate struct FfiConverterOptionUInt32: FfiConverterRustBuffer { + typealias SwiftType = UInt32? + + public static func write(_ value: SwiftType, into buf: inout [UInt8]) { + guard let value = value else { + writeInt(&buf, Int8(0)) + return + } + writeInt(&buf, Int8(1)) + FfiConverterUInt32.write(value, into: &buf) + } + + public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> SwiftType { + switch try readInt(&buf) as Int8 { + case 0: return nil + case 1: return try FfiConverterUInt32.read(from: &buf) + default: throw UniffiInternalError.unexpectedOptionalTag + } + } +} + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +fileprivate struct FfiConverterOptionUInt64: FfiConverterRustBuffer { + typealias SwiftType = UInt64? + + public static func write(_ value: SwiftType, into buf: inout [UInt8]) { + guard let value = value else { + writeInt(&buf, Int8(0)) + return + } + writeInt(&buf, Int8(1)) + FfiConverterUInt64.write(value, into: &buf) + } + + public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> SwiftType { + switch try readInt(&buf) as Int8 { + case 0: return nil + case 1: return try FfiConverterUInt64.read(from: &buf) + default: throw UniffiInternalError.unexpectedOptionalTag + } + } +} + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +fileprivate struct FfiConverterOptionBool: FfiConverterRustBuffer { + typealias SwiftType = Bool? + + public static func write(_ value: SwiftType, into buf: inout [UInt8]) { + guard let value = value else { + writeInt(&buf, Int8(0)) + return + } + writeInt(&buf, Int8(1)) + FfiConverterBool.write(value, into: &buf) + } + + public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> SwiftType { + switch try readInt(&buf) as Int8 { + case 0: return nil + case 1: return try FfiConverterBool.read(from: &buf) + default: throw UniffiInternalError.unexpectedOptionalTag + } + } +} + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +fileprivate struct FfiConverterOptionString: FfiConverterRustBuffer { + typealias SwiftType = String? + + public static func write(_ value: SwiftType, into buf: inout [UInt8]) { + guard let value = value else { + writeInt(&buf, Int8(0)) + return + } + writeInt(&buf, Int8(1)) + FfiConverterString.write(value, into: &buf) + } + + public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> SwiftType { + switch try readInt(&buf) as Int8 { + case 0: return nil + case 1: return try FfiConverterString.read(from: &buf) + default: throw UniffiInternalError.unexpectedOptionalTag + } + } +} + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +fileprivate struct FfiConverterOptionData: FfiConverterRustBuffer { + typealias SwiftType = Data? + + public static func write(_ value: SwiftType, into buf: inout [UInt8]) { + guard let value = value else { + writeInt(&buf, Int8(0)) + return + } + writeInt(&buf, Int8(1)) + FfiConverterData.write(value, into: &buf) + } + + public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> SwiftType { + switch try readInt(&buf) as Int8 { + case 0: return nil + case 1: return try FfiConverterData.read(from: &buf) + default: throw UniffiInternalError.unexpectedOptionalTag + } + } +} + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +fileprivate struct FfiConverterOptionTypeAppCallTransactionFields: FfiConverterRustBuffer { + typealias SwiftType = AppCallTransactionFields? + + public static func write(_ value: SwiftType, into buf: inout [UInt8]) { + guard let value = value else { + writeInt(&buf, Int8(0)) + return + } + writeInt(&buf, Int8(1)) + FfiConverterTypeAppCallTransactionFields.write(value, into: &buf) + } + + public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> SwiftType { + switch try readInt(&buf) as Int8 { + case 0: return nil + case 1: return try FfiConverterTypeAppCallTransactionFields.read(from: &buf) + default: throw UniffiInternalError.unexpectedOptionalTag + } + } +} + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +fileprivate struct FfiConverterOptionTypeAssetConfigTransactionFields: FfiConverterRustBuffer { + typealias SwiftType = AssetConfigTransactionFields? + + public static func write(_ value: SwiftType, into buf: inout [UInt8]) { + guard let value = value else { + writeInt(&buf, Int8(0)) + return + } + writeInt(&buf, Int8(1)) + FfiConverterTypeAssetConfigTransactionFields.write(value, into: &buf) + } + + public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> SwiftType { + switch try readInt(&buf) as Int8 { + case 0: return nil + case 1: return try FfiConverterTypeAssetConfigTransactionFields.read(from: &buf) + default: throw UniffiInternalError.unexpectedOptionalTag + } + } +} + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +fileprivate struct FfiConverterOptionTypeAssetFreezeTransactionFields: FfiConverterRustBuffer { + typealias SwiftType = AssetFreezeTransactionFields? + + public static func write(_ value: SwiftType, into buf: inout [UInt8]) { + guard let value = value else { + writeInt(&buf, Int8(0)) + return + } + writeInt(&buf, Int8(1)) + FfiConverterTypeAssetFreezeTransactionFields.write(value, into: &buf) + } + + public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> SwiftType { + switch try readInt(&buf) as Int8 { + case 0: return nil + case 1: return try FfiConverterTypeAssetFreezeTransactionFields.read(from: &buf) + default: throw UniffiInternalError.unexpectedOptionalTag + } + } +} + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +fileprivate struct FfiConverterOptionTypeAssetTransferTransactionFields: FfiConverterRustBuffer { + typealias SwiftType = AssetTransferTransactionFields? + + public static func write(_ value: SwiftType, into buf: inout [UInt8]) { + guard let value = value else { + writeInt(&buf, Int8(0)) + return + } + writeInt(&buf, Int8(1)) + FfiConverterTypeAssetTransferTransactionFields.write(value, into: &buf) + } + public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> SwiftType { + switch try readInt(&buf) as Int8 { + case 0: return nil + case 1: return try FfiConverterTypeAssetTransferTransactionFields.read(from: &buf) + default: throw UniffiInternalError.unexpectedOptionalTag + } + } +} #if swift(>=5.8) @_documentation(visibility: private) #endif -public func FfiConverterTypeTransactionType_lift(_ buf: RustBuffer) throws -> TransactionType { - return try FfiConverterTypeTransactionType.lift(buf) +fileprivate struct FfiConverterOptionTypeKeyRegistrationTransactionFields: FfiConverterRustBuffer { + typealias SwiftType = KeyRegistrationTransactionFields? + + public static func write(_ value: SwiftType, into buf: inout [UInt8]) { + guard let value = value else { + writeInt(&buf, Int8(0)) + return + } + writeInt(&buf, Int8(1)) + FfiConverterTypeKeyRegistrationTransactionFields.write(value, into: &buf) + } + + public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> SwiftType { + switch try readInt(&buf) as Int8 { + case 0: return nil + case 1: return try FfiConverterTypeKeyRegistrationTransactionFields.read(from: &buf) + default: throw UniffiInternalError.unexpectedOptionalTag + } + } } #if swift(>=5.8) @_documentation(visibility: private) #endif -public func FfiConverterTypeTransactionType_lower(_ value: TransactionType) -> RustBuffer { - return FfiConverterTypeTransactionType.lower(value) -} +fileprivate struct FfiConverterOptionTypeMultisigSignature: FfiConverterRustBuffer { + typealias SwiftType = MultisigSignature? + public static func write(_ value: SwiftType, into buf: inout [UInt8]) { + guard let value = value else { + writeInt(&buf, Int8(0)) + return + } + writeInt(&buf, Int8(1)) + FfiConverterTypeMultisigSignature.write(value, into: &buf) + } + public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> SwiftType { + switch try readInt(&buf) as Int8 { + case 0: return nil + case 1: return try FfiConverterTypeMultisigSignature.read(from: &buf) + default: throw UniffiInternalError.unexpectedOptionalTag + } + } +} -extension TransactionType: Equatable, Hashable {} +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +fileprivate struct FfiConverterOptionTypePaymentTransactionFields: FfiConverterRustBuffer { + typealias SwiftType = PaymentTransactionFields? + public static func write(_ value: SwiftType, into buf: inout [UInt8]) { + guard let value = value else { + writeInt(&buf, Int8(0)) + return + } + writeInt(&buf, Int8(1)) + FfiConverterTypePaymentTransactionFields.write(value, into: &buf) + } + public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> SwiftType { + switch try readInt(&buf) as Int8 { + case 0: return nil + case 1: return try FfiConverterTypePaymentTransactionFields.read(from: &buf) + default: throw UniffiInternalError.unexpectedOptionalTag + } + } +} #if swift(>=5.8) @_documentation(visibility: private) #endif -fileprivate struct FfiConverterOptionString: FfiConverterRustBuffer { - typealias SwiftType = String? +fileprivate struct FfiConverterOptionTypeStateSchema: FfiConverterRustBuffer { + typealias SwiftType = StateSchema? public static func write(_ value: SwiftType, into buf: inout [UInt8]) { guard let value = value else { @@ -1159,13 +3213,13 @@ fileprivate struct FfiConverterOptionString: FfiConverterRustBuffer { return } writeInt(&buf, Int8(1)) - FfiConverterString.write(value, into: &buf) + FfiConverterTypeStateSchema.write(value, into: &buf) } public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> SwiftType { switch try readInt(&buf) as Int8 { case 0: return nil - case 1: return try FfiConverterString.read(from: &buf) + case 1: return try FfiConverterTypeStateSchema.read(from: &buf) default: throw UniffiInternalError.unexpectedOptionalTag } } @@ -1174,8 +3228,8 @@ fileprivate struct FfiConverterOptionString: FfiConverterRustBuffer { #if swift(>=5.8) @_documentation(visibility: private) #endif -fileprivate struct FfiConverterOptionTypeAddress: FfiConverterRustBuffer { - typealias SwiftType = Address? +fileprivate struct FfiConverterOptionSequenceUInt64: FfiConverterRustBuffer { + typealias SwiftType = [UInt64]? public static func write(_ value: SwiftType, into buf: inout [UInt8]) { guard let value = value else { @@ -1183,13 +3237,13 @@ fileprivate struct FfiConverterOptionTypeAddress: FfiConverterRustBuffer { return } writeInt(&buf, Int8(1)) - FfiConverterTypeAddress.write(value, into: &buf) + FfiConverterSequenceUInt64.write(value, into: &buf) } public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> SwiftType { switch try readInt(&buf) as Int8 { case 0: return nil - case 1: return try FfiConverterTypeAddress.read(from: &buf) + case 1: return try FfiConverterSequenceUInt64.read(from: &buf) default: throw UniffiInternalError.unexpectedOptionalTag } } @@ -1198,8 +3252,8 @@ fileprivate struct FfiConverterOptionTypeAddress: FfiConverterRustBuffer { #if swift(>=5.8) @_documentation(visibility: private) #endif -fileprivate struct FfiConverterOptionTypeAssetTransferTransactionFields: FfiConverterRustBuffer { - typealias SwiftType = AssetTransferTransactionFields? +fileprivate struct FfiConverterOptionSequenceString: FfiConverterRustBuffer { + typealias SwiftType = [String]? public static func write(_ value: SwiftType, into buf: inout [UInt8]) { guard let value = value else { @@ -1207,13 +3261,13 @@ fileprivate struct FfiConverterOptionTypeAssetTransferTransactionFields: FfiConv return } writeInt(&buf, Int8(1)) - FfiConverterTypeAssetTransferTransactionFields.write(value, into: &buf) + FfiConverterSequenceString.write(value, into: &buf) } public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> SwiftType { switch try readInt(&buf) as Int8 { case 0: return nil - case 1: return try FfiConverterTypeAssetTransferTransactionFields.read(from: &buf) + case 1: return try FfiConverterSequenceString.read(from: &buf) default: throw UniffiInternalError.unexpectedOptionalTag } } @@ -1222,8 +3276,8 @@ fileprivate struct FfiConverterOptionTypeAssetTransferTransactionFields: FfiConv #if swift(>=5.8) @_documentation(visibility: private) #endif -fileprivate struct FfiConverterOptionTypePaymentTransactionFields: FfiConverterRustBuffer { - typealias SwiftType = PaymentTransactionFields? +fileprivate struct FfiConverterOptionSequenceData: FfiConverterRustBuffer { + typealias SwiftType = [Data]? public static func write(_ value: SwiftType, into buf: inout [UInt8]) { guard let value = value else { @@ -1231,13 +3285,13 @@ fileprivate struct FfiConverterOptionTypePaymentTransactionFields: FfiConverterR return } writeInt(&buf, Int8(1)) - FfiConverterTypePaymentTransactionFields.write(value, into: &buf) + FfiConverterSequenceData.write(value, into: &buf) } public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> SwiftType { switch try readInt(&buf) as Int8 { case 0: return nil - case 1: return try FfiConverterTypePaymentTransactionFields.read(from: &buf) + case 1: return try FfiConverterSequenceData.read(from: &buf) default: throw UniffiInternalError.unexpectedOptionalTag } } @@ -1246,8 +3300,8 @@ fileprivate struct FfiConverterOptionTypePaymentTransactionFields: FfiConverterR #if swift(>=5.8) @_documentation(visibility: private) #endif -fileprivate struct FfiConverterOptionTypeByteBuf: FfiConverterRustBuffer { - typealias SwiftType = ByteBuf? +fileprivate struct FfiConverterOptionSequenceTypeBoxReference: FfiConverterRustBuffer { + typealias SwiftType = [BoxReference]? public static func write(_ value: SwiftType, into buf: inout [UInt8]) { guard let value = value else { @@ -1255,97 +3309,351 @@ fileprivate struct FfiConverterOptionTypeByteBuf: FfiConverterRustBuffer { return } writeInt(&buf, Int8(1)) - FfiConverterTypeByteBuf.write(value, into: &buf) + FfiConverterSequenceTypeBoxReference.write(value, into: &buf) } public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> SwiftType { switch try readInt(&buf) as Int8 { case 0: return nil - case 1: return try FfiConverterTypeByteBuf.read(from: &buf) + case 1: return try FfiConverterSequenceTypeBoxReference.read(from: &buf) default: throw UniffiInternalError.unexpectedOptionalTag } } } +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +fileprivate struct FfiConverterSequenceUInt64: FfiConverterRustBuffer { + typealias SwiftType = [UInt64] -/** - * Typealias from the type name used in the UDL file to the builtin type. This - * is needed because the UDL type name is used in function/method signatures. - */ -public typealias ByteBuf = Data + public static func write(_ value: [UInt64], into buf: inout [UInt8]) { + let len = Int32(value.count) + writeInt(&buf, len) + for item in value { + FfiConverterUInt64.write(item, into: &buf) + } + } + + public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> [UInt64] { + let len: Int32 = try readInt(&buf) + var seq = [UInt64]() + seq.reserveCapacity(Int(len)) + for _ in 0 ..< len { + seq.append(try FfiConverterUInt64.read(from: &buf)) + } + return seq + } +} #if swift(>=5.8) @_documentation(visibility: private) #endif -public struct FfiConverterTypeByteBuf: FfiConverter { - public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> ByteBuf { - return try FfiConverterData.read(from: &buf) +fileprivate struct FfiConverterSequenceString: FfiConverterRustBuffer { + typealias SwiftType = [String] + + public static func write(_ value: [String], into buf: inout [UInt8]) { + let len = Int32(value.count) + writeInt(&buf, len) + for item in value { + FfiConverterString.write(item, into: &buf) + } } - public static func write(_ value: ByteBuf, into buf: inout [UInt8]) { - return FfiConverterData.write(value, into: &buf) + public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> [String] { + let len: Int32 = try readInt(&buf) + var seq = [String]() + seq.reserveCapacity(Int(len)) + for _ in 0 ..< len { + seq.append(try FfiConverterString.read(from: &buf)) + } + return seq } +} + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +fileprivate struct FfiConverterSequenceData: FfiConverterRustBuffer { + typealias SwiftType = [Data] - public static func lift(_ value: RustBuffer) throws -> ByteBuf { - return try FfiConverterData.lift(value) + public static func write(_ value: [Data], into buf: inout [UInt8]) { + let len = Int32(value.count) + writeInt(&buf, len) + for item in value { + FfiConverterData.write(item, into: &buf) + } } - public static func lower(_ value: ByteBuf) -> RustBuffer { - return FfiConverterData.lower(value) + public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> [Data] { + let len: Int32 = try readInt(&buf) + var seq = [Data]() + seq.reserveCapacity(Int(len)) + for _ in 0 ..< len { + seq.append(try FfiConverterData.read(from: &buf)) + } + return seq } } +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +fileprivate struct FfiConverterSequenceTypeBoxReference: FfiConverterRustBuffer { + typealias SwiftType = [BoxReference] + + public static func write(_ value: [BoxReference], into buf: inout [UInt8]) { + let len = Int32(value.count) + writeInt(&buf, len) + for item in value { + FfiConverterTypeBoxReference.write(item, into: &buf) + } + } + + public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> [BoxReference] { + let len: Int32 = try readInt(&buf) + var seq = [BoxReference]() + seq.reserveCapacity(Int(len)) + for _ in 0 ..< len { + seq.append(try FfiConverterTypeBoxReference.read(from: &buf)) + } + return seq + } +} #if swift(>=5.8) @_documentation(visibility: private) #endif -public func FfiConverterTypeByteBuf_lift(_ value: RustBuffer) throws -> ByteBuf { - return try FfiConverterTypeByteBuf.lift(value) +fileprivate struct FfiConverterSequenceTypeMultisigSubsignature: FfiConverterRustBuffer { + typealias SwiftType = [MultisigSubsignature] + + public static func write(_ value: [MultisigSubsignature], into buf: inout [UInt8]) { + let len = Int32(value.count) + writeInt(&buf, len) + for item in value { + FfiConverterTypeMultisigSubsignature.write(item, into: &buf) + } + } + + public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> [MultisigSubsignature] { + let len: Int32 = try readInt(&buf) + var seq = [MultisigSubsignature]() + seq.reserveCapacity(Int(len)) + for _ in 0 ..< len { + seq.append(try FfiConverterTypeMultisigSubsignature.read(from: &buf)) + } + return seq + } } #if swift(>=5.8) @_documentation(visibility: private) #endif -public func FfiConverterTypeByteBuf_lower(_ value: ByteBuf) -> RustBuffer { - return FfiConverterTypeByteBuf.lower(value) +fileprivate struct FfiConverterSequenceTypeSignedTransaction: FfiConverterRustBuffer { + typealias SwiftType = [SignedTransaction] + + public static func write(_ value: [SignedTransaction], into buf: inout [UInt8]) { + let len = Int32(value.count) + writeInt(&buf, len) + for item in value { + FfiConverterTypeSignedTransaction.write(item, into: &buf) + } + } + + public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> [SignedTransaction] { + let len: Int32 = try readInt(&buf) + var seq = [SignedTransaction]() + seq.reserveCapacity(Int(len)) + for _ in 0 ..< len { + seq.append(try FfiConverterTypeSignedTransaction.read(from: &buf)) + } + return seq + } } -public func addressFromPubKey(pubKey: Data)throws -> Address { - return try FfiConverterTypeAddress.lift(try rustCallWithError(FfiConverterTypeAlgoKitTransactError.lift) { - uniffi_algokit_transact_ffi_fn_func_address_from_pub_key( - FfiConverterData.lower(pubKey),$0 +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +fileprivate struct FfiConverterSequenceTypeTransaction: FfiConverterRustBuffer { + typealias SwiftType = [Transaction] + + public static func write(_ value: [Transaction], into buf: inout [UInt8]) { + let len = Int32(value.count) + writeInt(&buf, len) + for item in value { + FfiConverterTypeTransaction.write(item, into: &buf) + } + } + + public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> [Transaction] { + let len: Int32 = try readInt(&buf) + var seq = [Transaction]() + seq.reserveCapacity(Int(len)) + for _ in 0 ..< len { + seq.append(try FfiConverterTypeTransaction.read(from: &buf)) + } + return seq + } +} +/** + * Returns the address of the multisignature account. + * + * # Errors + * /// Returns [`AlgoKitTransactError`] if the multisignature signature is invalid or the address cannot be derived. + */ +public func addressFromMultisigSignature(multisigSignature: MultisigSignature)throws -> String { + return try FfiConverterString.lift(try rustCallWithError(FfiConverterTypeAlgoKitTransactError_lift) { + uniffi_algokit_transact_ffi_fn_func_address_from_multisig_signature( + FfiConverterTypeMultisigSignature_lower(multisigSignature),$0 ) }) } -public func addressFromString(address: String)throws -> Address { - return try FfiConverterTypeAddress.lift(try rustCallWithError(FfiConverterTypeAlgoKitTransactError.lift) { - uniffi_algokit_transact_ffi_fn_func_address_from_string( - FfiConverterString.lower(address),$0 +public func addressFromPublicKey(publicKey: Data)throws -> String { + return try FfiConverterString.lift(try rustCallWithError(FfiConverterTypeAlgoKitTransactError_lift) { + uniffi_algokit_transact_ffi_fn_func_address_from_public_key( + FfiConverterData.lower(publicKey),$0 + ) +}) +} +/** + * Applies a subsignature for a participant to a multisignature signature, replacing any existing signature. + * + * # Errors + * + * Returns [`AlgoKitTransactError`] if the participant address is invalid or not found, or if the signature bytes are invalid. + */ +public func applyMultisigSubsignature(multisigSignature: MultisigSignature, participant: String, subsignature: Data)throws -> MultisigSignature { + return try FfiConverterTypeMultisigSignature_lift(try rustCallWithError(FfiConverterTypeAlgoKitTransactError_lift) { + uniffi_algokit_transact_ffi_fn_func_apply_multisig_subsignature( + FfiConverterTypeMultisigSignature_lower(multisigSignature), + FfiConverterString.lower(participant), + FfiConverterData.lower(subsignature),$0 + ) +}) +} +public func assignFee(transaction: Transaction, feeParams: FeeParams)throws -> Transaction { + return try FfiConverterTypeTransaction_lift(try rustCallWithError(FfiConverterTypeAlgoKitTransactError_lift) { + uniffi_algokit_transact_ffi_fn_func_assign_fee( + FfiConverterTypeTransaction_lower(transaction), + FfiConverterTypeFeeParams_lower(feeParams),$0 + ) +}) +} +public func calculateFee(transaction: Transaction, feeParams: FeeParams)throws -> UInt64 { + return try FfiConverterUInt64.lift(try rustCallWithError(FfiConverterTypeAlgoKitTransactError_lift) { + uniffi_algokit_transact_ffi_fn_func_calculate_fee( + FfiConverterTypeTransaction_lower(transaction), + FfiConverterTypeFeeParams_lower(feeParams),$0 + ) +}) +} +/** + * Decodes a signed transaction. + * + * # Parameters + * * `encoded_signed_transaction` - The MsgPack encoded signed transaction bytes + * + * # Returns + * The decoded SignedTransaction or an error if decoding fails. + */ +public func decodeSignedTransaction(encodedSignedTransaction: Data)throws -> SignedTransaction { + return try FfiConverterTypeSignedTransaction_lift(try rustCallWithError(FfiConverterTypeAlgoKitTransactError_lift) { + uniffi_algokit_transact_ffi_fn_func_decode_signed_transaction( + FfiConverterData.lower(encodedSignedTransaction),$0 ) }) } -public func attachSignature(encodedTx: Data, signature: Data)throws -> Data { - return try FfiConverterData.lift(try rustCallWithError(FfiConverterTypeAlgoKitTransactError.lift) { - uniffi_algokit_transact_ffi_fn_func_attach_signature( - FfiConverterData.lower(encodedTx), - FfiConverterData.lower(signature),$0 +/** + * Decodes a collection of MsgPack bytes into a signed transaction collection. + * + * # Parameters + * * `encoded_signed_transactions` - A collection of MsgPack encoded bytes, each representing a signed transaction. + * + * # Returns + * A collection of decoded signed transactions or an error if decoding fails. + */ +public func decodeSignedTransactions(encodedSignedTransactions: [Data])throws -> [SignedTransaction] { + return try FfiConverterSequenceTypeSignedTransaction.lift(try rustCallWithError(FfiConverterTypeAlgoKitTransactError_lift) { + uniffi_algokit_transact_ffi_fn_func_decode_signed_transactions( + FfiConverterSequenceData.lower(encodedSignedTransactions),$0 ) }) } -public func decodeTransaction(bytes: Data)throws -> Transaction { - return try FfiConverterTypeTransaction.lift(try rustCallWithError(FfiConverterTypeAlgoKitTransactError.lift) { +/** + * Decodes MsgPack bytes into a transaction. + * + * # Parameters + * * `encoded_tx` - MsgPack encoded bytes representing a transaction. + * + * # Returns + * A decoded transaction or an error if decoding fails. + */ +public func decodeTransaction(encodedTx: Data)throws -> Transaction { + return try FfiConverterTypeTransaction_lift(try rustCallWithError(FfiConverterTypeAlgoKitTransactError_lift) { uniffi_algokit_transact_ffi_fn_func_decode_transaction( - FfiConverterData.lower(bytes),$0 + FfiConverterData.lower(encodedTx),$0 + ) +}) +} +/** + * Decodes a collection of MsgPack bytes into a transaction collection. + * + * # Parameters + * * `encoded_txs` - A collection of MsgPack encoded bytes, each representing a transaction. + * + * # Returns + * A collection of decoded transactions or an error if decoding fails. + */ +public func decodeTransactions(encodedTxs: [Data])throws -> [Transaction] { + return try FfiConverterSequenceTypeTransaction.lift(try rustCallWithError(FfiConverterTypeAlgoKitTransactError_lift) { + uniffi_algokit_transact_ffi_fn_func_decode_transactions( + FfiConverterSequenceData.lower(encodedTxs),$0 + ) +}) +} +/** + * Encode a signed transaction to MsgPack for sending on the network. + * + * This method performs canonical encoding. No domain separation prefix is applicable. + * + * # Parameters + * * `signed_transaction` - The signed transaction to encode + * + * # Returns + * The MsgPack encoded bytes or an error if encoding fails. + */ +public func encodeSignedTransaction(signedTransaction: SignedTransaction)throws -> Data { + return try FfiConverterData.lift(try rustCallWithError(FfiConverterTypeAlgoKitTransactError_lift) { + uniffi_algokit_transact_ffi_fn_func_encode_signed_transaction( + FfiConverterTypeSignedTransaction_lower(signedTransaction),$0 + ) +}) +} +/** + * Encode signed transactions to MsgPack for sending on the network. + * + * This method performs canonical encoding. No domain separation prefix is applicable. + * + * # Parameters + * * `signed_transactions` - A collection of signed transactions to encode + * + * # Returns + * A collection of MsgPack encoded bytes or an error if encoding fails. + */ +public func encodeSignedTransactions(signedTransactions: [SignedTransaction])throws -> [Data] { + return try FfiConverterSequenceData.lift(try rustCallWithError(FfiConverterTypeAlgoKitTransactError_lift) { + uniffi_algokit_transact_ffi_fn_func_encode_signed_transactions( + FfiConverterSequenceTypeSignedTransaction.lower(signedTransactions),$0 ) }) } /** * Encode the transaction with the domain separation (e.g. "TX") prefix */ -public func encodeTransaction(tx: Transaction)throws -> Data { - return try FfiConverterData.lift(try rustCallWithError(FfiConverterTypeAlgoKitTransactError.lift) { +public func encodeTransaction(transaction: Transaction)throws -> Data { + return try FfiConverterData.lift(try rustCallWithError(FfiConverterTypeAlgoKitTransactError_lift) { uniffi_algokit_transact_ffi_fn_func_encode_transaction( - FfiConverterTypeTransaction.lower(tx),$0 + FfiConverterTypeTransaction_lower(transaction),$0 ) }) } @@ -1353,10 +3661,26 @@ public func encodeTransaction(tx: Transaction)throws -> Data { * Encode the transaction without the domain separation (e.g. "TX") prefix * This is useful for encoding the transaction for signing with tools that automatically add "TX" prefix to the transaction bytes. */ -public func encodeTransactionRaw(tx: Transaction)throws -> Data { - return try FfiConverterData.lift(try rustCallWithError(FfiConverterTypeAlgoKitTransactError.lift) { +public func encodeTransactionRaw(transaction: Transaction)throws -> Data { + return try FfiConverterData.lift(try rustCallWithError(FfiConverterTypeAlgoKitTransactError_lift) { uniffi_algokit_transact_ffi_fn_func_encode_transaction_raw( - FfiConverterTypeTransaction.lower(tx),$0 + FfiConverterTypeTransaction_lower(transaction),$0 + ) +}) +} +/** + * Encode transactions to MsgPack with the domain separation (e.g. "TX") prefix. + * + * # Parameters + * * `transactions` - A collection of transactions to encode + * + * # Returns + * A collection of MsgPack encoded bytes or an error if encoding fails. + */ +public func encodeTransactions(transactions: [Transaction])throws -> [Data] { + return try FfiConverterSequenceData.lift(try rustCallWithError(FfiConverterTypeAlgoKitTransactError_lift) { + uniffi_algokit_transact_ffi_fn_func_encode_transactions( + FfiConverterSequenceTypeTransaction.lower(transactions),$0 ) }) } @@ -1364,17 +3688,17 @@ public func encodeTransactionRaw(tx: Transaction)throws -> Data { * Return the size of the transaction in bytes as if it was already signed and encoded. * This is useful for estimating the fee for the transaction. */ -public func estimateTransactionSize(transaction: Transaction)throws -> UInt64 { - return try FfiConverterUInt64.lift(try rustCallWithError(FfiConverterTypeAlgoKitTransactError.lift) { +public func estimateTransactionSize(transaction: Transaction)throws -> UInt64 { + return try FfiConverterUInt64.lift(try rustCallWithError(FfiConverterTypeAlgoKitTransactError_lift) { uniffi_algokit_transact_ffi_fn_func_estimate_transaction_size( - FfiConverterTypeTransaction.lower(transaction),$0 + FfiConverterTypeTransaction_lower(transaction),$0 ) }) } -public func getAlgorandConstant(constant: AlgorandConstant) -> UInt64 { +public func getAlgorandConstant(constant: AlgorandConstant) -> UInt64 { return try! FfiConverterUInt64.lift(try! rustCall() { uniffi_algokit_transact_ffi_fn_func_get_algorand_constant( - FfiConverterTypeAlgorandConstant.lower(constant),$0 + FfiConverterTypeAlgorandConstant_lower(constant),$0 ) }) } @@ -1382,30 +3706,91 @@ public func getAlgorandConstant(constant: AlgorandConstant) -> UInt64 { * Get the transaction type from the encoded transaction. * This is particularly useful when decoding a transaction that has an unknown type */ -public func getEncodedTransactionType(bytes: Data)throws -> TransactionType { - return try FfiConverterTypeTransactionType.lift(try rustCallWithError(FfiConverterTypeAlgoKitTransactError.lift) { +public func getEncodedTransactionType(encodedTransaction: Data)throws -> TransactionType { + return try FfiConverterTypeTransactionType_lift(try rustCallWithError(FfiConverterTypeAlgoKitTransactError_lift) { uniffi_algokit_transact_ffi_fn_func_get_encoded_transaction_type( - FfiConverterData.lower(bytes),$0 + FfiConverterData.lower(encodedTransaction),$0 ) }) } /** * Get the base32 transaction ID string for a transaction. */ -public func getTransactionId(tx: Transaction)throws -> String { - return try FfiConverterString.lift(try rustCallWithError(FfiConverterTypeAlgoKitTransactError.lift) { +public func getTransactionId(transaction: Transaction)throws -> String { + return try FfiConverterString.lift(try rustCallWithError(FfiConverterTypeAlgoKitTransactError_lift) { uniffi_algokit_transact_ffi_fn_func_get_transaction_id( - FfiConverterTypeTransaction.lower(tx),$0 + FfiConverterTypeTransaction_lower(transaction),$0 ) }) } /** * Get the raw 32-byte transaction ID for a transaction. */ -public func getTransactionIdRaw(tx: Transaction)throws -> Data { - return try FfiConverterData.lift(try rustCallWithError(FfiConverterTypeAlgoKitTransactError.lift) { +public func getTransactionIdRaw(transaction: Transaction)throws -> Data { + return try FfiConverterData.lift(try rustCallWithError(FfiConverterTypeAlgoKitTransactError_lift) { uniffi_algokit_transact_ffi_fn_func_get_transaction_id_raw( - FfiConverterTypeTransaction.lower(tx),$0 + FfiConverterTypeTransaction_lower(transaction),$0 + ) +}) +} +/** + * Groups a collection of transactions by calculating and assigning the group to each transaction. + */ +public func groupTransactions(transactions: [Transaction])throws -> [Transaction] { + return try FfiConverterSequenceTypeTransaction.lift(try rustCallWithError(FfiConverterTypeAlgoKitTransactError_lift) { + uniffi_algokit_transact_ffi_fn_func_group_transactions( + FfiConverterSequenceTypeTransaction.lower(transactions),$0 + ) +}) +} +/** + * Merges two multisignature signatures, replacing signatures in the first with those from the second where present. + * + * # Errors + * + * Returns [`AlgoKitTransactError`] if the multisignature parameters or participants do not match. + */ +public func mergeMultisignatures(multisigSignatureA: MultisigSignature, multisigSignatureB: MultisigSignature)throws -> MultisigSignature { + return try FfiConverterTypeMultisigSignature_lift(try rustCallWithError(FfiConverterTypeAlgoKitTransactError_lift) { + uniffi_algokit_transact_ffi_fn_func_merge_multisignatures( + FfiConverterTypeMultisigSignature_lower(multisigSignatureA), + FfiConverterTypeMultisigSignature_lower(multisigSignatureB),$0 + ) +}) +} +/** + * Creates an empty multisignature signature from a list of participant addresses. + * + * # Errors + * + * Returns [`AlgoKitTransactError`] if any address is invalid or the multisignature parameters are invalid. + */ +public func newMultisigSignature(version: UInt8, threshold: UInt8, participants: [String])throws -> MultisigSignature { + return try FfiConverterTypeMultisigSignature_lift(try rustCallWithError(FfiConverterTypeAlgoKitTransactError_lift) { + uniffi_algokit_transact_ffi_fn_func_new_multisig_signature( + FfiConverterUInt8.lower(version), + FfiConverterUInt8.lower(threshold), + FfiConverterSequenceString.lower(participants),$0 + ) +}) +} +/** + * Returns the list of participant addresses from a multisignature signature. + * + * # Errors + * Returns [`AlgoKitTransactError`] if the multisignature is invalid. + */ +public func participantsFromMultisigSignature(multisigSignature: MultisigSignature)throws -> [String] { + return try FfiConverterSequenceString.lift(try rustCallWithError(FfiConverterTypeAlgoKitTransactError_lift) { + uniffi_algokit_transact_ffi_fn_func_participants_from_multisig_signature( + FfiConverterTypeMultisigSignature_lower(multisigSignature),$0 + ) +}) +} +public func publicKeyFromAddress(address: String)throws -> Data { + return try FfiConverterData.lift(try rustCallWithError(FfiConverterTypeAlgoKitTransactError_lift) { + uniffi_algokit_transact_ffi_fn_func_public_key_from_address( + FfiConverterString.lower(address),$0 ) }) } @@ -1419,28 +3804,52 @@ private enum InitializationResult { // the code inside is only computed once. private let initializationResult: InitializationResult = { // Get the bindings contract version from our ComponentInterface - let bindings_contract_version = 26 + let bindings_contract_version = 29 // Get the scaffolding contract version by calling the into the dylib let scaffolding_contract_version = ffi_algokit_transact_ffi_uniffi_contract_version() if bindings_contract_version != scaffolding_contract_version { return InitializationResult.contractVersionMismatch } - if (uniffi_algokit_transact_ffi_checksum_func_address_from_pub_key() != 65205) { + if (uniffi_algokit_transact_ffi_checksum_func_address_from_multisig_signature() != 51026) { + return InitializationResult.apiChecksumMismatch + } + if (uniffi_algokit_transact_ffi_checksum_func_address_from_public_key() != 10716) { + return InitializationResult.apiChecksumMismatch + } + if (uniffi_algokit_transact_ffi_checksum_func_apply_multisig_subsignature() != 42634) { + return InitializationResult.apiChecksumMismatch + } + if (uniffi_algokit_transact_ffi_checksum_func_assign_fee() != 35003) { + return InitializationResult.apiChecksumMismatch + } + if (uniffi_algokit_transact_ffi_checksum_func_calculate_fee() != 7537) { + return InitializationResult.apiChecksumMismatch + } + if (uniffi_algokit_transact_ffi_checksum_func_decode_signed_transaction() != 43569) { return InitializationResult.apiChecksumMismatch } - if (uniffi_algokit_transact_ffi_checksum_func_address_from_string() != 56499) { + if (uniffi_algokit_transact_ffi_checksum_func_decode_signed_transactions() != 62888) { return InitializationResult.apiChecksumMismatch } - if (uniffi_algokit_transact_ffi_checksum_func_attach_signature() != 7369) { + if (uniffi_algokit_transact_ffi_checksum_func_decode_transaction() != 56405) { return InitializationResult.apiChecksumMismatch } - if (uniffi_algokit_transact_ffi_checksum_func_decode_transaction() != 38127) { + if (uniffi_algokit_transact_ffi_checksum_func_decode_transactions() != 26956) { return InitializationResult.apiChecksumMismatch } - if (uniffi_algokit_transact_ffi_checksum_func_encode_transaction() != 62809) { + if (uniffi_algokit_transact_ffi_checksum_func_encode_signed_transaction() != 47064) { return InitializationResult.apiChecksumMismatch } - if (uniffi_algokit_transact_ffi_checksum_func_encode_transaction_raw() != 1774) { + if (uniffi_algokit_transact_ffi_checksum_func_encode_signed_transactions() != 1956) { + return InitializationResult.apiChecksumMismatch + } + if (uniffi_algokit_transact_ffi_checksum_func_encode_transaction() != 11275) { + return InitializationResult.apiChecksumMismatch + } + if (uniffi_algokit_transact_ffi_checksum_func_encode_transaction_raw() != 384) { + return InitializationResult.apiChecksumMismatch + } + if (uniffi_algokit_transact_ffi_checksum_func_encode_transactions() != 59611) { return InitializationResult.apiChecksumMismatch } if (uniffi_algokit_transact_ffi_checksum_func_estimate_transaction_size() != 60858) { @@ -1449,20 +3858,37 @@ private let initializationResult: InitializationResult = { if (uniffi_algokit_transact_ffi_checksum_func_get_algorand_constant() != 49400) { return InitializationResult.apiChecksumMismatch } - if (uniffi_algokit_transact_ffi_checksum_func_get_encoded_transaction_type() != 9866) { + if (uniffi_algokit_transact_ffi_checksum_func_get_encoded_transaction_type() != 42551) { + return InitializationResult.apiChecksumMismatch + } + if (uniffi_algokit_transact_ffi_checksum_func_get_transaction_id() != 10957) { + return InitializationResult.apiChecksumMismatch + } + if (uniffi_algokit_transact_ffi_checksum_func_get_transaction_id_raw() != 48975) { + return InitializationResult.apiChecksumMismatch + } + if (uniffi_algokit_transact_ffi_checksum_func_group_transactions() != 18193) { + return InitializationResult.apiChecksumMismatch + } + if (uniffi_algokit_transact_ffi_checksum_func_merge_multisignatures() != 58688) { + return InitializationResult.apiChecksumMismatch + } + if (uniffi_algokit_transact_ffi_checksum_func_new_multisig_signature() != 29314) { return InitializationResult.apiChecksumMismatch } - if (uniffi_algokit_transact_ffi_checksum_func_get_transaction_id() != 20463) { + if (uniffi_algokit_transact_ffi_checksum_func_participants_from_multisig_signature() != 25095) { return InitializationResult.apiChecksumMismatch } - if (uniffi_algokit_transact_ffi_checksum_func_get_transaction_id_raw() != 37098) { + if (uniffi_algokit_transact_ffi_checksum_func_public_key_from_address() != 58152) { return InitializationResult.apiChecksumMismatch } return InitializationResult.ok }() -private func uniffiEnsureInitialized() { +// Make the ensure init function public so that other modules which have external type references to +// our types can call it. +public func uniffiEnsureAlgokitTransactFfiInitialized() { switch initializationResult { case .ok: break diff --git a/packages/swift/AlgoKitTransact/Frameworks/algokit_transact.xcframework/ios-arm64_x86_64-simulator/Headers/algokit_transactFFI.h b/packages/swift/AlgoKitTransact/Frameworks/algokit_transact.xcframework/ios-arm64_x86_64-simulator/Headers/algokit_transactFFI.h index 5f1185624..d6dd1e874 100644 --- a/packages/swift/AlgoKitTransact/Frameworks/algokit_transact.xcframework/ios-arm64_x86_64-simulator/Headers/algokit_transactFFI.h +++ b/packages/swift/AlgoKitTransact/Frameworks/algokit_transact.xcframework/ios-arm64_x86_64-simulator/Headers/algokit_transactFFI.h @@ -251,34 +251,74 @@ typedef void (*UniffiForeignFutureCompleteVoid)(uint64_t, UniffiForeignFutureStr ); #endif -#ifndef UNIFFI_FFIDEF_UNIFFI_ALGOKIT_TRANSACT_FFI_FN_FUNC_ADDRESS_FROM_PUB_KEY -#define UNIFFI_FFIDEF_UNIFFI_ALGOKIT_TRANSACT_FFI_FN_FUNC_ADDRESS_FROM_PUB_KEY -RustBuffer uniffi_algokit_transact_ffi_fn_func_address_from_pub_key(RustBuffer pub_key, RustCallStatus *_Nonnull out_status +#ifndef UNIFFI_FFIDEF_UNIFFI_ALGOKIT_TRANSACT_FFI_FN_FUNC_ADDRESS_FROM_MULTISIG_SIGNATURE +#define UNIFFI_FFIDEF_UNIFFI_ALGOKIT_TRANSACT_FFI_FN_FUNC_ADDRESS_FROM_MULTISIG_SIGNATURE +RustBuffer uniffi_algokit_transact_ffi_fn_func_address_from_multisig_signature(RustBuffer multisig_signature, RustCallStatus *_Nonnull out_status ); #endif -#ifndef UNIFFI_FFIDEF_UNIFFI_ALGOKIT_TRANSACT_FFI_FN_FUNC_ADDRESS_FROM_STRING -#define UNIFFI_FFIDEF_UNIFFI_ALGOKIT_TRANSACT_FFI_FN_FUNC_ADDRESS_FROM_STRING -RustBuffer uniffi_algokit_transact_ffi_fn_func_address_from_string(RustBuffer address, RustCallStatus *_Nonnull out_status +#ifndef UNIFFI_FFIDEF_UNIFFI_ALGOKIT_TRANSACT_FFI_FN_FUNC_ADDRESS_FROM_PUBLIC_KEY +#define UNIFFI_FFIDEF_UNIFFI_ALGOKIT_TRANSACT_FFI_FN_FUNC_ADDRESS_FROM_PUBLIC_KEY +RustBuffer uniffi_algokit_transact_ffi_fn_func_address_from_public_key(RustBuffer public_key, RustCallStatus *_Nonnull out_status ); #endif -#ifndef UNIFFI_FFIDEF_UNIFFI_ALGOKIT_TRANSACT_FFI_FN_FUNC_ATTACH_SIGNATURE -#define UNIFFI_FFIDEF_UNIFFI_ALGOKIT_TRANSACT_FFI_FN_FUNC_ATTACH_SIGNATURE -RustBuffer uniffi_algokit_transact_ffi_fn_func_attach_signature(RustBuffer encoded_tx, RustBuffer signature, RustCallStatus *_Nonnull out_status +#ifndef UNIFFI_FFIDEF_UNIFFI_ALGOKIT_TRANSACT_FFI_FN_FUNC_APPLY_MULTISIG_SUBSIGNATURE +#define UNIFFI_FFIDEF_UNIFFI_ALGOKIT_TRANSACT_FFI_FN_FUNC_APPLY_MULTISIG_SUBSIGNATURE +RustBuffer uniffi_algokit_transact_ffi_fn_func_apply_multisig_subsignature(RustBuffer multisig_signature, RustBuffer participant, RustBuffer subsignature, RustCallStatus *_Nonnull out_status +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_ALGOKIT_TRANSACT_FFI_FN_FUNC_ASSIGN_FEE +#define UNIFFI_FFIDEF_UNIFFI_ALGOKIT_TRANSACT_FFI_FN_FUNC_ASSIGN_FEE +RustBuffer uniffi_algokit_transact_ffi_fn_func_assign_fee(RustBuffer transaction, RustBuffer fee_params, RustCallStatus *_Nonnull out_status +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_ALGOKIT_TRANSACT_FFI_FN_FUNC_CALCULATE_FEE +#define UNIFFI_FFIDEF_UNIFFI_ALGOKIT_TRANSACT_FFI_FN_FUNC_CALCULATE_FEE +uint64_t uniffi_algokit_transact_ffi_fn_func_calculate_fee(RustBuffer transaction, RustBuffer fee_params, RustCallStatus *_Nonnull out_status +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_ALGOKIT_TRANSACT_FFI_FN_FUNC_DECODE_SIGNED_TRANSACTION +#define UNIFFI_FFIDEF_UNIFFI_ALGOKIT_TRANSACT_FFI_FN_FUNC_DECODE_SIGNED_TRANSACTION +RustBuffer uniffi_algokit_transact_ffi_fn_func_decode_signed_transaction(RustBuffer encoded_signed_transaction, RustCallStatus *_Nonnull out_status +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_ALGOKIT_TRANSACT_FFI_FN_FUNC_DECODE_SIGNED_TRANSACTIONS +#define UNIFFI_FFIDEF_UNIFFI_ALGOKIT_TRANSACT_FFI_FN_FUNC_DECODE_SIGNED_TRANSACTIONS +RustBuffer uniffi_algokit_transact_ffi_fn_func_decode_signed_transactions(RustBuffer encoded_signed_transactions, RustCallStatus *_Nonnull out_status ); #endif #ifndef UNIFFI_FFIDEF_UNIFFI_ALGOKIT_TRANSACT_FFI_FN_FUNC_DECODE_TRANSACTION #define UNIFFI_FFIDEF_UNIFFI_ALGOKIT_TRANSACT_FFI_FN_FUNC_DECODE_TRANSACTION -RustBuffer uniffi_algokit_transact_ffi_fn_func_decode_transaction(RustBuffer bytes, RustCallStatus *_Nonnull out_status +RustBuffer uniffi_algokit_transact_ffi_fn_func_decode_transaction(RustBuffer encoded_tx, RustCallStatus *_Nonnull out_status +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_ALGOKIT_TRANSACT_FFI_FN_FUNC_DECODE_TRANSACTIONS +#define UNIFFI_FFIDEF_UNIFFI_ALGOKIT_TRANSACT_FFI_FN_FUNC_DECODE_TRANSACTIONS +RustBuffer uniffi_algokit_transact_ffi_fn_func_decode_transactions(RustBuffer encoded_txs, RustCallStatus *_Nonnull out_status +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_ALGOKIT_TRANSACT_FFI_FN_FUNC_ENCODE_SIGNED_TRANSACTION +#define UNIFFI_FFIDEF_UNIFFI_ALGOKIT_TRANSACT_FFI_FN_FUNC_ENCODE_SIGNED_TRANSACTION +RustBuffer uniffi_algokit_transact_ffi_fn_func_encode_signed_transaction(RustBuffer signed_transaction, RustCallStatus *_Nonnull out_status +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_ALGOKIT_TRANSACT_FFI_FN_FUNC_ENCODE_SIGNED_TRANSACTIONS +#define UNIFFI_FFIDEF_UNIFFI_ALGOKIT_TRANSACT_FFI_FN_FUNC_ENCODE_SIGNED_TRANSACTIONS +RustBuffer uniffi_algokit_transact_ffi_fn_func_encode_signed_transactions(RustBuffer signed_transactions, RustCallStatus *_Nonnull out_status ); #endif #ifndef UNIFFI_FFIDEF_UNIFFI_ALGOKIT_TRANSACT_FFI_FN_FUNC_ENCODE_TRANSACTION #define UNIFFI_FFIDEF_UNIFFI_ALGOKIT_TRANSACT_FFI_FN_FUNC_ENCODE_TRANSACTION -RustBuffer uniffi_algokit_transact_ffi_fn_func_encode_transaction(RustBuffer tx, RustCallStatus *_Nonnull out_status +RustBuffer uniffi_algokit_transact_ffi_fn_func_encode_transaction(RustBuffer transaction, RustCallStatus *_Nonnull out_status ); #endif #ifndef UNIFFI_FFIDEF_UNIFFI_ALGOKIT_TRANSACT_FFI_FN_FUNC_ENCODE_TRANSACTION_RAW #define UNIFFI_FFIDEF_UNIFFI_ALGOKIT_TRANSACT_FFI_FN_FUNC_ENCODE_TRANSACTION_RAW -RustBuffer uniffi_algokit_transact_ffi_fn_func_encode_transaction_raw(RustBuffer tx, RustCallStatus *_Nonnull out_status +RustBuffer uniffi_algokit_transact_ffi_fn_func_encode_transaction_raw(RustBuffer transaction, RustCallStatus *_Nonnull out_status +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_ALGOKIT_TRANSACT_FFI_FN_FUNC_ENCODE_TRANSACTIONS +#define UNIFFI_FFIDEF_UNIFFI_ALGOKIT_TRANSACT_FFI_FN_FUNC_ENCODE_TRANSACTIONS +RustBuffer uniffi_algokit_transact_ffi_fn_func_encode_transactions(RustBuffer transactions, RustCallStatus *_Nonnull out_status ); #endif #ifndef UNIFFI_FFIDEF_UNIFFI_ALGOKIT_TRANSACT_FFI_FN_FUNC_ESTIMATE_TRANSACTION_SIZE @@ -293,17 +333,42 @@ uint64_t uniffi_algokit_transact_ffi_fn_func_get_algorand_constant(RustBuffer co #endif #ifndef UNIFFI_FFIDEF_UNIFFI_ALGOKIT_TRANSACT_FFI_FN_FUNC_GET_ENCODED_TRANSACTION_TYPE #define UNIFFI_FFIDEF_UNIFFI_ALGOKIT_TRANSACT_FFI_FN_FUNC_GET_ENCODED_TRANSACTION_TYPE -RustBuffer uniffi_algokit_transact_ffi_fn_func_get_encoded_transaction_type(RustBuffer bytes, RustCallStatus *_Nonnull out_status +RustBuffer uniffi_algokit_transact_ffi_fn_func_get_encoded_transaction_type(RustBuffer encoded_transaction, RustCallStatus *_Nonnull out_status ); #endif #ifndef UNIFFI_FFIDEF_UNIFFI_ALGOKIT_TRANSACT_FFI_FN_FUNC_GET_TRANSACTION_ID #define UNIFFI_FFIDEF_UNIFFI_ALGOKIT_TRANSACT_FFI_FN_FUNC_GET_TRANSACTION_ID -RustBuffer uniffi_algokit_transact_ffi_fn_func_get_transaction_id(RustBuffer tx, RustCallStatus *_Nonnull out_status +RustBuffer uniffi_algokit_transact_ffi_fn_func_get_transaction_id(RustBuffer transaction, RustCallStatus *_Nonnull out_status ); #endif #ifndef UNIFFI_FFIDEF_UNIFFI_ALGOKIT_TRANSACT_FFI_FN_FUNC_GET_TRANSACTION_ID_RAW #define UNIFFI_FFIDEF_UNIFFI_ALGOKIT_TRANSACT_FFI_FN_FUNC_GET_TRANSACTION_ID_RAW -RustBuffer uniffi_algokit_transact_ffi_fn_func_get_transaction_id_raw(RustBuffer tx, RustCallStatus *_Nonnull out_status +RustBuffer uniffi_algokit_transact_ffi_fn_func_get_transaction_id_raw(RustBuffer transaction, RustCallStatus *_Nonnull out_status +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_ALGOKIT_TRANSACT_FFI_FN_FUNC_GROUP_TRANSACTIONS +#define UNIFFI_FFIDEF_UNIFFI_ALGOKIT_TRANSACT_FFI_FN_FUNC_GROUP_TRANSACTIONS +RustBuffer uniffi_algokit_transact_ffi_fn_func_group_transactions(RustBuffer transactions, RustCallStatus *_Nonnull out_status +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_ALGOKIT_TRANSACT_FFI_FN_FUNC_MERGE_MULTISIGNATURES +#define UNIFFI_FFIDEF_UNIFFI_ALGOKIT_TRANSACT_FFI_FN_FUNC_MERGE_MULTISIGNATURES +RustBuffer uniffi_algokit_transact_ffi_fn_func_merge_multisignatures(RustBuffer multisig_signature_a, RustBuffer multisig_signature_b, RustCallStatus *_Nonnull out_status +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_ALGOKIT_TRANSACT_FFI_FN_FUNC_NEW_MULTISIG_SIGNATURE +#define UNIFFI_FFIDEF_UNIFFI_ALGOKIT_TRANSACT_FFI_FN_FUNC_NEW_MULTISIG_SIGNATURE +RustBuffer uniffi_algokit_transact_ffi_fn_func_new_multisig_signature(uint8_t version, uint8_t threshold, RustBuffer participants, RustCallStatus *_Nonnull out_status +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_ALGOKIT_TRANSACT_FFI_FN_FUNC_PARTICIPANTS_FROM_MULTISIG_SIGNATURE +#define UNIFFI_FFIDEF_UNIFFI_ALGOKIT_TRANSACT_FFI_FN_FUNC_PARTICIPANTS_FROM_MULTISIG_SIGNATURE +RustBuffer uniffi_algokit_transact_ffi_fn_func_participants_from_multisig_signature(RustBuffer multisig_signature, RustCallStatus *_Nonnull out_status +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_ALGOKIT_TRANSACT_FFI_FN_FUNC_PUBLIC_KEY_FROM_ADDRESS +#define UNIFFI_FFIDEF_UNIFFI_ALGOKIT_TRANSACT_FFI_FN_FUNC_PUBLIC_KEY_FROM_ADDRESS +RustBuffer uniffi_algokit_transact_ffi_fn_func_public_key_from_address(RustBuffer address, RustCallStatus *_Nonnull out_status ); #endif #ifndef UNIFFI_FFIDEF_FFI_ALGOKIT_TRANSACT_FFI_RUSTBUFFER_ALLOC @@ -586,21 +651,45 @@ void ffi_algokit_transact_ffi_rust_future_free_void(uint64_t handle void ffi_algokit_transact_ffi_rust_future_complete_void(uint64_t handle, RustCallStatus *_Nonnull out_status ); #endif -#ifndef UNIFFI_FFIDEF_UNIFFI_ALGOKIT_TRANSACT_FFI_CHECKSUM_FUNC_ADDRESS_FROM_PUB_KEY -#define UNIFFI_FFIDEF_UNIFFI_ALGOKIT_TRANSACT_FFI_CHECKSUM_FUNC_ADDRESS_FROM_PUB_KEY -uint16_t uniffi_algokit_transact_ffi_checksum_func_address_from_pub_key(void +#ifndef UNIFFI_FFIDEF_UNIFFI_ALGOKIT_TRANSACT_FFI_CHECKSUM_FUNC_ADDRESS_FROM_MULTISIG_SIGNATURE +#define UNIFFI_FFIDEF_UNIFFI_ALGOKIT_TRANSACT_FFI_CHECKSUM_FUNC_ADDRESS_FROM_MULTISIG_SIGNATURE +uint16_t uniffi_algokit_transact_ffi_checksum_func_address_from_multisig_signature(void + +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_ALGOKIT_TRANSACT_FFI_CHECKSUM_FUNC_ADDRESS_FROM_PUBLIC_KEY +#define UNIFFI_FFIDEF_UNIFFI_ALGOKIT_TRANSACT_FFI_CHECKSUM_FUNC_ADDRESS_FROM_PUBLIC_KEY +uint16_t uniffi_algokit_transact_ffi_checksum_func_address_from_public_key(void ); #endif -#ifndef UNIFFI_FFIDEF_UNIFFI_ALGOKIT_TRANSACT_FFI_CHECKSUM_FUNC_ADDRESS_FROM_STRING -#define UNIFFI_FFIDEF_UNIFFI_ALGOKIT_TRANSACT_FFI_CHECKSUM_FUNC_ADDRESS_FROM_STRING -uint16_t uniffi_algokit_transact_ffi_checksum_func_address_from_string(void +#ifndef UNIFFI_FFIDEF_UNIFFI_ALGOKIT_TRANSACT_FFI_CHECKSUM_FUNC_APPLY_MULTISIG_SUBSIGNATURE +#define UNIFFI_FFIDEF_UNIFFI_ALGOKIT_TRANSACT_FFI_CHECKSUM_FUNC_APPLY_MULTISIG_SUBSIGNATURE +uint16_t uniffi_algokit_transact_ffi_checksum_func_apply_multisig_subsignature(void ); #endif -#ifndef UNIFFI_FFIDEF_UNIFFI_ALGOKIT_TRANSACT_FFI_CHECKSUM_FUNC_ATTACH_SIGNATURE -#define UNIFFI_FFIDEF_UNIFFI_ALGOKIT_TRANSACT_FFI_CHECKSUM_FUNC_ATTACH_SIGNATURE -uint16_t uniffi_algokit_transact_ffi_checksum_func_attach_signature(void +#ifndef UNIFFI_FFIDEF_UNIFFI_ALGOKIT_TRANSACT_FFI_CHECKSUM_FUNC_ASSIGN_FEE +#define UNIFFI_FFIDEF_UNIFFI_ALGOKIT_TRANSACT_FFI_CHECKSUM_FUNC_ASSIGN_FEE +uint16_t uniffi_algokit_transact_ffi_checksum_func_assign_fee(void + +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_ALGOKIT_TRANSACT_FFI_CHECKSUM_FUNC_CALCULATE_FEE +#define UNIFFI_FFIDEF_UNIFFI_ALGOKIT_TRANSACT_FFI_CHECKSUM_FUNC_CALCULATE_FEE +uint16_t uniffi_algokit_transact_ffi_checksum_func_calculate_fee(void + +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_ALGOKIT_TRANSACT_FFI_CHECKSUM_FUNC_DECODE_SIGNED_TRANSACTION +#define UNIFFI_FFIDEF_UNIFFI_ALGOKIT_TRANSACT_FFI_CHECKSUM_FUNC_DECODE_SIGNED_TRANSACTION +uint16_t uniffi_algokit_transact_ffi_checksum_func_decode_signed_transaction(void + +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_ALGOKIT_TRANSACT_FFI_CHECKSUM_FUNC_DECODE_SIGNED_TRANSACTIONS +#define UNIFFI_FFIDEF_UNIFFI_ALGOKIT_TRANSACT_FFI_CHECKSUM_FUNC_DECODE_SIGNED_TRANSACTIONS +uint16_t uniffi_algokit_transact_ffi_checksum_func_decode_signed_transactions(void ); #endif @@ -608,6 +697,24 @@ uint16_t uniffi_algokit_transact_ffi_checksum_func_attach_signature(void #define UNIFFI_FFIDEF_UNIFFI_ALGOKIT_TRANSACT_FFI_CHECKSUM_FUNC_DECODE_TRANSACTION uint16_t uniffi_algokit_transact_ffi_checksum_func_decode_transaction(void +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_ALGOKIT_TRANSACT_FFI_CHECKSUM_FUNC_DECODE_TRANSACTIONS +#define UNIFFI_FFIDEF_UNIFFI_ALGOKIT_TRANSACT_FFI_CHECKSUM_FUNC_DECODE_TRANSACTIONS +uint16_t uniffi_algokit_transact_ffi_checksum_func_decode_transactions(void + +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_ALGOKIT_TRANSACT_FFI_CHECKSUM_FUNC_ENCODE_SIGNED_TRANSACTION +#define UNIFFI_FFIDEF_UNIFFI_ALGOKIT_TRANSACT_FFI_CHECKSUM_FUNC_ENCODE_SIGNED_TRANSACTION +uint16_t uniffi_algokit_transact_ffi_checksum_func_encode_signed_transaction(void + +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_ALGOKIT_TRANSACT_FFI_CHECKSUM_FUNC_ENCODE_SIGNED_TRANSACTIONS +#define UNIFFI_FFIDEF_UNIFFI_ALGOKIT_TRANSACT_FFI_CHECKSUM_FUNC_ENCODE_SIGNED_TRANSACTIONS +uint16_t uniffi_algokit_transact_ffi_checksum_func_encode_signed_transactions(void + ); #endif #ifndef UNIFFI_FFIDEF_UNIFFI_ALGOKIT_TRANSACT_FFI_CHECKSUM_FUNC_ENCODE_TRANSACTION @@ -620,6 +727,12 @@ uint16_t uniffi_algokit_transact_ffi_checksum_func_encode_transaction(void #define UNIFFI_FFIDEF_UNIFFI_ALGOKIT_TRANSACT_FFI_CHECKSUM_FUNC_ENCODE_TRANSACTION_RAW uint16_t uniffi_algokit_transact_ffi_checksum_func_encode_transaction_raw(void +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_ALGOKIT_TRANSACT_FFI_CHECKSUM_FUNC_ENCODE_TRANSACTIONS +#define UNIFFI_FFIDEF_UNIFFI_ALGOKIT_TRANSACT_FFI_CHECKSUM_FUNC_ENCODE_TRANSACTIONS +uint16_t uniffi_algokit_transact_ffi_checksum_func_encode_transactions(void + ); #endif #ifndef UNIFFI_FFIDEF_UNIFFI_ALGOKIT_TRANSACT_FFI_CHECKSUM_FUNC_ESTIMATE_TRANSACTION_SIZE @@ -650,6 +763,36 @@ uint16_t uniffi_algokit_transact_ffi_checksum_func_get_transaction_id(void #define UNIFFI_FFIDEF_UNIFFI_ALGOKIT_TRANSACT_FFI_CHECKSUM_FUNC_GET_TRANSACTION_ID_RAW uint16_t uniffi_algokit_transact_ffi_checksum_func_get_transaction_id_raw(void +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_ALGOKIT_TRANSACT_FFI_CHECKSUM_FUNC_GROUP_TRANSACTIONS +#define UNIFFI_FFIDEF_UNIFFI_ALGOKIT_TRANSACT_FFI_CHECKSUM_FUNC_GROUP_TRANSACTIONS +uint16_t uniffi_algokit_transact_ffi_checksum_func_group_transactions(void + +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_ALGOKIT_TRANSACT_FFI_CHECKSUM_FUNC_MERGE_MULTISIGNATURES +#define UNIFFI_FFIDEF_UNIFFI_ALGOKIT_TRANSACT_FFI_CHECKSUM_FUNC_MERGE_MULTISIGNATURES +uint16_t uniffi_algokit_transact_ffi_checksum_func_merge_multisignatures(void + +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_ALGOKIT_TRANSACT_FFI_CHECKSUM_FUNC_NEW_MULTISIG_SIGNATURE +#define UNIFFI_FFIDEF_UNIFFI_ALGOKIT_TRANSACT_FFI_CHECKSUM_FUNC_NEW_MULTISIG_SIGNATURE +uint16_t uniffi_algokit_transact_ffi_checksum_func_new_multisig_signature(void + +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_ALGOKIT_TRANSACT_FFI_CHECKSUM_FUNC_PARTICIPANTS_FROM_MULTISIG_SIGNATURE +#define UNIFFI_FFIDEF_UNIFFI_ALGOKIT_TRANSACT_FFI_CHECKSUM_FUNC_PARTICIPANTS_FROM_MULTISIG_SIGNATURE +uint16_t uniffi_algokit_transact_ffi_checksum_func_participants_from_multisig_signature(void + +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_ALGOKIT_TRANSACT_FFI_CHECKSUM_FUNC_PUBLIC_KEY_FROM_ADDRESS +#define UNIFFI_FFIDEF_UNIFFI_ALGOKIT_TRANSACT_FFI_CHECKSUM_FUNC_PUBLIC_KEY_FROM_ADDRESS +uint16_t uniffi_algokit_transact_ffi_checksum_func_public_key_from_address(void + ); #endif #ifndef UNIFFI_FFIDEF_FFI_ALGOKIT_TRANSACT_FFI_UNIFFI_CONTRACT_VERSION diff --git a/packages/swift/AlgoKitTransact/Frameworks/algokit_transact.xcframework/ios-arm64_x86_64-simulator/Headers/module.modulemap b/packages/swift/AlgoKitTransact/Frameworks/algokit_transact.xcframework/ios-arm64_x86_64-simulator/Headers/module.modulemap index 5c45883d7..861b066ff 100644 --- a/packages/swift/AlgoKitTransact/Frameworks/algokit_transact.xcframework/ios-arm64_x86_64-simulator/Headers/module.modulemap +++ b/packages/swift/AlgoKitTransact/Frameworks/algokit_transact.xcframework/ios-arm64_x86_64-simulator/Headers/module.modulemap @@ -1,4 +1,7 @@ module algokit_transactFFI { header "algokit_transactFFI.h" export * + use "Darwin" + use "_Builtin_stdbool" + use "_Builtin_stdint" } \ No newline at end of file diff --git a/packages/swift/AlgoKitTransact/Frameworks/algokit_transact.xcframework/ios-arm64_x86_64-simulator/libalgokit_transact_ffi-ios-sim.a b/packages/swift/AlgoKitTransact/Frameworks/algokit_transact.xcframework/ios-arm64_x86_64-simulator/libalgokit_transact_ffi-ios-sim.a index 48052d3ca..43b4ade9b 100644 Binary files a/packages/swift/AlgoKitTransact/Frameworks/algokit_transact.xcframework/ios-arm64_x86_64-simulator/libalgokit_transact_ffi-ios-sim.a and b/packages/swift/AlgoKitTransact/Frameworks/algokit_transact.xcframework/ios-arm64_x86_64-simulator/libalgokit_transact_ffi-ios-sim.a differ diff --git a/packages/swift/AlgoKitTransact/Frameworks/algokit_transact.xcframework/macos-arm64_x86_64/Headers/algokit_transact.swift b/packages/swift/AlgoKitTransact/Frameworks/algokit_transact.xcframework/macos-arm64_x86_64/Headers/algokit_transact.swift index 8fe29c207..92e86dfc8 100644 --- a/packages/swift/AlgoKitTransact/Frameworks/algokit_transact.xcframework/macos-arm64_x86_64/Headers/algokit_transact.swift +++ b/packages/swift/AlgoKitTransact/Frameworks/algokit_transact.xcframework/macos-arm64_x86_64/Headers/algokit_transact.swift @@ -281,7 +281,7 @@ private func makeRustCall( _ callback: (UnsafeMutablePointer) -> T, errorHandler: ((RustBuffer) throws -> E)? ) throws -> T { - uniffiEnsureInitialized() + uniffiEnsureAlgokitTransactFfiInitialized() var callStatus = RustCallStatus.init() let returnedVal = callback(&callStatus) try uniffiCheckCallStatus(callStatus: callStatus, errorHandler: errorHandler) @@ -352,9 +352,10 @@ private func uniffiTraitInterfaceCallWithError( callStatus.pointee.errorBuf = FfiConverterString.lower(String(describing: error)) } } -fileprivate class UniffiHandleMap { - private var map: [UInt64: T] = [:] +fileprivate final class UniffiHandleMap: @unchecked Sendable { + // All mutation happens with this lock held, which is why we implement @unchecked Sendable. private let lock = NSLock() + private var map: [UInt64: T] = [:] private var currentHandle: UInt64 = 1 func insert(obj: T) -> UInt64 { @@ -396,6 +397,38 @@ fileprivate class UniffiHandleMap { // Public interface members begin here. +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +fileprivate struct FfiConverterUInt8: FfiConverterPrimitive { + typealias FfiType = UInt8 + typealias SwiftType = UInt8 + + public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> UInt8 { + return try lift(readInt(&buf)) + } + + public static func write(_ value: UInt8, into buf: inout [UInt8]) { + writeInt(&buf, lower(value)) + } +} + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +fileprivate struct FfiConverterUInt32: FfiConverterPrimitive { + typealias FfiType = UInt32 + typealias SwiftType = UInt32 + + public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> UInt32 { + return try lift(readInt(&buf)) + } + + public static func write(_ value: SwiftType, into buf: inout [UInt8]) { + writeInt(&buf, lower(value)) + } +} + #if swift(>=5.8) @_documentation(visibility: private) #endif @@ -412,6 +445,30 @@ fileprivate struct FfiConverterUInt64: FfiConverterPrimitive { } } +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +fileprivate struct FfiConverterBool : FfiConverter { + typealias FfiType = Int8 + typealias SwiftType = Bool + + public static func lift(_ value: Int8) throws -> Bool { + return value != 0 + } + + public static func lower(_ value: Bool) -> Int8 { + return value ? 1 : 0 + } + + public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> Bool { + return try lift(readInt(&buf)) + } + + public static func write(_ value: Bool, into buf: inout [UInt8]) { + writeInt(&buf, lower(value)) + } +} + #if swift(>=5.8) @_documentation(visibility: private) #endif @@ -472,53 +529,269 @@ fileprivate struct FfiConverterData: FfiConverterRustBuffer { } -public struct Address { - public var address: String - public var pubKey: ByteBuf +/** + * Represents an app call transaction that interacts with Algorand Smart Contracts. + * + * App call transactions are used to create, update, delete, opt-in to, + * close out of, or clear state from Algorand applications (smart contracts). + */ +public struct AppCallTransactionFields { + /** + * ID of the app being called. + * + * Set this to 0 to indicate an app creation call. + */ + public var appId: UInt64 + /** + * Defines what additional actions occur with the transaction. + */ + public var onComplete: OnApplicationComplete + /** + * Logic executed for every app call transaction, except when + * on-completion is set to "clear". + * + * Approval programs may reject the transaction. + * Only required for app creation and update transactions. + */ + public var approvalProgram: Data? + /** + * Logic executed for app call transactions with on-completion set to "clear". + * + * Clear state programs cannot reject the transaction. + * Only required for app creation and update transactions. + */ + public var clearStateProgram: Data? + /** + * Holds the maximum number of global state values. + * + * Only required for app creation transactions. + * This cannot be changed after creation. + */ + public var globalStateSchema: StateSchema? + /** + * Holds the maximum number of local state values. + * + * Only required for app creation transactions. + * This cannot be changed after creation. + */ + public var localStateSchema: StateSchema? + /** + * Number of additional pages allocated to the app's approval + * and clear state programs. + * + * Each extra program page is 2048 bytes. The sum of approval program + * and clear state program may not exceed 2048*(1+extra_program_pages) bytes. + * Currently, the maximum value is 3. + * This cannot be changed after creation. + */ + public var extraProgramPages: UInt32? + /** + * Transaction specific arguments available in the app's + * approval program and clear state program. + */ + public var args: [Data]? + /** + * List of accounts in addition to the sender that may be accessed + * from the app's approval program and clear state program. + */ + public var accountReferences: [String]? + /** + * List of apps in addition to the current app that may be called + * from the app's approval program and clear state program. + */ + public var appReferences: [UInt64]? + /** + * Lists the assets whose parameters may be accessed by this app's + * approval program and clear state program. + * + * The access is read-only. + */ + public var assetReferences: [UInt64]? + /** + * The boxes that should be made available for the runtime of the program. + */ + public var boxReferences: [BoxReference]? // Default memberwise initializers are never public by default, so we // declare one manually. - public init(address: String, pubKey: ByteBuf) { - self.address = address - self.pubKey = pubKey - } -} - + public init( + /** + * ID of the app being called. + * + * Set this to 0 to indicate an app creation call. + */appId: UInt64, + /** + * Defines what additional actions occur with the transaction. + */onComplete: OnApplicationComplete, + /** + * Logic executed for every app call transaction, except when + * on-completion is set to "clear". + * + * Approval programs may reject the transaction. + * Only required for app creation and update transactions. + */approvalProgram: Data? = nil, + /** + * Logic executed for app call transactions with on-completion set to "clear". + * + * Clear state programs cannot reject the transaction. + * Only required for app creation and update transactions. + */clearStateProgram: Data? = nil, + /** + * Holds the maximum number of global state values. + * + * Only required for app creation transactions. + * This cannot be changed after creation. + */globalStateSchema: StateSchema? = nil, + /** + * Holds the maximum number of local state values. + * + * Only required for app creation transactions. + * This cannot be changed after creation. + */localStateSchema: StateSchema? = nil, + /** + * Number of additional pages allocated to the app's approval + * and clear state programs. + * + * Each extra program page is 2048 bytes. The sum of approval program + * and clear state program may not exceed 2048*(1+extra_program_pages) bytes. + * Currently, the maximum value is 3. + * This cannot be changed after creation. + */extraProgramPages: UInt32? = nil, + /** + * Transaction specific arguments available in the app's + * approval program and clear state program. + */args: [Data]? = nil, + /** + * List of accounts in addition to the sender that may be accessed + * from the app's approval program and clear state program. + */accountReferences: [String]? = nil, + /** + * List of apps in addition to the current app that may be called + * from the app's approval program and clear state program. + */appReferences: [UInt64]? = nil, + /** + * Lists the assets whose parameters may be accessed by this app's + * approval program and clear state program. + * + * The access is read-only. + */assetReferences: [UInt64]? = nil, + /** + * The boxes that should be made available for the runtime of the program. + */boxReferences: [BoxReference]? = nil) { + self.appId = appId + self.onComplete = onComplete + self.approvalProgram = approvalProgram + self.clearStateProgram = clearStateProgram + self.globalStateSchema = globalStateSchema + self.localStateSchema = localStateSchema + self.extraProgramPages = extraProgramPages + self.args = args + self.accountReferences = accountReferences + self.appReferences = appReferences + self.assetReferences = assetReferences + self.boxReferences = boxReferences + } +} + +#if compiler(>=6) +extension AppCallTransactionFields: Sendable {} +#endif -extension Address: Equatable, Hashable { - public static func ==(lhs: Address, rhs: Address) -> Bool { - if lhs.address != rhs.address { +extension AppCallTransactionFields: Equatable, Hashable { + public static func ==(lhs: AppCallTransactionFields, rhs: AppCallTransactionFields) -> Bool { + if lhs.appId != rhs.appId { return false } - if lhs.pubKey != rhs.pubKey { + if lhs.onComplete != rhs.onComplete { + return false + } + if lhs.approvalProgram != rhs.approvalProgram { + return false + } + if lhs.clearStateProgram != rhs.clearStateProgram { + return false + } + if lhs.globalStateSchema != rhs.globalStateSchema { + return false + } + if lhs.localStateSchema != rhs.localStateSchema { + return false + } + if lhs.extraProgramPages != rhs.extraProgramPages { + return false + } + if lhs.args != rhs.args { + return false + } + if lhs.accountReferences != rhs.accountReferences { + return false + } + if lhs.appReferences != rhs.appReferences { + return false + } + if lhs.assetReferences != rhs.assetReferences { + return false + } + if lhs.boxReferences != rhs.boxReferences { return false } return true } public func hash(into hasher: inout Hasher) { - hasher.combine(address) - hasher.combine(pubKey) + hasher.combine(appId) + hasher.combine(onComplete) + hasher.combine(approvalProgram) + hasher.combine(clearStateProgram) + hasher.combine(globalStateSchema) + hasher.combine(localStateSchema) + hasher.combine(extraProgramPages) + hasher.combine(args) + hasher.combine(accountReferences) + hasher.combine(appReferences) + hasher.combine(assetReferences) + hasher.combine(boxReferences) } } + #if swift(>=5.8) @_documentation(visibility: private) #endif -public struct FfiConverterTypeAddress: FfiConverterRustBuffer { - public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> Address { +public struct FfiConverterTypeAppCallTransactionFields: FfiConverterRustBuffer { + public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> AppCallTransactionFields { return - try Address( - address: FfiConverterString.read(from: &buf), - pubKey: FfiConverterTypeByteBuf.read(from: &buf) + try AppCallTransactionFields( + appId: FfiConverterUInt64.read(from: &buf), + onComplete: FfiConverterTypeOnApplicationComplete.read(from: &buf), + approvalProgram: FfiConverterOptionData.read(from: &buf), + clearStateProgram: FfiConverterOptionData.read(from: &buf), + globalStateSchema: FfiConverterOptionTypeStateSchema.read(from: &buf), + localStateSchema: FfiConverterOptionTypeStateSchema.read(from: &buf), + extraProgramPages: FfiConverterOptionUInt32.read(from: &buf), + args: FfiConverterOptionSequenceData.read(from: &buf), + accountReferences: FfiConverterOptionSequenceString.read(from: &buf), + appReferences: FfiConverterOptionSequenceUInt64.read(from: &buf), + assetReferences: FfiConverterOptionSequenceUInt64.read(from: &buf), + boxReferences: FfiConverterOptionSequenceTypeBoxReference.read(from: &buf) ) } - public static func write(_ value: Address, into buf: inout [UInt8]) { - FfiConverterString.write(value.address, into: &buf) - FfiConverterTypeByteBuf.write(value.pubKey, into: &buf) + public static func write(_ value: AppCallTransactionFields, into buf: inout [UInt8]) { + FfiConverterUInt64.write(value.appId, into: &buf) + FfiConverterTypeOnApplicationComplete.write(value.onComplete, into: &buf) + FfiConverterOptionData.write(value.approvalProgram, into: &buf) + FfiConverterOptionData.write(value.clearStateProgram, into: &buf) + FfiConverterOptionTypeStateSchema.write(value.globalStateSchema, into: &buf) + FfiConverterOptionTypeStateSchema.write(value.localStateSchema, into: &buf) + FfiConverterOptionUInt32.write(value.extraProgramPages, into: &buf) + FfiConverterOptionSequenceData.write(value.args, into: &buf) + FfiConverterOptionSequenceString.write(value.accountReferences, into: &buf) + FfiConverterOptionSequenceUInt64.write(value.appReferences, into: &buf) + FfiConverterOptionSequenceUInt64.write(value.assetReferences, into: &buf) + FfiConverterOptionSequenceTypeBoxReference.write(value.boxReferences, into: &buf) } } @@ -526,53 +799,306 @@ public struct FfiConverterTypeAddress: FfiConverterRustBuffer { #if swift(>=5.8) @_documentation(visibility: private) #endif -public func FfiConverterTypeAddress_lift(_ buf: RustBuffer) throws -> Address { - return try FfiConverterTypeAddress.lift(buf) +public func FfiConverterTypeAppCallTransactionFields_lift(_ buf: RustBuffer) throws -> AppCallTransactionFields { + return try FfiConverterTypeAppCallTransactionFields.lift(buf) } #if swift(>=5.8) @_documentation(visibility: private) #endif -public func FfiConverterTypeAddress_lower(_ value: Address) -> RustBuffer { - return FfiConverterTypeAddress.lower(value) +public func FfiConverterTypeAppCallTransactionFields_lower(_ value: AppCallTransactionFields) -> RustBuffer { + return FfiConverterTypeAppCallTransactionFields.lower(value) } -public struct AssetTransferTransactionFields { +/** + * Parameters to define an asset config transaction. + * + * For asset creation, the asset ID field must be 0. + * For asset reconfiguration, the asset ID field must be set. Only fields manager, reserve, freeze, and clawback can be set. + * For asset destroy, the asset ID field must be set, all other fields must not be set. + * + * **Note:** The manager, reserve, freeze, and clawback addresses + * are immutably empty if they are not set. If manager is not set then + * all fields are immutable from that point forward. + */ +public struct AssetConfigTransactionFields { + /** + * ID of the asset to operate on. + * + * For asset creation, this must be 0. + * For asset reconfiguration this is the ID of the existing asset to be reconfigured, + * For asset destroy this is the ID of the existing asset to be destroyed. + */ public var assetId: UInt64 - public var amount: UInt64 - public var receiver: Address - public var assetSender: Address? - public var closeRemainderTo: Address? + /** + * The total amount of the smallest divisible (decimal) unit to create. + * + * Required when creating a new asset. + * For example, if creating a asset with 2 decimals and wanting a total supply of 100 units, this value should be 10000. + * + * This field can only be specified upon asset creation. + */ + public var total: UInt64? + /** + * The amount of decimal places the asset should have. + * + * If unspecified then the asset will be in whole units (i.e. `0`). + * * If 0, the asset is not divisible; + * * If 1, the base unit of the asset is in tenths; + * * If 2, the base unit of the asset is in hundredths; + * * If 3, the base unit of the asset is in thousandths; + * + * and so on up to 19 decimal places. + * + * This field can only be specified upon asset creation. + */ + public var decimals: UInt32? + /** + * Whether the asset is frozen by default for all accounts. + * Defaults to `false`. + * + * If `true` then for anyone apart from the creator to hold the + * asset it needs to be unfrozen per account using an asset freeze + * transaction from the `freeze` account, which must be set on creation. + * + * This field can only be specified upon asset creation. + */ + public var defaultFrozen: Bool? + /** + * The optional name of the asset. + * + * Max size is 32 bytes. + * + * This field can only be specified upon asset creation. + */ + public var assetName: String? + /** + * The optional name of the unit of this asset (e.g. ticker name). + * + * Max size is 8 bytes. + * + * This field can only be specified upon asset creation. + */ + public var unitName: String? + /** + * Specifies an optional URL where more information about the asset can be retrieved (e.g. metadata). + * + * Max size is 96 bytes. + * + * This field can only be specified upon asset creation. + */ + public var url: String? + /** + * 32-byte hash of some metadata that is relevant to your asset and/or asset holders. + * + * The format of this metadata is up to the application. + * + * This field can only be specified upon asset creation. + */ + public var metadataHash: Data? + /** + * The address of the optional account that can manage the configuration of the asset and destroy it. + * + * The fields it can change are `manager`, `reserve`, `clawback`, and `freeze`. + * + * If not set or set to the Zero address the asset becomes permanently immutable. + */ + public var manager: String? + /** + * The address of the optional account that holds the reserve (uncirculated supply) units of the asset. + * + * This address has no specific authority in the protocol itself and is informational only. + * + * Some standards like [ARC-19](https://github.com/algorandfoundation/ARCs/blob/main/ARCs/arc-0019.md) + * rely on this field to hold meaningful data. + * + * It can be used in the case where you want to signal to holders of your asset that the uncirculated units + * of the asset reside in an account that is different from the default creator account. + * + * If not set or set to the Zero address is permanently empty. + */ + public var reserve: String? + /** + * The address of the optional account that can be used to freeze or unfreeze holdings of this asset for any account. + * + * If empty, freezing is not permitted. + * + * If not set or set to the Zero address is permanently empty. + */ + public var freeze: String? + /** + * The address of the optional account that can clawback holdings of this asset from any account. + * + * **This field should be used with caution** as the clawback account has the ability to **unconditionally take assets from any account**. + * + * If empty, clawback is not permitted. + * + * If not set or set to the Zero address is permanently empty. + */ + public var clawback: String? // Default memberwise initializers are never public by default, so we // declare one manually. - public init(assetId: UInt64, amount: UInt64, receiver: Address, assetSender: Address? = nil, closeRemainderTo: Address? = nil) { + public init( + /** + * ID of the asset to operate on. + * + * For asset creation, this must be 0. + * For asset reconfiguration this is the ID of the existing asset to be reconfigured, + * For asset destroy this is the ID of the existing asset to be destroyed. + */assetId: UInt64, + /** + * The total amount of the smallest divisible (decimal) unit to create. + * + * Required when creating a new asset. + * For example, if creating a asset with 2 decimals and wanting a total supply of 100 units, this value should be 10000. + * + * This field can only be specified upon asset creation. + */total: UInt64? = nil, + /** + * The amount of decimal places the asset should have. + * + * If unspecified then the asset will be in whole units (i.e. `0`). + * * If 0, the asset is not divisible; + * * If 1, the base unit of the asset is in tenths; + * * If 2, the base unit of the asset is in hundredths; + * * If 3, the base unit of the asset is in thousandths; + * + * and so on up to 19 decimal places. + * + * This field can only be specified upon asset creation. + */decimals: UInt32? = nil, + /** + * Whether the asset is frozen by default for all accounts. + * Defaults to `false`. + * + * If `true` then for anyone apart from the creator to hold the + * asset it needs to be unfrozen per account using an asset freeze + * transaction from the `freeze` account, which must be set on creation. + * + * This field can only be specified upon asset creation. + */defaultFrozen: Bool? = nil, + /** + * The optional name of the asset. + * + * Max size is 32 bytes. + * + * This field can only be specified upon asset creation. + */assetName: String? = nil, + /** + * The optional name of the unit of this asset (e.g. ticker name). + * + * Max size is 8 bytes. + * + * This field can only be specified upon asset creation. + */unitName: String? = nil, + /** + * Specifies an optional URL where more information about the asset can be retrieved (e.g. metadata). + * + * Max size is 96 bytes. + * + * This field can only be specified upon asset creation. + */url: String? = nil, + /** + * 32-byte hash of some metadata that is relevant to your asset and/or asset holders. + * + * The format of this metadata is up to the application. + * + * This field can only be specified upon asset creation. + */metadataHash: Data? = nil, + /** + * The address of the optional account that can manage the configuration of the asset and destroy it. + * + * The fields it can change are `manager`, `reserve`, `clawback`, and `freeze`. + * + * If not set or set to the Zero address the asset becomes permanently immutable. + */manager: String? = nil, + /** + * The address of the optional account that holds the reserve (uncirculated supply) units of the asset. + * + * This address has no specific authority in the protocol itself and is informational only. + * + * Some standards like [ARC-19](https://github.com/algorandfoundation/ARCs/blob/main/ARCs/arc-0019.md) + * rely on this field to hold meaningful data. + * + * It can be used in the case where you want to signal to holders of your asset that the uncirculated units + * of the asset reside in an account that is different from the default creator account. + * + * If not set or set to the Zero address is permanently empty. + */reserve: String? = nil, + /** + * The address of the optional account that can be used to freeze or unfreeze holdings of this asset for any account. + * + * If empty, freezing is not permitted. + * + * If not set or set to the Zero address is permanently empty. + */freeze: String? = nil, + /** + * The address of the optional account that can clawback holdings of this asset from any account. + * + * **This field should be used with caution** as the clawback account has the ability to **unconditionally take assets from any account**. + * + * If empty, clawback is not permitted. + * + * If not set or set to the Zero address is permanently empty. + */clawback: String? = nil) { self.assetId = assetId - self.amount = amount - self.receiver = receiver - self.assetSender = assetSender - self.closeRemainderTo = closeRemainderTo - } -} - + self.total = total + self.decimals = decimals + self.defaultFrozen = defaultFrozen + self.assetName = assetName + self.unitName = unitName + self.url = url + self.metadataHash = metadataHash + self.manager = manager + self.reserve = reserve + self.freeze = freeze + self.clawback = clawback + } +} + +#if compiler(>=6) +extension AssetConfigTransactionFields: Sendable {} +#endif -extension AssetTransferTransactionFields: Equatable, Hashable { - public static func ==(lhs: AssetTransferTransactionFields, rhs: AssetTransferTransactionFields) -> Bool { +extension AssetConfigTransactionFields: Equatable, Hashable { + public static func ==(lhs: AssetConfigTransactionFields, rhs: AssetConfigTransactionFields) -> Bool { if lhs.assetId != rhs.assetId { return false } - if lhs.amount != rhs.amount { + if lhs.total != rhs.total { return false } - if lhs.receiver != rhs.receiver { + if lhs.decimals != rhs.decimals { return false } - if lhs.assetSender != rhs.assetSender { + if lhs.defaultFrozen != rhs.defaultFrozen { return false } - if lhs.closeRemainderTo != rhs.closeRemainderTo { + if lhs.assetName != rhs.assetName { + return false + } + if lhs.unitName != rhs.unitName { + return false + } + if lhs.url != rhs.url { + return false + } + if lhs.metadataHash != rhs.metadataHash { + return false + } + if lhs.manager != rhs.manager { + return false + } + if lhs.reserve != rhs.reserve { + return false + } + if lhs.freeze != rhs.freeze { + return false + } + if lhs.clawback != rhs.clawback { return false } return true @@ -580,35 +1106,57 @@ extension AssetTransferTransactionFields: Equatable, Hashable { public func hash(into hasher: inout Hasher) { hasher.combine(assetId) - hasher.combine(amount) - hasher.combine(receiver) - hasher.combine(assetSender) - hasher.combine(closeRemainderTo) + hasher.combine(total) + hasher.combine(decimals) + hasher.combine(defaultFrozen) + hasher.combine(assetName) + hasher.combine(unitName) + hasher.combine(url) + hasher.combine(metadataHash) + hasher.combine(manager) + hasher.combine(reserve) + hasher.combine(freeze) + hasher.combine(clawback) } } + #if swift(>=5.8) @_documentation(visibility: private) #endif -public struct FfiConverterTypeAssetTransferTransactionFields: FfiConverterRustBuffer { - public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> AssetTransferTransactionFields { +public struct FfiConverterTypeAssetConfigTransactionFields: FfiConverterRustBuffer { + public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> AssetConfigTransactionFields { return - try AssetTransferTransactionFields( + try AssetConfigTransactionFields( assetId: FfiConverterUInt64.read(from: &buf), - amount: FfiConverterUInt64.read(from: &buf), - receiver: FfiConverterTypeAddress.read(from: &buf), - assetSender: FfiConverterOptionTypeAddress.read(from: &buf), - closeRemainderTo: FfiConverterOptionTypeAddress.read(from: &buf) + total: FfiConverterOptionUInt64.read(from: &buf), + decimals: FfiConverterOptionUInt32.read(from: &buf), + defaultFrozen: FfiConverterOptionBool.read(from: &buf), + assetName: FfiConverterOptionString.read(from: &buf), + unitName: FfiConverterOptionString.read(from: &buf), + url: FfiConverterOptionString.read(from: &buf), + metadataHash: FfiConverterOptionData.read(from: &buf), + manager: FfiConverterOptionString.read(from: &buf), + reserve: FfiConverterOptionString.read(from: &buf), + freeze: FfiConverterOptionString.read(from: &buf), + clawback: FfiConverterOptionString.read(from: &buf) ) } - public static func write(_ value: AssetTransferTransactionFields, into buf: inout [UInt8]) { + public static func write(_ value: AssetConfigTransactionFields, into buf: inout [UInt8]) { FfiConverterUInt64.write(value.assetId, into: &buf) - FfiConverterUInt64.write(value.amount, into: &buf) - FfiConverterTypeAddress.write(value.receiver, into: &buf) - FfiConverterOptionTypeAddress.write(value.assetSender, into: &buf) - FfiConverterOptionTypeAddress.write(value.closeRemainderTo, into: &buf) + FfiConverterOptionUInt64.write(value.total, into: &buf) + FfiConverterOptionUInt32.write(value.decimals, into: &buf) + FfiConverterOptionBool.write(value.defaultFrozen, into: &buf) + FfiConverterOptionString.write(value.assetName, into: &buf) + FfiConverterOptionString.write(value.unitName, into: &buf) + FfiConverterOptionString.write(value.url, into: &buf) + FfiConverterOptionData.write(value.metadataHash, into: &buf) + FfiConverterOptionString.write(value.manager, into: &buf) + FfiConverterOptionString.write(value.reserve, into: &buf) + FfiConverterOptionString.write(value.freeze, into: &buf) + FfiConverterOptionString.write(value.clawback, into: &buf) } } @@ -616,73 +1164,107 @@ public struct FfiConverterTypeAssetTransferTransactionFields: FfiConverterRustBu #if swift(>=5.8) @_documentation(visibility: private) #endif -public func FfiConverterTypeAssetTransferTransactionFields_lift(_ buf: RustBuffer) throws -> AssetTransferTransactionFields { - return try FfiConverterTypeAssetTransferTransactionFields.lift(buf) +public func FfiConverterTypeAssetConfigTransactionFields_lift(_ buf: RustBuffer) throws -> AssetConfigTransactionFields { + return try FfiConverterTypeAssetConfigTransactionFields.lift(buf) } #if swift(>=5.8) @_documentation(visibility: private) #endif -public func FfiConverterTypeAssetTransferTransactionFields_lower(_ value: AssetTransferTransactionFields) -> RustBuffer { - return FfiConverterTypeAssetTransferTransactionFields.lower(value) +public func FfiConverterTypeAssetConfigTransactionFields_lower(_ value: AssetConfigTransactionFields) -> RustBuffer { + return FfiConverterTypeAssetConfigTransactionFields.lower(value) } -public struct PaymentTransactionFields { - public var receiver: Address - public var amount: UInt64 - public var closeRemainderTo: Address? +/** + * Represents an asset freeze transaction that freezes or unfreezes asset holdings. + * + * Asset freeze transactions are used by the asset freeze account to control + * whether a specific account can transfer a particular asset. + */ +public struct AssetFreezeTransactionFields { + /** + * The ID of the asset being frozen/unfrozen. + */ + public var assetId: UInt64 + /** + * The target account whose asset holdings will be affected. + */ + public var freezeTarget: String + /** + * The new freeze status. + * + * `true` to freeze the asset holdings (prevent transfers), + * `false` to unfreeze the asset holdings (allow transfers). + */ + public var frozen: Bool // Default memberwise initializers are never public by default, so we // declare one manually. - public init(receiver: Address, amount: UInt64, closeRemainderTo: Address? = nil) { - self.receiver = receiver - self.amount = amount - self.closeRemainderTo = closeRemainderTo + public init( + /** + * The ID of the asset being frozen/unfrozen. + */assetId: UInt64, + /** + * The target account whose asset holdings will be affected. + */freezeTarget: String, + /** + * The new freeze status. + * + * `true` to freeze the asset holdings (prevent transfers), + * `false` to unfreeze the asset holdings (allow transfers). + */frozen: Bool) { + self.assetId = assetId + self.freezeTarget = freezeTarget + self.frozen = frozen } } +#if compiler(>=6) +extension AssetFreezeTransactionFields: Sendable {} +#endif -extension PaymentTransactionFields: Equatable, Hashable { - public static func ==(lhs: PaymentTransactionFields, rhs: PaymentTransactionFields) -> Bool { - if lhs.receiver != rhs.receiver { +extension AssetFreezeTransactionFields: Equatable, Hashable { + public static func ==(lhs: AssetFreezeTransactionFields, rhs: AssetFreezeTransactionFields) -> Bool { + if lhs.assetId != rhs.assetId { return false } - if lhs.amount != rhs.amount { + if lhs.freezeTarget != rhs.freezeTarget { return false } - if lhs.closeRemainderTo != rhs.closeRemainderTo { + if lhs.frozen != rhs.frozen { return false } return true } public func hash(into hasher: inout Hasher) { - hasher.combine(receiver) - hasher.combine(amount) - hasher.combine(closeRemainderTo) + hasher.combine(assetId) + hasher.combine(freezeTarget) + hasher.combine(frozen) } } + #if swift(>=5.8) @_documentation(visibility: private) #endif -public struct FfiConverterTypePaymentTransactionFields: FfiConverterRustBuffer { - public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> PaymentTransactionFields { +public struct FfiConverterTypeAssetFreezeTransactionFields: FfiConverterRustBuffer { + public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> AssetFreezeTransactionFields { return - try PaymentTransactionFields( - receiver: FfiConverterTypeAddress.read(from: &buf), - amount: FfiConverterUInt64.read(from: &buf), - closeRemainderTo: FfiConverterOptionTypeAddress.read(from: &buf) + try AssetFreezeTransactionFields( + assetId: FfiConverterUInt64.read(from: &buf), + freezeTarget: FfiConverterString.read(from: &buf), + frozen: FfiConverterBool.read(from: &buf) ) } - public static func write(_ value: PaymentTransactionFields, into buf: inout [UInt8]) { - FfiConverterTypeAddress.write(value.receiver, into: &buf) - FfiConverterUInt64.write(value.amount, into: &buf) - FfiConverterOptionTypeAddress.write(value.closeRemainderTo, into: &buf) + public static func write(_ value: AssetFreezeTransactionFields, into buf: inout [UInt8]) { + FfiConverterUInt64.write(value.assetId, into: &buf) + FfiConverterString.write(value.freezeTarget, into: &buf) + FfiConverterBool.write(value.frozen, into: &buf) } } @@ -690,38 +1272,993 @@ public struct FfiConverterTypePaymentTransactionFields: FfiConverterRustBuffer { #if swift(>=5.8) @_documentation(visibility: private) #endif -public func FfiConverterTypePaymentTransactionFields_lift(_ buf: RustBuffer) throws -> PaymentTransactionFields { - return try FfiConverterTypePaymentTransactionFields.lift(buf) +public func FfiConverterTypeAssetFreezeTransactionFields_lift(_ buf: RustBuffer) throws -> AssetFreezeTransactionFields { + return try FfiConverterTypeAssetFreezeTransactionFields.lift(buf) } #if swift(>=5.8) @_documentation(visibility: private) #endif -public func FfiConverterTypePaymentTransactionFields_lower(_ value: PaymentTransactionFields) -> RustBuffer { - return FfiConverterTypePaymentTransactionFields.lower(value) +public func FfiConverterTypeAssetFreezeTransactionFields_lower(_ value: AssetFreezeTransactionFields) -> RustBuffer { + return FfiConverterTypeAssetFreezeTransactionFields.lower(value) } -public struct Transaction { - /** - * The type of transaction - */ - public var transactionType: TransactionType - /** - * The sender of the transaction - */ - public var sender: Address - public var fee: UInt64 - public var firstValid: UInt64 - public var lastValid: UInt64 - public var genesisHash: ByteBuf? - public var genesisId: String? - public var note: ByteBuf? - public var rekeyTo: Address? - public var lease: ByteBuf? - public var group: ByteBuf? - public var payment: PaymentTransactionFields? - public var assetTransfer: AssetTransferTransactionFields? +public struct AssetTransferTransactionFields { + public var assetId: UInt64 + public var amount: UInt64 + public var receiver: String + public var assetSender: String? + public var closeRemainderTo: String? + + // Default memberwise initializers are never public by default, so we + // declare one manually. + public init(assetId: UInt64, amount: UInt64, receiver: String, assetSender: String? = nil, closeRemainderTo: String? = nil) { + self.assetId = assetId + self.amount = amount + self.receiver = receiver + self.assetSender = assetSender + self.closeRemainderTo = closeRemainderTo + } +} + +#if compiler(>=6) +extension AssetTransferTransactionFields: Sendable {} +#endif + + +extension AssetTransferTransactionFields: Equatable, Hashable { + public static func ==(lhs: AssetTransferTransactionFields, rhs: AssetTransferTransactionFields) -> Bool { + if lhs.assetId != rhs.assetId { + return false + } + if lhs.amount != rhs.amount { + return false + } + if lhs.receiver != rhs.receiver { + return false + } + if lhs.assetSender != rhs.assetSender { + return false + } + if lhs.closeRemainderTo != rhs.closeRemainderTo { + return false + } + return true + } + + public func hash(into hasher: inout Hasher) { + hasher.combine(assetId) + hasher.combine(amount) + hasher.combine(receiver) + hasher.combine(assetSender) + hasher.combine(closeRemainderTo) + } +} + + + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +public struct FfiConverterTypeAssetTransferTransactionFields: FfiConverterRustBuffer { + public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> AssetTransferTransactionFields { + return + try AssetTransferTransactionFields( + assetId: FfiConverterUInt64.read(from: &buf), + amount: FfiConverterUInt64.read(from: &buf), + receiver: FfiConverterString.read(from: &buf), + assetSender: FfiConverterOptionString.read(from: &buf), + closeRemainderTo: FfiConverterOptionString.read(from: &buf) + ) + } + + public static func write(_ value: AssetTransferTransactionFields, into buf: inout [UInt8]) { + FfiConverterUInt64.write(value.assetId, into: &buf) + FfiConverterUInt64.write(value.amount, into: &buf) + FfiConverterString.write(value.receiver, into: &buf) + FfiConverterOptionString.write(value.assetSender, into: &buf) + FfiConverterOptionString.write(value.closeRemainderTo, into: &buf) + } +} + + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +public func FfiConverterTypeAssetTransferTransactionFields_lift(_ buf: RustBuffer) throws -> AssetTransferTransactionFields { + return try FfiConverterTypeAssetTransferTransactionFields.lift(buf) +} + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +public func FfiConverterTypeAssetTransferTransactionFields_lower(_ value: AssetTransferTransactionFields) -> RustBuffer { + return FfiConverterTypeAssetTransferTransactionFields.lower(value) +} + + +/** + * Box reference for app call transactions. + * + * References a specific box that should be made available for the runtime + * of the program. + */ +public struct BoxReference { + /** + * App ID that owns the box. + * A value of 0 indicates the current app. + */ + public var appId: UInt64 + /** + * Name of the box. + */ + public var name: Data + + // Default memberwise initializers are never public by default, so we + // declare one manually. + public init( + /** + * App ID that owns the box. + * A value of 0 indicates the current app. + */appId: UInt64, + /** + * Name of the box. + */name: Data) { + self.appId = appId + self.name = name + } +} + +#if compiler(>=6) +extension BoxReference: Sendable {} +#endif + + +extension BoxReference: Equatable, Hashable { + public static func ==(lhs: BoxReference, rhs: BoxReference) -> Bool { + if lhs.appId != rhs.appId { + return false + } + if lhs.name != rhs.name { + return false + } + return true + } + + public func hash(into hasher: inout Hasher) { + hasher.combine(appId) + hasher.combine(name) + } +} + + + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +public struct FfiConverterTypeBoxReference: FfiConverterRustBuffer { + public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> BoxReference { + return + try BoxReference( + appId: FfiConverterUInt64.read(from: &buf), + name: FfiConverterData.read(from: &buf) + ) + } + + public static func write(_ value: BoxReference, into buf: inout [UInt8]) { + FfiConverterUInt64.write(value.appId, into: &buf) + FfiConverterData.write(value.name, into: &buf) + } +} + + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +public func FfiConverterTypeBoxReference_lift(_ buf: RustBuffer) throws -> BoxReference { + return try FfiConverterTypeBoxReference.lift(buf) +} + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +public func FfiConverterTypeBoxReference_lower(_ value: BoxReference) -> RustBuffer { + return FfiConverterTypeBoxReference.lower(value) +} + + +public struct FeeParams { + public var feePerByte: UInt64 + public var minFee: UInt64 + public var extraFee: UInt64? + public var maxFee: UInt64? + + // Default memberwise initializers are never public by default, so we + // declare one manually. + public init(feePerByte: UInt64, minFee: UInt64, extraFee: UInt64? = nil, maxFee: UInt64? = nil) { + self.feePerByte = feePerByte + self.minFee = minFee + self.extraFee = extraFee + self.maxFee = maxFee + } +} + +#if compiler(>=6) +extension FeeParams: Sendable {} +#endif + + +extension FeeParams: Equatable, Hashable { + public static func ==(lhs: FeeParams, rhs: FeeParams) -> Bool { + if lhs.feePerByte != rhs.feePerByte { + return false + } + if lhs.minFee != rhs.minFee { + return false + } + if lhs.extraFee != rhs.extraFee { + return false + } + if lhs.maxFee != rhs.maxFee { + return false + } + return true + } + + public func hash(into hasher: inout Hasher) { + hasher.combine(feePerByte) + hasher.combine(minFee) + hasher.combine(extraFee) + hasher.combine(maxFee) + } +} + + + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +public struct FfiConverterTypeFeeParams: FfiConverterRustBuffer { + public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> FeeParams { + return + try FeeParams( + feePerByte: FfiConverterUInt64.read(from: &buf), + minFee: FfiConverterUInt64.read(from: &buf), + extraFee: FfiConverterOptionUInt64.read(from: &buf), + maxFee: FfiConverterOptionUInt64.read(from: &buf) + ) + } + + public static func write(_ value: FeeParams, into buf: inout [UInt8]) { + FfiConverterUInt64.write(value.feePerByte, into: &buf) + FfiConverterUInt64.write(value.minFee, into: &buf) + FfiConverterOptionUInt64.write(value.extraFee, into: &buf) + FfiConverterOptionUInt64.write(value.maxFee, into: &buf) + } +} + + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +public func FfiConverterTypeFeeParams_lift(_ buf: RustBuffer) throws -> FeeParams { + return try FfiConverterTypeFeeParams.lift(buf) +} + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +public func FfiConverterTypeFeeParams_lower(_ value: FeeParams) -> RustBuffer { + return FfiConverterTypeFeeParams.lower(value) +} + + +public struct KeyPairAccount { + public var pubKey: Data + + // Default memberwise initializers are never public by default, so we + // declare one manually. + public init(pubKey: Data) { + self.pubKey = pubKey + } +} + +#if compiler(>=6) +extension KeyPairAccount: Sendable {} +#endif + + +extension KeyPairAccount: Equatable, Hashable { + public static func ==(lhs: KeyPairAccount, rhs: KeyPairAccount) -> Bool { + if lhs.pubKey != rhs.pubKey { + return false + } + return true + } + + public func hash(into hasher: inout Hasher) { + hasher.combine(pubKey) + } +} + + + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +public struct FfiConverterTypeKeyPairAccount: FfiConverterRustBuffer { + public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> KeyPairAccount { + return + try KeyPairAccount( + pubKey: FfiConverterData.read(from: &buf) + ) + } + + public static func write(_ value: KeyPairAccount, into buf: inout [UInt8]) { + FfiConverterData.write(value.pubKey, into: &buf) + } +} + + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +public func FfiConverterTypeKeyPairAccount_lift(_ buf: RustBuffer) throws -> KeyPairAccount { + return try FfiConverterTypeKeyPairAccount.lift(buf) +} + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +public func FfiConverterTypeKeyPairAccount_lower(_ value: KeyPairAccount) -> RustBuffer { + return FfiConverterTypeKeyPairAccount.lower(value) +} + + +public struct KeyRegistrationTransactionFields { + /** + * Root participation public key (32 bytes) + */ + public var voteKey: Data? + /** + * VRF public key (32 bytes) + */ + public var selectionKey: Data? + /** + * State proof key (64 bytes) + */ + public var stateProofKey: Data? + /** + * First round for which the participation key is valid + */ + public var voteFirst: UInt64? + /** + * Last round for which the participation key is valid + */ + public var voteLast: UInt64? + /** + * Key dilution for the 2-level participation key + */ + public var voteKeyDilution: UInt64? + /** + * Mark account as non-reward earning + */ + public var nonParticipation: Bool? + + // Default memberwise initializers are never public by default, so we + // declare one manually. + public init( + /** + * Root participation public key (32 bytes) + */voteKey: Data? = nil, + /** + * VRF public key (32 bytes) + */selectionKey: Data? = nil, + /** + * State proof key (64 bytes) + */stateProofKey: Data? = nil, + /** + * First round for which the participation key is valid + */voteFirst: UInt64? = nil, + /** + * Last round for which the participation key is valid + */voteLast: UInt64? = nil, + /** + * Key dilution for the 2-level participation key + */voteKeyDilution: UInt64? = nil, + /** + * Mark account as non-reward earning + */nonParticipation: Bool? = nil) { + self.voteKey = voteKey + self.selectionKey = selectionKey + self.stateProofKey = stateProofKey + self.voteFirst = voteFirst + self.voteLast = voteLast + self.voteKeyDilution = voteKeyDilution + self.nonParticipation = nonParticipation + } +} + +#if compiler(>=6) +extension KeyRegistrationTransactionFields: Sendable {} +#endif + + +extension KeyRegistrationTransactionFields: Equatable, Hashable { + public static func ==(lhs: KeyRegistrationTransactionFields, rhs: KeyRegistrationTransactionFields) -> Bool { + if lhs.voteKey != rhs.voteKey { + return false + } + if lhs.selectionKey != rhs.selectionKey { + return false + } + if lhs.stateProofKey != rhs.stateProofKey { + return false + } + if lhs.voteFirst != rhs.voteFirst { + return false + } + if lhs.voteLast != rhs.voteLast { + return false + } + if lhs.voteKeyDilution != rhs.voteKeyDilution { + return false + } + if lhs.nonParticipation != rhs.nonParticipation { + return false + } + return true + } + + public func hash(into hasher: inout Hasher) { + hasher.combine(voteKey) + hasher.combine(selectionKey) + hasher.combine(stateProofKey) + hasher.combine(voteFirst) + hasher.combine(voteLast) + hasher.combine(voteKeyDilution) + hasher.combine(nonParticipation) + } +} + + + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +public struct FfiConverterTypeKeyRegistrationTransactionFields: FfiConverterRustBuffer { + public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> KeyRegistrationTransactionFields { + return + try KeyRegistrationTransactionFields( + voteKey: FfiConverterOptionData.read(from: &buf), + selectionKey: FfiConverterOptionData.read(from: &buf), + stateProofKey: FfiConverterOptionData.read(from: &buf), + voteFirst: FfiConverterOptionUInt64.read(from: &buf), + voteLast: FfiConverterOptionUInt64.read(from: &buf), + voteKeyDilution: FfiConverterOptionUInt64.read(from: &buf), + nonParticipation: FfiConverterOptionBool.read(from: &buf) + ) + } + + public static func write(_ value: KeyRegistrationTransactionFields, into buf: inout [UInt8]) { + FfiConverterOptionData.write(value.voteKey, into: &buf) + FfiConverterOptionData.write(value.selectionKey, into: &buf) + FfiConverterOptionData.write(value.stateProofKey, into: &buf) + FfiConverterOptionUInt64.write(value.voteFirst, into: &buf) + FfiConverterOptionUInt64.write(value.voteLast, into: &buf) + FfiConverterOptionUInt64.write(value.voteKeyDilution, into: &buf) + FfiConverterOptionBool.write(value.nonParticipation, into: &buf) + } +} + + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +public func FfiConverterTypeKeyRegistrationTransactionFields_lift(_ buf: RustBuffer) throws -> KeyRegistrationTransactionFields { + return try FfiConverterTypeKeyRegistrationTransactionFields.lift(buf) +} + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +public func FfiConverterTypeKeyRegistrationTransactionFields_lower(_ value: KeyRegistrationTransactionFields) -> RustBuffer { + return FfiConverterTypeKeyRegistrationTransactionFields.lower(value) +} + + +/** + * Representation of an Algorand multisignature signature. + */ +public struct MultisigSignature { + /** + * Multisig version. + */ + public var version: UInt8 + /** + * Minimum number of signatures required. + */ + public var threshold: UInt8 + /** + * List of subsignatures for each participant. + */ + public var subsignatures: [MultisigSubsignature] + + // Default memberwise initializers are never public by default, so we + // declare one manually. + public init( + /** + * Multisig version. + */version: UInt8, + /** + * Minimum number of signatures required. + */threshold: UInt8, + /** + * List of subsignatures for each participant. + */subsignatures: [MultisigSubsignature]) { + self.version = version + self.threshold = threshold + self.subsignatures = subsignatures + } +} + +#if compiler(>=6) +extension MultisigSignature: Sendable {} +#endif + + +extension MultisigSignature: Equatable, Hashable { + public static func ==(lhs: MultisigSignature, rhs: MultisigSignature) -> Bool { + if lhs.version != rhs.version { + return false + } + if lhs.threshold != rhs.threshold { + return false + } + if lhs.subsignatures != rhs.subsignatures { + return false + } + return true + } + + public func hash(into hasher: inout Hasher) { + hasher.combine(version) + hasher.combine(threshold) + hasher.combine(subsignatures) + } +} + + + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +public struct FfiConverterTypeMultisigSignature: FfiConverterRustBuffer { + public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> MultisigSignature { + return + try MultisigSignature( + version: FfiConverterUInt8.read(from: &buf), + threshold: FfiConverterUInt8.read(from: &buf), + subsignatures: FfiConverterSequenceTypeMultisigSubsignature.read(from: &buf) + ) + } + + public static func write(_ value: MultisigSignature, into buf: inout [UInt8]) { + FfiConverterUInt8.write(value.version, into: &buf) + FfiConverterUInt8.write(value.threshold, into: &buf) + FfiConverterSequenceTypeMultisigSubsignature.write(value.subsignatures, into: &buf) + } +} + + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +public func FfiConverterTypeMultisigSignature_lift(_ buf: RustBuffer) throws -> MultisigSignature { + return try FfiConverterTypeMultisigSignature.lift(buf) +} + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +public func FfiConverterTypeMultisigSignature_lower(_ value: MultisigSignature) -> RustBuffer { + return FfiConverterTypeMultisigSignature.lower(value) +} + + +/** + * Representation of a single subsignature in a multisignature transaction. + * + * Each subsignature contains the participant's address and an optional signature. + */ +public struct MultisigSubsignature { + /** + * Address of the participant. + */ + public var address: String + /** + * Optional signature bytes for the participant. + */ + public var signature: Data? + + // Default memberwise initializers are never public by default, so we + // declare one manually. + public init( + /** + * Address of the participant. + */address: String, + /** + * Optional signature bytes for the participant. + */signature: Data? = nil) { + self.address = address + self.signature = signature + } +} + +#if compiler(>=6) +extension MultisigSubsignature: Sendable {} +#endif + + +extension MultisigSubsignature: Equatable, Hashable { + public static func ==(lhs: MultisigSubsignature, rhs: MultisigSubsignature) -> Bool { + if lhs.address != rhs.address { + return false + } + if lhs.signature != rhs.signature { + return false + } + return true + } + + public func hash(into hasher: inout Hasher) { + hasher.combine(address) + hasher.combine(signature) + } +} + + + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +public struct FfiConverterTypeMultisigSubsignature: FfiConverterRustBuffer { + public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> MultisigSubsignature { + return + try MultisigSubsignature( + address: FfiConverterString.read(from: &buf), + signature: FfiConverterOptionData.read(from: &buf) + ) + } + + public static func write(_ value: MultisigSubsignature, into buf: inout [UInt8]) { + FfiConverterString.write(value.address, into: &buf) + FfiConverterOptionData.write(value.signature, into: &buf) + } +} + + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +public func FfiConverterTypeMultisigSubsignature_lift(_ buf: RustBuffer) throws -> MultisigSubsignature { + return try FfiConverterTypeMultisigSubsignature.lift(buf) +} + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +public func FfiConverterTypeMultisigSubsignature_lower(_ value: MultisigSubsignature) -> RustBuffer { + return FfiConverterTypeMultisigSubsignature.lower(value) +} + + +public struct PaymentTransactionFields { + public var receiver: String + public var amount: UInt64 + public var closeRemainderTo: String? + + // Default memberwise initializers are never public by default, so we + // declare one manually. + public init(receiver: String, amount: UInt64, closeRemainderTo: String? = nil) { + self.receiver = receiver + self.amount = amount + self.closeRemainderTo = closeRemainderTo + } +} + +#if compiler(>=6) +extension PaymentTransactionFields: Sendable {} +#endif + + +extension PaymentTransactionFields: Equatable, Hashable { + public static func ==(lhs: PaymentTransactionFields, rhs: PaymentTransactionFields) -> Bool { + if lhs.receiver != rhs.receiver { + return false + } + if lhs.amount != rhs.amount { + return false + } + if lhs.closeRemainderTo != rhs.closeRemainderTo { + return false + } + return true + } + + public func hash(into hasher: inout Hasher) { + hasher.combine(receiver) + hasher.combine(amount) + hasher.combine(closeRemainderTo) + } +} + + + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +public struct FfiConverterTypePaymentTransactionFields: FfiConverterRustBuffer { + public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> PaymentTransactionFields { + return + try PaymentTransactionFields( + receiver: FfiConverterString.read(from: &buf), + amount: FfiConverterUInt64.read(from: &buf), + closeRemainderTo: FfiConverterOptionString.read(from: &buf) + ) + } + + public static func write(_ value: PaymentTransactionFields, into buf: inout [UInt8]) { + FfiConverterString.write(value.receiver, into: &buf) + FfiConverterUInt64.write(value.amount, into: &buf) + FfiConverterOptionString.write(value.closeRemainderTo, into: &buf) + } +} + + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +public func FfiConverterTypePaymentTransactionFields_lift(_ buf: RustBuffer) throws -> PaymentTransactionFields { + return try FfiConverterTypePaymentTransactionFields.lift(buf) +} + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +public func FfiConverterTypePaymentTransactionFields_lower(_ value: PaymentTransactionFields) -> RustBuffer { + return FfiConverterTypePaymentTransactionFields.lower(value) +} + + +public struct SignedTransaction { + /** + * The transaction that has been signed. + */ + public var transaction: Transaction + /** + * Optional Ed25519 signature authorizing the transaction. + */ + public var signature: Data? + /** + * Optional auth address applicable if the transaction sender is a rekeyed account. + */ + public var authAddress: String? + /** + * Optional multisig signature if the transaction is a multisig transaction. + */ + public var multisignature: MultisigSignature? + + // Default memberwise initializers are never public by default, so we + // declare one manually. + public init( + /** + * The transaction that has been signed. + */transaction: Transaction, + /** + * Optional Ed25519 signature authorizing the transaction. + */signature: Data? = nil, + /** + * Optional auth address applicable if the transaction sender is a rekeyed account. + */authAddress: String? = nil, + /** + * Optional multisig signature if the transaction is a multisig transaction. + */multisignature: MultisigSignature? = nil) { + self.transaction = transaction + self.signature = signature + self.authAddress = authAddress + self.multisignature = multisignature + } +} + +#if compiler(>=6) +extension SignedTransaction: Sendable {} +#endif + + +extension SignedTransaction: Equatable, Hashable { + public static func ==(lhs: SignedTransaction, rhs: SignedTransaction) -> Bool { + if lhs.transaction != rhs.transaction { + return false + } + if lhs.signature != rhs.signature { + return false + } + if lhs.authAddress != rhs.authAddress { + return false + } + if lhs.multisignature != rhs.multisignature { + return false + } + return true + } + + public func hash(into hasher: inout Hasher) { + hasher.combine(transaction) + hasher.combine(signature) + hasher.combine(authAddress) + hasher.combine(multisignature) + } +} + + + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +public struct FfiConverterTypeSignedTransaction: FfiConverterRustBuffer { + public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> SignedTransaction { + return + try SignedTransaction( + transaction: FfiConverterTypeTransaction.read(from: &buf), + signature: FfiConverterOptionData.read(from: &buf), + authAddress: FfiConverterOptionString.read(from: &buf), + multisignature: FfiConverterOptionTypeMultisigSignature.read(from: &buf) + ) + } + + public static func write(_ value: SignedTransaction, into buf: inout [UInt8]) { + FfiConverterTypeTransaction.write(value.transaction, into: &buf) + FfiConverterOptionData.write(value.signature, into: &buf) + FfiConverterOptionString.write(value.authAddress, into: &buf) + FfiConverterOptionTypeMultisigSignature.write(value.multisignature, into: &buf) + } +} + + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +public func FfiConverterTypeSignedTransaction_lift(_ buf: RustBuffer) throws -> SignedTransaction { + return try FfiConverterTypeSignedTransaction.lift(buf) +} + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +public func FfiConverterTypeSignedTransaction_lower(_ value: SignedTransaction) -> RustBuffer { + return FfiConverterTypeSignedTransaction.lower(value) +} + + +/** + * Schema for app state storage. + * + * Defines the maximum number of values that may be stored in app + * key/value storage for both global and local state. + */ +public struct StateSchema { + /** + * Maximum number of integer values that may be stored. + */ + public var numUints: UInt32 + /** + * Maximum number of byte slice values that may be stored. + */ + public var numByteSlices: UInt32 + + // Default memberwise initializers are never public by default, so we + // declare one manually. + public init( + /** + * Maximum number of integer values that may be stored. + */numUints: UInt32, + /** + * Maximum number of byte slice values that may be stored. + */numByteSlices: UInt32) { + self.numUints = numUints + self.numByteSlices = numByteSlices + } +} + +#if compiler(>=6) +extension StateSchema: Sendable {} +#endif + + +extension StateSchema: Equatable, Hashable { + public static func ==(lhs: StateSchema, rhs: StateSchema) -> Bool { + if lhs.numUints != rhs.numUints { + return false + } + if lhs.numByteSlices != rhs.numByteSlices { + return false + } + return true + } + + public func hash(into hasher: inout Hasher) { + hasher.combine(numUints) + hasher.combine(numByteSlices) + } +} + + + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +public struct FfiConverterTypeStateSchema: FfiConverterRustBuffer { + public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> StateSchema { + return + try StateSchema( + numUints: FfiConverterUInt32.read(from: &buf), + numByteSlices: FfiConverterUInt32.read(from: &buf) + ) + } + + public static func write(_ value: StateSchema, into buf: inout [UInt8]) { + FfiConverterUInt32.write(value.numUints, into: &buf) + FfiConverterUInt32.write(value.numByteSlices, into: &buf) + } +} + + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +public func FfiConverterTypeStateSchema_lift(_ buf: RustBuffer) throws -> StateSchema { + return try FfiConverterTypeStateSchema.lift(buf) +} + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +public func FfiConverterTypeStateSchema_lower(_ value: StateSchema) -> RustBuffer { + return FfiConverterTypeStateSchema.lower(value) +} + + +public struct Transaction { + /** + * The type of transaction + */ + public var transactionType: TransactionType + /** + * The sender of the transaction + */ + public var sender: String + /** + * Optional transaction fee in microALGO. + * + * If not set, the fee will be interpreted as 0 by the network. + */ + public var fee: UInt64? + public var firstValid: UInt64 + public var lastValid: UInt64 + public var genesisHash: Data? + public var genesisId: String? + public var note: Data? + public var rekeyTo: String? + public var lease: Data? + public var group: Data? + public var payment: PaymentTransactionFields? + public var assetTransfer: AssetTransferTransactionFields? + public var assetConfig: AssetConfigTransactionFields? + public var appCall: AppCallTransactionFields? + public var keyRegistration: KeyRegistrationTransactionFields? + public var assetFreeze: AssetFreezeTransactionFields? // Default memberwise initializers are never public by default, so we // declare one manually. @@ -731,7 +2268,12 @@ public struct Transaction { */transactionType: TransactionType, /** * The sender of the transaction - */sender: Address, fee: UInt64, firstValid: UInt64, lastValid: UInt64, genesisHash: ByteBuf?, genesisId: String?, note: ByteBuf? = nil, rekeyTo: Address? = nil, lease: ByteBuf? = nil, group: ByteBuf? = nil, payment: PaymentTransactionFields? = nil, assetTransfer: AssetTransferTransactionFields? = nil) { + */sender: String, + /** + * Optional transaction fee in microALGO. + * + * If not set, the fee will be interpreted as 0 by the network. + */fee: UInt64? = nil, firstValid: UInt64, lastValid: UInt64, genesisHash: Data?, genesisId: String?, note: Data? = nil, rekeyTo: String? = nil, lease: Data? = nil, group: Data? = nil, payment: PaymentTransactionFields? = nil, assetTransfer: AssetTransferTransactionFields? = nil, assetConfig: AssetConfigTransactionFields? = nil, appCall: AppCallTransactionFields? = nil, keyRegistration: KeyRegistrationTransactionFields? = nil, assetFreeze: AssetFreezeTransactionFields? = nil) { self.transactionType = transactionType self.sender = sender self.fee = fee @@ -745,9 +2287,16 @@ public struct Transaction { self.group = group self.payment = payment self.assetTransfer = assetTransfer + self.assetConfig = assetConfig + self.appCall = appCall + self.keyRegistration = keyRegistration + self.assetFreeze = assetFreeze } } +#if compiler(>=6) +extension Transaction: Sendable {} +#endif extension Transaction: Equatable, Hashable { @@ -791,6 +2340,18 @@ extension Transaction: Equatable, Hashable { if lhs.assetTransfer != rhs.assetTransfer { return false } + if lhs.assetConfig != rhs.assetConfig { + return false + } + if lhs.appCall != rhs.appCall { + return false + } + if lhs.keyRegistration != rhs.keyRegistration { + return false + } + if lhs.assetFreeze != rhs.assetFreeze { + return false + } return true } @@ -808,10 +2369,15 @@ extension Transaction: Equatable, Hashable { hasher.combine(group) hasher.combine(payment) hasher.combine(assetTransfer) + hasher.combine(assetConfig) + hasher.combine(appCall) + hasher.combine(keyRegistration) + hasher.combine(assetFreeze) } } + #if swift(>=5.8) @_documentation(visibility: private) #endif @@ -820,35 +2386,43 @@ public struct FfiConverterTypeTransaction: FfiConverterRustBuffer { return try Transaction( transactionType: FfiConverterTypeTransactionType.read(from: &buf), - sender: FfiConverterTypeAddress.read(from: &buf), - fee: FfiConverterUInt64.read(from: &buf), + sender: FfiConverterString.read(from: &buf), + fee: FfiConverterOptionUInt64.read(from: &buf), firstValid: FfiConverterUInt64.read(from: &buf), lastValid: FfiConverterUInt64.read(from: &buf), - genesisHash: FfiConverterOptionTypeByteBuf.read(from: &buf), + genesisHash: FfiConverterOptionData.read(from: &buf), genesisId: FfiConverterOptionString.read(from: &buf), - note: FfiConverterOptionTypeByteBuf.read(from: &buf), - rekeyTo: FfiConverterOptionTypeAddress.read(from: &buf), - lease: FfiConverterOptionTypeByteBuf.read(from: &buf), - group: FfiConverterOptionTypeByteBuf.read(from: &buf), + note: FfiConverterOptionData.read(from: &buf), + rekeyTo: FfiConverterOptionString.read(from: &buf), + lease: FfiConverterOptionData.read(from: &buf), + group: FfiConverterOptionData.read(from: &buf), payment: FfiConverterOptionTypePaymentTransactionFields.read(from: &buf), - assetTransfer: FfiConverterOptionTypeAssetTransferTransactionFields.read(from: &buf) + assetTransfer: FfiConverterOptionTypeAssetTransferTransactionFields.read(from: &buf), + assetConfig: FfiConverterOptionTypeAssetConfigTransactionFields.read(from: &buf), + appCall: FfiConverterOptionTypeAppCallTransactionFields.read(from: &buf), + keyRegistration: FfiConverterOptionTypeKeyRegistrationTransactionFields.read(from: &buf), + assetFreeze: FfiConverterOptionTypeAssetFreezeTransactionFields.read(from: &buf) ) } public static func write(_ value: Transaction, into buf: inout [UInt8]) { FfiConverterTypeTransactionType.write(value.transactionType, into: &buf) - FfiConverterTypeAddress.write(value.sender, into: &buf) - FfiConverterUInt64.write(value.fee, into: &buf) + FfiConverterString.write(value.sender, into: &buf) + FfiConverterOptionUInt64.write(value.fee, into: &buf) FfiConverterUInt64.write(value.firstValid, into: &buf) FfiConverterUInt64.write(value.lastValid, into: &buf) - FfiConverterOptionTypeByteBuf.write(value.genesisHash, into: &buf) + FfiConverterOptionData.write(value.genesisHash, into: &buf) FfiConverterOptionString.write(value.genesisId, into: &buf) - FfiConverterOptionTypeByteBuf.write(value.note, into: &buf) - FfiConverterOptionTypeAddress.write(value.rekeyTo, into: &buf) - FfiConverterOptionTypeByteBuf.write(value.lease, into: &buf) - FfiConverterOptionTypeByteBuf.write(value.group, into: &buf) + FfiConverterOptionData.write(value.note, into: &buf) + FfiConverterOptionString.write(value.rekeyTo, into: &buf) + FfiConverterOptionData.write(value.lease, into: &buf) + FfiConverterOptionData.write(value.group, into: &buf) FfiConverterOptionTypePaymentTransactionFields.write(value.payment, into: &buf) FfiConverterOptionTypeAssetTransferTransactionFields.write(value.assetTransfer, into: &buf) + FfiConverterOptionTypeAssetConfigTransactionFields.write(value.assetConfig, into: &buf) + FfiConverterOptionTypeAppCallTransactionFields.write(value.appCall, into: &buf) + FfiConverterOptionTypeKeyRegistrationTransactionFields.write(value.keyRegistration, into: &buf) + FfiConverterOptionTypeAssetFreezeTransactionFields.write(value.assetFreeze, into: &buf) } } @@ -868,13 +2442,17 @@ public func FfiConverterTypeTransaction_lower(_ value: Transaction) -> RustBuffe } -public enum AlgoKitTransactError { +public enum AlgoKitTransactError: Swift.Error { - case EncodingError(String + case EncodingError(errorMsg: String + ) + case DecodingError(errorMsg: String ) - case DecodingError(String + case InputError(errorMsg: String + ) + case MsgPackError(errorMsg: String ) } @@ -893,10 +2471,16 @@ public struct FfiConverterTypeAlgoKitTransactError: FfiConverterRustBuffer { case 1: return .EncodingError( - try FfiConverterString.read(from: &buf) + errorMsg: try FfiConverterString.read(from: &buf) ) case 2: return .DecodingError( - try FfiConverterString.read(from: &buf) + errorMsg: try FfiConverterString.read(from: &buf) + ) + case 3: return .InputError( + errorMsg: try FfiConverterString.read(from: &buf) + ) + case 4: return .MsgPackError( + errorMsg: try FfiConverterString.read(from: &buf) ) default: throw UniffiInternalError.unexpectedEnumCase @@ -910,126 +2494,300 @@ public struct FfiConverterTypeAlgoKitTransactError: FfiConverterRustBuffer { - case let .EncodingError(v1): + case let .EncodingError(errorMsg): writeInt(&buf, Int32(1)) - FfiConverterString.write(v1, into: &buf) + FfiConverterString.write(errorMsg, into: &buf) - case let .DecodingError(v1): + case let .DecodingError(errorMsg): writeInt(&buf, Int32(2)) - FfiConverterString.write(v1, into: &buf) + FfiConverterString.write(errorMsg, into: &buf) + + + case let .InputError(errorMsg): + writeInt(&buf, Int32(3)) + FfiConverterString.write(errorMsg, into: &buf) + + + case let .MsgPackError(errorMsg): + writeInt(&buf, Int32(4)) + FfiConverterString.write(errorMsg, into: &buf) } } } -extension AlgoKitTransactError: Equatable, Hashable {} +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +public func FfiConverterTypeAlgoKitTransactError_lift(_ buf: RustBuffer) throws -> AlgoKitTransactError { + return try FfiConverterTypeAlgoKitTransactError.lift(buf) +} + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +public func FfiConverterTypeAlgoKitTransactError_lower(_ value: AlgoKitTransactError) -> RustBuffer { + return FfiConverterTypeAlgoKitTransactError.lower(value) +} + + +extension AlgoKitTransactError: Equatable, Hashable {} + + + + +extension AlgoKitTransactError: Foundation.LocalizedError { + public var errorDescription: String? { + String(reflecting: self) + } +} + + + + +// Note that we don't yet support `indirect` for enums. +// See https://github.com/mozilla/uniffi-rs/issues/396 for further discussion. +/** + * Enum containing all constants used in this crate. + */ + +public enum AlgorandConstant { + + /** + * Length of hash digests (32) + */ + case hashLength + /** + * Length of the checksum used in Algorand addresses (4) + */ + case checksumLength + /** + * Length of a base32-encoded Algorand address (58) + */ + case addressLength + /** + * Length of an Algorand public key in bytes (32) + */ + case publicKeyLength + /** + * Length of an Algorand secret key in bytes (32) + */ + case secretKeyLength + /** + * Length of an Algorand signature in bytes (64) + */ + case signatureLength + /** + * Increment in the encoded byte size when a signature is attached to a transaction (75) + */ + case signatureEncodingIncrLength + /** + * The maximum number of transactions in a group (16) + */ + case maxTxGroupSize +} + + +#if compiler(>=6) +extension AlgorandConstant: Sendable {} +#endif + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +public struct FfiConverterTypeAlgorandConstant: FfiConverterRustBuffer { + typealias SwiftType = AlgorandConstant + + public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> AlgorandConstant { + let variant: Int32 = try readInt(&buf) + switch variant { + + case 1: return .hashLength + + case 2: return .checksumLength + + case 3: return .addressLength + + case 4: return .publicKeyLength + + case 5: return .secretKeyLength + + case 6: return .signatureLength + + case 7: return .signatureEncodingIncrLength + + case 8: return .maxTxGroupSize + + default: throw UniffiInternalError.unexpectedEnumCase + } + } + + public static func write(_ value: AlgorandConstant, into buf: inout [UInt8]) { + switch value { + + + case .hashLength: + writeInt(&buf, Int32(1)) + + + case .checksumLength: + writeInt(&buf, Int32(2)) + + + case .addressLength: + writeInt(&buf, Int32(3)) + + + case .publicKeyLength: + writeInt(&buf, Int32(4)) + + + case .secretKeyLength: + writeInt(&buf, Int32(5)) + + + case .signatureLength: + writeInt(&buf, Int32(6)) + + + case .signatureEncodingIncrLength: + writeInt(&buf, Int32(7)) + + + case .maxTxGroupSize: + writeInt(&buf, Int32(8)) + + } + } +} + + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +public func FfiConverterTypeAlgorandConstant_lift(_ buf: RustBuffer) throws -> AlgorandConstant { + return try FfiConverterTypeAlgorandConstant.lift(buf) +} + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +public func FfiConverterTypeAlgorandConstant_lower(_ value: AlgorandConstant) -> RustBuffer { + return FfiConverterTypeAlgorandConstant.lower(value) +} + + +extension AlgorandConstant: Equatable, Hashable {} + + + + -extension AlgoKitTransactError: Foundation.LocalizedError { - public var errorDescription: String? { - String(reflecting: self) - } -} // Note that we don't yet support `indirect` for enums. // See https://github.com/mozilla/uniffi-rs/issues/396 for further discussion. /** - * Enum containing all constants used in this crate. + * On-completion actions for app transactions. + * + * These values define what additional actions occur with the transaction. */ -public enum AlgorandConstant { +public enum OnApplicationComplete { /** - * Length of hash digests (32) - */ - case hashLength - /** - * Length of the checksum used in Algorand addresses (4) + * NoOp indicates that an app transaction will simply call its + * approval program without any additional action. */ - case checksumLength + case noOp /** - * Length of a base32-encoded Algorand address (58) + * OptIn indicates that an app transaction will allocate some + * local state for the app in the sender's account. */ - case addressLength + case optIn /** - * Length of an Algorand public key in bytes (32) + * CloseOut indicates that an app transaction will deallocate + * some local state for the app from the user's account. */ - case publicKeyLength + case closeOut /** - * Length of an Algorand secret key in bytes (32) + * ClearState is similar to CloseOut, but may never fail. This + * allows users to reclaim their minimum balance from an app + * they no longer wish to opt in to. */ - case secretKeyLength + case clearState /** - * Length of an Algorand signature in bytes (64) + * UpdateApplication indicates that an app transaction will + * update the approval program and clear state program for the app. */ - case signatureLength + case updateApplication /** - * Increment in the encoded byte size when a signature is attached to a transaction (75) + * DeleteApplication indicates that an app transaction will + * delete the app parameters for the app from the creator's + * balance record. */ - case signatureEncodingIncrLength + case deleteApplication } +#if compiler(>=6) +extension OnApplicationComplete: Sendable {} +#endif + #if swift(>=5.8) @_documentation(visibility: private) #endif -public struct FfiConverterTypeAlgorandConstant: FfiConverterRustBuffer { - typealias SwiftType = AlgorandConstant +public struct FfiConverterTypeOnApplicationComplete: FfiConverterRustBuffer { + typealias SwiftType = OnApplicationComplete - public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> AlgorandConstant { + public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> OnApplicationComplete { let variant: Int32 = try readInt(&buf) switch variant { - case 1: return .hashLength - - case 2: return .checksumLength + case 1: return .noOp - case 3: return .addressLength + case 2: return .optIn - case 4: return .publicKeyLength + case 3: return .closeOut - case 5: return .secretKeyLength + case 4: return .clearState - case 6: return .signatureLength + case 5: return .updateApplication - case 7: return .signatureEncodingIncrLength + case 6: return .deleteApplication default: throw UniffiInternalError.unexpectedEnumCase } } - public static func write(_ value: AlgorandConstant, into buf: inout [UInt8]) { + public static func write(_ value: OnApplicationComplete, into buf: inout [UInt8]) { switch value { - case .hashLength: + case .noOp: writeInt(&buf, Int32(1)) - case .checksumLength: + case .optIn: writeInt(&buf, Int32(2)) - case .addressLength: + case .closeOut: writeInt(&buf, Int32(3)) - case .publicKeyLength: + case .clearState: writeInt(&buf, Int32(4)) - case .secretKeyLength: + case .updateApplication: writeInt(&buf, Int32(5)) - case .signatureLength: + case .deleteApplication: writeInt(&buf, Int32(6)) - - case .signatureEncodingIncrLength: - writeInt(&buf, Int32(7)) - } } } @@ -1038,20 +2796,22 @@ public struct FfiConverterTypeAlgorandConstant: FfiConverterRustBuffer { #if swift(>=5.8) @_documentation(visibility: private) #endif -public func FfiConverterTypeAlgorandConstant_lift(_ buf: RustBuffer) throws -> AlgorandConstant { - return try FfiConverterTypeAlgorandConstant.lift(buf) +public func FfiConverterTypeOnApplicationComplete_lift(_ buf: RustBuffer) throws -> OnApplicationComplete { + return try FfiConverterTypeOnApplicationComplete.lift(buf) } #if swift(>=5.8) @_documentation(visibility: private) #endif -public func FfiConverterTypeAlgorandConstant_lower(_ value: AlgorandConstant) -> RustBuffer { - return FfiConverterTypeAlgorandConstant.lower(value) +public func FfiConverterTypeOnApplicationComplete_lower(_ value: OnApplicationComplete) -> RustBuffer { + return FfiConverterTypeOnApplicationComplete.lower(value) } +extension OnApplicationComplete: Equatable, Hashable {} + + -extension AlgorandConstant: Equatable, Hashable {} @@ -1065,10 +2825,14 @@ public enum TransactionType { case assetFreeze case assetConfig case keyRegistration - case applicationCall + case appCall } +#if compiler(>=6) +extension TransactionType: Sendable {} +#endif + #if swift(>=5.8) @_documentation(visibility: private) #endif @@ -1089,7 +2853,7 @@ public struct FfiConverterTypeTransactionType: FfiConverterRustBuffer { case 5: return .keyRegistration - case 6: return .applicationCall + case 6: return .appCall default: throw UniffiInternalError.unexpectedEnumCase } @@ -1119,39 +2883,329 @@ public struct FfiConverterTypeTransactionType: FfiConverterRustBuffer { writeInt(&buf, Int32(5)) - case .applicationCall: + case .appCall: writeInt(&buf, Int32(6)) } } -} +} + + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +public func FfiConverterTypeTransactionType_lift(_ buf: RustBuffer) throws -> TransactionType { + return try FfiConverterTypeTransactionType.lift(buf) +} + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +public func FfiConverterTypeTransactionType_lower(_ value: TransactionType) -> RustBuffer { + return FfiConverterTypeTransactionType.lower(value) +} + + +extension TransactionType: Equatable, Hashable {} + + + + + + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +fileprivate struct FfiConverterOptionUInt32: FfiConverterRustBuffer { + typealias SwiftType = UInt32? + + public static func write(_ value: SwiftType, into buf: inout [UInt8]) { + guard let value = value else { + writeInt(&buf, Int8(0)) + return + } + writeInt(&buf, Int8(1)) + FfiConverterUInt32.write(value, into: &buf) + } + + public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> SwiftType { + switch try readInt(&buf) as Int8 { + case 0: return nil + case 1: return try FfiConverterUInt32.read(from: &buf) + default: throw UniffiInternalError.unexpectedOptionalTag + } + } +} + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +fileprivate struct FfiConverterOptionUInt64: FfiConverterRustBuffer { + typealias SwiftType = UInt64? + + public static func write(_ value: SwiftType, into buf: inout [UInt8]) { + guard let value = value else { + writeInt(&buf, Int8(0)) + return + } + writeInt(&buf, Int8(1)) + FfiConverterUInt64.write(value, into: &buf) + } + + public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> SwiftType { + switch try readInt(&buf) as Int8 { + case 0: return nil + case 1: return try FfiConverterUInt64.read(from: &buf) + default: throw UniffiInternalError.unexpectedOptionalTag + } + } +} + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +fileprivate struct FfiConverterOptionBool: FfiConverterRustBuffer { + typealias SwiftType = Bool? + + public static func write(_ value: SwiftType, into buf: inout [UInt8]) { + guard let value = value else { + writeInt(&buf, Int8(0)) + return + } + writeInt(&buf, Int8(1)) + FfiConverterBool.write(value, into: &buf) + } + + public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> SwiftType { + switch try readInt(&buf) as Int8 { + case 0: return nil + case 1: return try FfiConverterBool.read(from: &buf) + default: throw UniffiInternalError.unexpectedOptionalTag + } + } +} + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +fileprivate struct FfiConverterOptionString: FfiConverterRustBuffer { + typealias SwiftType = String? + + public static func write(_ value: SwiftType, into buf: inout [UInt8]) { + guard let value = value else { + writeInt(&buf, Int8(0)) + return + } + writeInt(&buf, Int8(1)) + FfiConverterString.write(value, into: &buf) + } + + public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> SwiftType { + switch try readInt(&buf) as Int8 { + case 0: return nil + case 1: return try FfiConverterString.read(from: &buf) + default: throw UniffiInternalError.unexpectedOptionalTag + } + } +} + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +fileprivate struct FfiConverterOptionData: FfiConverterRustBuffer { + typealias SwiftType = Data? + + public static func write(_ value: SwiftType, into buf: inout [UInt8]) { + guard let value = value else { + writeInt(&buf, Int8(0)) + return + } + writeInt(&buf, Int8(1)) + FfiConverterData.write(value, into: &buf) + } + + public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> SwiftType { + switch try readInt(&buf) as Int8 { + case 0: return nil + case 1: return try FfiConverterData.read(from: &buf) + default: throw UniffiInternalError.unexpectedOptionalTag + } + } +} + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +fileprivate struct FfiConverterOptionTypeAppCallTransactionFields: FfiConverterRustBuffer { + typealias SwiftType = AppCallTransactionFields? + + public static func write(_ value: SwiftType, into buf: inout [UInt8]) { + guard let value = value else { + writeInt(&buf, Int8(0)) + return + } + writeInt(&buf, Int8(1)) + FfiConverterTypeAppCallTransactionFields.write(value, into: &buf) + } + + public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> SwiftType { + switch try readInt(&buf) as Int8 { + case 0: return nil + case 1: return try FfiConverterTypeAppCallTransactionFields.read(from: &buf) + default: throw UniffiInternalError.unexpectedOptionalTag + } + } +} + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +fileprivate struct FfiConverterOptionTypeAssetConfigTransactionFields: FfiConverterRustBuffer { + typealias SwiftType = AssetConfigTransactionFields? + + public static func write(_ value: SwiftType, into buf: inout [UInt8]) { + guard let value = value else { + writeInt(&buf, Int8(0)) + return + } + writeInt(&buf, Int8(1)) + FfiConverterTypeAssetConfigTransactionFields.write(value, into: &buf) + } + + public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> SwiftType { + switch try readInt(&buf) as Int8 { + case 0: return nil + case 1: return try FfiConverterTypeAssetConfigTransactionFields.read(from: &buf) + default: throw UniffiInternalError.unexpectedOptionalTag + } + } +} + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +fileprivate struct FfiConverterOptionTypeAssetFreezeTransactionFields: FfiConverterRustBuffer { + typealias SwiftType = AssetFreezeTransactionFields? + + public static func write(_ value: SwiftType, into buf: inout [UInt8]) { + guard let value = value else { + writeInt(&buf, Int8(0)) + return + } + writeInt(&buf, Int8(1)) + FfiConverterTypeAssetFreezeTransactionFields.write(value, into: &buf) + } + + public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> SwiftType { + switch try readInt(&buf) as Int8 { + case 0: return nil + case 1: return try FfiConverterTypeAssetFreezeTransactionFields.read(from: &buf) + default: throw UniffiInternalError.unexpectedOptionalTag + } + } +} + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +fileprivate struct FfiConverterOptionTypeAssetTransferTransactionFields: FfiConverterRustBuffer { + typealias SwiftType = AssetTransferTransactionFields? + + public static func write(_ value: SwiftType, into buf: inout [UInt8]) { + guard let value = value else { + writeInt(&buf, Int8(0)) + return + } + writeInt(&buf, Int8(1)) + FfiConverterTypeAssetTransferTransactionFields.write(value, into: &buf) + } + public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> SwiftType { + switch try readInt(&buf) as Int8 { + case 0: return nil + case 1: return try FfiConverterTypeAssetTransferTransactionFields.read(from: &buf) + default: throw UniffiInternalError.unexpectedOptionalTag + } + } +} #if swift(>=5.8) @_documentation(visibility: private) #endif -public func FfiConverterTypeTransactionType_lift(_ buf: RustBuffer) throws -> TransactionType { - return try FfiConverterTypeTransactionType.lift(buf) +fileprivate struct FfiConverterOptionTypeKeyRegistrationTransactionFields: FfiConverterRustBuffer { + typealias SwiftType = KeyRegistrationTransactionFields? + + public static func write(_ value: SwiftType, into buf: inout [UInt8]) { + guard let value = value else { + writeInt(&buf, Int8(0)) + return + } + writeInt(&buf, Int8(1)) + FfiConverterTypeKeyRegistrationTransactionFields.write(value, into: &buf) + } + + public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> SwiftType { + switch try readInt(&buf) as Int8 { + case 0: return nil + case 1: return try FfiConverterTypeKeyRegistrationTransactionFields.read(from: &buf) + default: throw UniffiInternalError.unexpectedOptionalTag + } + } } #if swift(>=5.8) @_documentation(visibility: private) #endif -public func FfiConverterTypeTransactionType_lower(_ value: TransactionType) -> RustBuffer { - return FfiConverterTypeTransactionType.lower(value) -} +fileprivate struct FfiConverterOptionTypeMultisigSignature: FfiConverterRustBuffer { + typealias SwiftType = MultisigSignature? + public static func write(_ value: SwiftType, into buf: inout [UInt8]) { + guard let value = value else { + writeInt(&buf, Int8(0)) + return + } + writeInt(&buf, Int8(1)) + FfiConverterTypeMultisigSignature.write(value, into: &buf) + } + public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> SwiftType { + switch try readInt(&buf) as Int8 { + case 0: return nil + case 1: return try FfiConverterTypeMultisigSignature.read(from: &buf) + default: throw UniffiInternalError.unexpectedOptionalTag + } + } +} -extension TransactionType: Equatable, Hashable {} +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +fileprivate struct FfiConverterOptionTypePaymentTransactionFields: FfiConverterRustBuffer { + typealias SwiftType = PaymentTransactionFields? + public static func write(_ value: SwiftType, into buf: inout [UInt8]) { + guard let value = value else { + writeInt(&buf, Int8(0)) + return + } + writeInt(&buf, Int8(1)) + FfiConverterTypePaymentTransactionFields.write(value, into: &buf) + } + public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> SwiftType { + switch try readInt(&buf) as Int8 { + case 0: return nil + case 1: return try FfiConverterTypePaymentTransactionFields.read(from: &buf) + default: throw UniffiInternalError.unexpectedOptionalTag + } + } +} #if swift(>=5.8) @_documentation(visibility: private) #endif -fileprivate struct FfiConverterOptionString: FfiConverterRustBuffer { - typealias SwiftType = String? +fileprivate struct FfiConverterOptionTypeStateSchema: FfiConverterRustBuffer { + typealias SwiftType = StateSchema? public static func write(_ value: SwiftType, into buf: inout [UInt8]) { guard let value = value else { @@ -1159,13 +3213,13 @@ fileprivate struct FfiConverterOptionString: FfiConverterRustBuffer { return } writeInt(&buf, Int8(1)) - FfiConverterString.write(value, into: &buf) + FfiConverterTypeStateSchema.write(value, into: &buf) } public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> SwiftType { switch try readInt(&buf) as Int8 { case 0: return nil - case 1: return try FfiConverterString.read(from: &buf) + case 1: return try FfiConverterTypeStateSchema.read(from: &buf) default: throw UniffiInternalError.unexpectedOptionalTag } } @@ -1174,8 +3228,8 @@ fileprivate struct FfiConverterOptionString: FfiConverterRustBuffer { #if swift(>=5.8) @_documentation(visibility: private) #endif -fileprivate struct FfiConverterOptionTypeAddress: FfiConverterRustBuffer { - typealias SwiftType = Address? +fileprivate struct FfiConverterOptionSequenceUInt64: FfiConverterRustBuffer { + typealias SwiftType = [UInt64]? public static func write(_ value: SwiftType, into buf: inout [UInt8]) { guard let value = value else { @@ -1183,13 +3237,13 @@ fileprivate struct FfiConverterOptionTypeAddress: FfiConverterRustBuffer { return } writeInt(&buf, Int8(1)) - FfiConverterTypeAddress.write(value, into: &buf) + FfiConverterSequenceUInt64.write(value, into: &buf) } public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> SwiftType { switch try readInt(&buf) as Int8 { case 0: return nil - case 1: return try FfiConverterTypeAddress.read(from: &buf) + case 1: return try FfiConverterSequenceUInt64.read(from: &buf) default: throw UniffiInternalError.unexpectedOptionalTag } } @@ -1198,8 +3252,8 @@ fileprivate struct FfiConverterOptionTypeAddress: FfiConverterRustBuffer { #if swift(>=5.8) @_documentation(visibility: private) #endif -fileprivate struct FfiConverterOptionTypeAssetTransferTransactionFields: FfiConverterRustBuffer { - typealias SwiftType = AssetTransferTransactionFields? +fileprivate struct FfiConverterOptionSequenceString: FfiConverterRustBuffer { + typealias SwiftType = [String]? public static func write(_ value: SwiftType, into buf: inout [UInt8]) { guard let value = value else { @@ -1207,13 +3261,13 @@ fileprivate struct FfiConverterOptionTypeAssetTransferTransactionFields: FfiConv return } writeInt(&buf, Int8(1)) - FfiConverterTypeAssetTransferTransactionFields.write(value, into: &buf) + FfiConverterSequenceString.write(value, into: &buf) } public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> SwiftType { switch try readInt(&buf) as Int8 { case 0: return nil - case 1: return try FfiConverterTypeAssetTransferTransactionFields.read(from: &buf) + case 1: return try FfiConverterSequenceString.read(from: &buf) default: throw UniffiInternalError.unexpectedOptionalTag } } @@ -1222,8 +3276,8 @@ fileprivate struct FfiConverterOptionTypeAssetTransferTransactionFields: FfiConv #if swift(>=5.8) @_documentation(visibility: private) #endif -fileprivate struct FfiConverterOptionTypePaymentTransactionFields: FfiConverterRustBuffer { - typealias SwiftType = PaymentTransactionFields? +fileprivate struct FfiConverterOptionSequenceData: FfiConverterRustBuffer { + typealias SwiftType = [Data]? public static func write(_ value: SwiftType, into buf: inout [UInt8]) { guard let value = value else { @@ -1231,13 +3285,13 @@ fileprivate struct FfiConverterOptionTypePaymentTransactionFields: FfiConverterR return } writeInt(&buf, Int8(1)) - FfiConverterTypePaymentTransactionFields.write(value, into: &buf) + FfiConverterSequenceData.write(value, into: &buf) } public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> SwiftType { switch try readInt(&buf) as Int8 { case 0: return nil - case 1: return try FfiConverterTypePaymentTransactionFields.read(from: &buf) + case 1: return try FfiConverterSequenceData.read(from: &buf) default: throw UniffiInternalError.unexpectedOptionalTag } } @@ -1246,8 +3300,8 @@ fileprivate struct FfiConverterOptionTypePaymentTransactionFields: FfiConverterR #if swift(>=5.8) @_documentation(visibility: private) #endif -fileprivate struct FfiConverterOptionTypeByteBuf: FfiConverterRustBuffer { - typealias SwiftType = ByteBuf? +fileprivate struct FfiConverterOptionSequenceTypeBoxReference: FfiConverterRustBuffer { + typealias SwiftType = [BoxReference]? public static func write(_ value: SwiftType, into buf: inout [UInt8]) { guard let value = value else { @@ -1255,97 +3309,351 @@ fileprivate struct FfiConverterOptionTypeByteBuf: FfiConverterRustBuffer { return } writeInt(&buf, Int8(1)) - FfiConverterTypeByteBuf.write(value, into: &buf) + FfiConverterSequenceTypeBoxReference.write(value, into: &buf) } public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> SwiftType { switch try readInt(&buf) as Int8 { case 0: return nil - case 1: return try FfiConverterTypeByteBuf.read(from: &buf) + case 1: return try FfiConverterSequenceTypeBoxReference.read(from: &buf) default: throw UniffiInternalError.unexpectedOptionalTag } } } +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +fileprivate struct FfiConverterSequenceUInt64: FfiConverterRustBuffer { + typealias SwiftType = [UInt64] -/** - * Typealias from the type name used in the UDL file to the builtin type. This - * is needed because the UDL type name is used in function/method signatures. - */ -public typealias ByteBuf = Data + public static func write(_ value: [UInt64], into buf: inout [UInt8]) { + let len = Int32(value.count) + writeInt(&buf, len) + for item in value { + FfiConverterUInt64.write(item, into: &buf) + } + } + + public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> [UInt64] { + let len: Int32 = try readInt(&buf) + var seq = [UInt64]() + seq.reserveCapacity(Int(len)) + for _ in 0 ..< len { + seq.append(try FfiConverterUInt64.read(from: &buf)) + } + return seq + } +} #if swift(>=5.8) @_documentation(visibility: private) #endif -public struct FfiConverterTypeByteBuf: FfiConverter { - public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> ByteBuf { - return try FfiConverterData.read(from: &buf) +fileprivate struct FfiConverterSequenceString: FfiConverterRustBuffer { + typealias SwiftType = [String] + + public static func write(_ value: [String], into buf: inout [UInt8]) { + let len = Int32(value.count) + writeInt(&buf, len) + for item in value { + FfiConverterString.write(item, into: &buf) + } } - public static func write(_ value: ByteBuf, into buf: inout [UInt8]) { - return FfiConverterData.write(value, into: &buf) + public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> [String] { + let len: Int32 = try readInt(&buf) + var seq = [String]() + seq.reserveCapacity(Int(len)) + for _ in 0 ..< len { + seq.append(try FfiConverterString.read(from: &buf)) + } + return seq } +} + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +fileprivate struct FfiConverterSequenceData: FfiConverterRustBuffer { + typealias SwiftType = [Data] - public static func lift(_ value: RustBuffer) throws -> ByteBuf { - return try FfiConverterData.lift(value) + public static func write(_ value: [Data], into buf: inout [UInt8]) { + let len = Int32(value.count) + writeInt(&buf, len) + for item in value { + FfiConverterData.write(item, into: &buf) + } } - public static func lower(_ value: ByteBuf) -> RustBuffer { - return FfiConverterData.lower(value) + public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> [Data] { + let len: Int32 = try readInt(&buf) + var seq = [Data]() + seq.reserveCapacity(Int(len)) + for _ in 0 ..< len { + seq.append(try FfiConverterData.read(from: &buf)) + } + return seq } } +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +fileprivate struct FfiConverterSequenceTypeBoxReference: FfiConverterRustBuffer { + typealias SwiftType = [BoxReference] + + public static func write(_ value: [BoxReference], into buf: inout [UInt8]) { + let len = Int32(value.count) + writeInt(&buf, len) + for item in value { + FfiConverterTypeBoxReference.write(item, into: &buf) + } + } + + public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> [BoxReference] { + let len: Int32 = try readInt(&buf) + var seq = [BoxReference]() + seq.reserveCapacity(Int(len)) + for _ in 0 ..< len { + seq.append(try FfiConverterTypeBoxReference.read(from: &buf)) + } + return seq + } +} #if swift(>=5.8) @_documentation(visibility: private) #endif -public func FfiConverterTypeByteBuf_lift(_ value: RustBuffer) throws -> ByteBuf { - return try FfiConverterTypeByteBuf.lift(value) +fileprivate struct FfiConverterSequenceTypeMultisigSubsignature: FfiConverterRustBuffer { + typealias SwiftType = [MultisigSubsignature] + + public static func write(_ value: [MultisigSubsignature], into buf: inout [UInt8]) { + let len = Int32(value.count) + writeInt(&buf, len) + for item in value { + FfiConverterTypeMultisigSubsignature.write(item, into: &buf) + } + } + + public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> [MultisigSubsignature] { + let len: Int32 = try readInt(&buf) + var seq = [MultisigSubsignature]() + seq.reserveCapacity(Int(len)) + for _ in 0 ..< len { + seq.append(try FfiConverterTypeMultisigSubsignature.read(from: &buf)) + } + return seq + } } #if swift(>=5.8) @_documentation(visibility: private) #endif -public func FfiConverterTypeByteBuf_lower(_ value: ByteBuf) -> RustBuffer { - return FfiConverterTypeByteBuf.lower(value) +fileprivate struct FfiConverterSequenceTypeSignedTransaction: FfiConverterRustBuffer { + typealias SwiftType = [SignedTransaction] + + public static func write(_ value: [SignedTransaction], into buf: inout [UInt8]) { + let len = Int32(value.count) + writeInt(&buf, len) + for item in value { + FfiConverterTypeSignedTransaction.write(item, into: &buf) + } + } + + public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> [SignedTransaction] { + let len: Int32 = try readInt(&buf) + var seq = [SignedTransaction]() + seq.reserveCapacity(Int(len)) + for _ in 0 ..< len { + seq.append(try FfiConverterTypeSignedTransaction.read(from: &buf)) + } + return seq + } } -public func addressFromPubKey(pubKey: Data)throws -> Address { - return try FfiConverterTypeAddress.lift(try rustCallWithError(FfiConverterTypeAlgoKitTransactError.lift) { - uniffi_algokit_transact_ffi_fn_func_address_from_pub_key( - FfiConverterData.lower(pubKey),$0 +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +fileprivate struct FfiConverterSequenceTypeTransaction: FfiConverterRustBuffer { + typealias SwiftType = [Transaction] + + public static func write(_ value: [Transaction], into buf: inout [UInt8]) { + let len = Int32(value.count) + writeInt(&buf, len) + for item in value { + FfiConverterTypeTransaction.write(item, into: &buf) + } + } + + public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> [Transaction] { + let len: Int32 = try readInt(&buf) + var seq = [Transaction]() + seq.reserveCapacity(Int(len)) + for _ in 0 ..< len { + seq.append(try FfiConverterTypeTransaction.read(from: &buf)) + } + return seq + } +} +/** + * Returns the address of the multisignature account. + * + * # Errors + * /// Returns [`AlgoKitTransactError`] if the multisignature signature is invalid or the address cannot be derived. + */ +public func addressFromMultisigSignature(multisigSignature: MultisigSignature)throws -> String { + return try FfiConverterString.lift(try rustCallWithError(FfiConverterTypeAlgoKitTransactError_lift) { + uniffi_algokit_transact_ffi_fn_func_address_from_multisig_signature( + FfiConverterTypeMultisigSignature_lower(multisigSignature),$0 ) }) } -public func addressFromString(address: String)throws -> Address { - return try FfiConverterTypeAddress.lift(try rustCallWithError(FfiConverterTypeAlgoKitTransactError.lift) { - uniffi_algokit_transact_ffi_fn_func_address_from_string( - FfiConverterString.lower(address),$0 +public func addressFromPublicKey(publicKey: Data)throws -> String { + return try FfiConverterString.lift(try rustCallWithError(FfiConverterTypeAlgoKitTransactError_lift) { + uniffi_algokit_transact_ffi_fn_func_address_from_public_key( + FfiConverterData.lower(publicKey),$0 + ) +}) +} +/** + * Applies a subsignature for a participant to a multisignature signature, replacing any existing signature. + * + * # Errors + * + * Returns [`AlgoKitTransactError`] if the participant address is invalid or not found, or if the signature bytes are invalid. + */ +public func applyMultisigSubsignature(multisigSignature: MultisigSignature, participant: String, subsignature: Data)throws -> MultisigSignature { + return try FfiConverterTypeMultisigSignature_lift(try rustCallWithError(FfiConverterTypeAlgoKitTransactError_lift) { + uniffi_algokit_transact_ffi_fn_func_apply_multisig_subsignature( + FfiConverterTypeMultisigSignature_lower(multisigSignature), + FfiConverterString.lower(participant), + FfiConverterData.lower(subsignature),$0 + ) +}) +} +public func assignFee(transaction: Transaction, feeParams: FeeParams)throws -> Transaction { + return try FfiConverterTypeTransaction_lift(try rustCallWithError(FfiConverterTypeAlgoKitTransactError_lift) { + uniffi_algokit_transact_ffi_fn_func_assign_fee( + FfiConverterTypeTransaction_lower(transaction), + FfiConverterTypeFeeParams_lower(feeParams),$0 + ) +}) +} +public func calculateFee(transaction: Transaction, feeParams: FeeParams)throws -> UInt64 { + return try FfiConverterUInt64.lift(try rustCallWithError(FfiConverterTypeAlgoKitTransactError_lift) { + uniffi_algokit_transact_ffi_fn_func_calculate_fee( + FfiConverterTypeTransaction_lower(transaction), + FfiConverterTypeFeeParams_lower(feeParams),$0 + ) +}) +} +/** + * Decodes a signed transaction. + * + * # Parameters + * * `encoded_signed_transaction` - The MsgPack encoded signed transaction bytes + * + * # Returns + * The decoded SignedTransaction or an error if decoding fails. + */ +public func decodeSignedTransaction(encodedSignedTransaction: Data)throws -> SignedTransaction { + return try FfiConverterTypeSignedTransaction_lift(try rustCallWithError(FfiConverterTypeAlgoKitTransactError_lift) { + uniffi_algokit_transact_ffi_fn_func_decode_signed_transaction( + FfiConverterData.lower(encodedSignedTransaction),$0 ) }) } -public func attachSignature(encodedTx: Data, signature: Data)throws -> Data { - return try FfiConverterData.lift(try rustCallWithError(FfiConverterTypeAlgoKitTransactError.lift) { - uniffi_algokit_transact_ffi_fn_func_attach_signature( - FfiConverterData.lower(encodedTx), - FfiConverterData.lower(signature),$0 +/** + * Decodes a collection of MsgPack bytes into a signed transaction collection. + * + * # Parameters + * * `encoded_signed_transactions` - A collection of MsgPack encoded bytes, each representing a signed transaction. + * + * # Returns + * A collection of decoded signed transactions or an error if decoding fails. + */ +public func decodeSignedTransactions(encodedSignedTransactions: [Data])throws -> [SignedTransaction] { + return try FfiConverterSequenceTypeSignedTransaction.lift(try rustCallWithError(FfiConverterTypeAlgoKitTransactError_lift) { + uniffi_algokit_transact_ffi_fn_func_decode_signed_transactions( + FfiConverterSequenceData.lower(encodedSignedTransactions),$0 ) }) } -public func decodeTransaction(bytes: Data)throws -> Transaction { - return try FfiConverterTypeTransaction.lift(try rustCallWithError(FfiConverterTypeAlgoKitTransactError.lift) { +/** + * Decodes MsgPack bytes into a transaction. + * + * # Parameters + * * `encoded_tx` - MsgPack encoded bytes representing a transaction. + * + * # Returns + * A decoded transaction or an error if decoding fails. + */ +public func decodeTransaction(encodedTx: Data)throws -> Transaction { + return try FfiConverterTypeTransaction_lift(try rustCallWithError(FfiConverterTypeAlgoKitTransactError_lift) { uniffi_algokit_transact_ffi_fn_func_decode_transaction( - FfiConverterData.lower(bytes),$0 + FfiConverterData.lower(encodedTx),$0 + ) +}) +} +/** + * Decodes a collection of MsgPack bytes into a transaction collection. + * + * # Parameters + * * `encoded_txs` - A collection of MsgPack encoded bytes, each representing a transaction. + * + * # Returns + * A collection of decoded transactions or an error if decoding fails. + */ +public func decodeTransactions(encodedTxs: [Data])throws -> [Transaction] { + return try FfiConverterSequenceTypeTransaction.lift(try rustCallWithError(FfiConverterTypeAlgoKitTransactError_lift) { + uniffi_algokit_transact_ffi_fn_func_decode_transactions( + FfiConverterSequenceData.lower(encodedTxs),$0 + ) +}) +} +/** + * Encode a signed transaction to MsgPack for sending on the network. + * + * This method performs canonical encoding. No domain separation prefix is applicable. + * + * # Parameters + * * `signed_transaction` - The signed transaction to encode + * + * # Returns + * The MsgPack encoded bytes or an error if encoding fails. + */ +public func encodeSignedTransaction(signedTransaction: SignedTransaction)throws -> Data { + return try FfiConverterData.lift(try rustCallWithError(FfiConverterTypeAlgoKitTransactError_lift) { + uniffi_algokit_transact_ffi_fn_func_encode_signed_transaction( + FfiConverterTypeSignedTransaction_lower(signedTransaction),$0 + ) +}) +} +/** + * Encode signed transactions to MsgPack for sending on the network. + * + * This method performs canonical encoding. No domain separation prefix is applicable. + * + * # Parameters + * * `signed_transactions` - A collection of signed transactions to encode + * + * # Returns + * A collection of MsgPack encoded bytes or an error if encoding fails. + */ +public func encodeSignedTransactions(signedTransactions: [SignedTransaction])throws -> [Data] { + return try FfiConverterSequenceData.lift(try rustCallWithError(FfiConverterTypeAlgoKitTransactError_lift) { + uniffi_algokit_transact_ffi_fn_func_encode_signed_transactions( + FfiConverterSequenceTypeSignedTransaction.lower(signedTransactions),$0 ) }) } /** * Encode the transaction with the domain separation (e.g. "TX") prefix */ -public func encodeTransaction(tx: Transaction)throws -> Data { - return try FfiConverterData.lift(try rustCallWithError(FfiConverterTypeAlgoKitTransactError.lift) { +public func encodeTransaction(transaction: Transaction)throws -> Data { + return try FfiConverterData.lift(try rustCallWithError(FfiConverterTypeAlgoKitTransactError_lift) { uniffi_algokit_transact_ffi_fn_func_encode_transaction( - FfiConverterTypeTransaction.lower(tx),$0 + FfiConverterTypeTransaction_lower(transaction),$0 ) }) } @@ -1353,10 +3661,26 @@ public func encodeTransaction(tx: Transaction)throws -> Data { * Encode the transaction without the domain separation (e.g. "TX") prefix * This is useful for encoding the transaction for signing with tools that automatically add "TX" prefix to the transaction bytes. */ -public func encodeTransactionRaw(tx: Transaction)throws -> Data { - return try FfiConverterData.lift(try rustCallWithError(FfiConverterTypeAlgoKitTransactError.lift) { +public func encodeTransactionRaw(transaction: Transaction)throws -> Data { + return try FfiConverterData.lift(try rustCallWithError(FfiConverterTypeAlgoKitTransactError_lift) { uniffi_algokit_transact_ffi_fn_func_encode_transaction_raw( - FfiConverterTypeTransaction.lower(tx),$0 + FfiConverterTypeTransaction_lower(transaction),$0 + ) +}) +} +/** + * Encode transactions to MsgPack with the domain separation (e.g. "TX") prefix. + * + * # Parameters + * * `transactions` - A collection of transactions to encode + * + * # Returns + * A collection of MsgPack encoded bytes or an error if encoding fails. + */ +public func encodeTransactions(transactions: [Transaction])throws -> [Data] { + return try FfiConverterSequenceData.lift(try rustCallWithError(FfiConverterTypeAlgoKitTransactError_lift) { + uniffi_algokit_transact_ffi_fn_func_encode_transactions( + FfiConverterSequenceTypeTransaction.lower(transactions),$0 ) }) } @@ -1364,17 +3688,17 @@ public func encodeTransactionRaw(tx: Transaction)throws -> Data { * Return the size of the transaction in bytes as if it was already signed and encoded. * This is useful for estimating the fee for the transaction. */ -public func estimateTransactionSize(transaction: Transaction)throws -> UInt64 { - return try FfiConverterUInt64.lift(try rustCallWithError(FfiConverterTypeAlgoKitTransactError.lift) { +public func estimateTransactionSize(transaction: Transaction)throws -> UInt64 { + return try FfiConverterUInt64.lift(try rustCallWithError(FfiConverterTypeAlgoKitTransactError_lift) { uniffi_algokit_transact_ffi_fn_func_estimate_transaction_size( - FfiConverterTypeTransaction.lower(transaction),$0 + FfiConverterTypeTransaction_lower(transaction),$0 ) }) } -public func getAlgorandConstant(constant: AlgorandConstant) -> UInt64 { +public func getAlgorandConstant(constant: AlgorandConstant) -> UInt64 { return try! FfiConverterUInt64.lift(try! rustCall() { uniffi_algokit_transact_ffi_fn_func_get_algorand_constant( - FfiConverterTypeAlgorandConstant.lower(constant),$0 + FfiConverterTypeAlgorandConstant_lower(constant),$0 ) }) } @@ -1382,30 +3706,91 @@ public func getAlgorandConstant(constant: AlgorandConstant) -> UInt64 { * Get the transaction type from the encoded transaction. * This is particularly useful when decoding a transaction that has an unknown type */ -public func getEncodedTransactionType(bytes: Data)throws -> TransactionType { - return try FfiConverterTypeTransactionType.lift(try rustCallWithError(FfiConverterTypeAlgoKitTransactError.lift) { +public func getEncodedTransactionType(encodedTransaction: Data)throws -> TransactionType { + return try FfiConverterTypeTransactionType_lift(try rustCallWithError(FfiConverterTypeAlgoKitTransactError_lift) { uniffi_algokit_transact_ffi_fn_func_get_encoded_transaction_type( - FfiConverterData.lower(bytes),$0 + FfiConverterData.lower(encodedTransaction),$0 ) }) } /** * Get the base32 transaction ID string for a transaction. */ -public func getTransactionId(tx: Transaction)throws -> String { - return try FfiConverterString.lift(try rustCallWithError(FfiConverterTypeAlgoKitTransactError.lift) { +public func getTransactionId(transaction: Transaction)throws -> String { + return try FfiConverterString.lift(try rustCallWithError(FfiConverterTypeAlgoKitTransactError_lift) { uniffi_algokit_transact_ffi_fn_func_get_transaction_id( - FfiConverterTypeTransaction.lower(tx),$0 + FfiConverterTypeTransaction_lower(transaction),$0 ) }) } /** * Get the raw 32-byte transaction ID for a transaction. */ -public func getTransactionIdRaw(tx: Transaction)throws -> Data { - return try FfiConverterData.lift(try rustCallWithError(FfiConverterTypeAlgoKitTransactError.lift) { +public func getTransactionIdRaw(transaction: Transaction)throws -> Data { + return try FfiConverterData.lift(try rustCallWithError(FfiConverterTypeAlgoKitTransactError_lift) { uniffi_algokit_transact_ffi_fn_func_get_transaction_id_raw( - FfiConverterTypeTransaction.lower(tx),$0 + FfiConverterTypeTransaction_lower(transaction),$0 + ) +}) +} +/** + * Groups a collection of transactions by calculating and assigning the group to each transaction. + */ +public func groupTransactions(transactions: [Transaction])throws -> [Transaction] { + return try FfiConverterSequenceTypeTransaction.lift(try rustCallWithError(FfiConverterTypeAlgoKitTransactError_lift) { + uniffi_algokit_transact_ffi_fn_func_group_transactions( + FfiConverterSequenceTypeTransaction.lower(transactions),$0 + ) +}) +} +/** + * Merges two multisignature signatures, replacing signatures in the first with those from the second where present. + * + * # Errors + * + * Returns [`AlgoKitTransactError`] if the multisignature parameters or participants do not match. + */ +public func mergeMultisignatures(multisigSignatureA: MultisigSignature, multisigSignatureB: MultisigSignature)throws -> MultisigSignature { + return try FfiConverterTypeMultisigSignature_lift(try rustCallWithError(FfiConverterTypeAlgoKitTransactError_lift) { + uniffi_algokit_transact_ffi_fn_func_merge_multisignatures( + FfiConverterTypeMultisigSignature_lower(multisigSignatureA), + FfiConverterTypeMultisigSignature_lower(multisigSignatureB),$0 + ) +}) +} +/** + * Creates an empty multisignature signature from a list of participant addresses. + * + * # Errors + * + * Returns [`AlgoKitTransactError`] if any address is invalid or the multisignature parameters are invalid. + */ +public func newMultisigSignature(version: UInt8, threshold: UInt8, participants: [String])throws -> MultisigSignature { + return try FfiConverterTypeMultisigSignature_lift(try rustCallWithError(FfiConverterTypeAlgoKitTransactError_lift) { + uniffi_algokit_transact_ffi_fn_func_new_multisig_signature( + FfiConverterUInt8.lower(version), + FfiConverterUInt8.lower(threshold), + FfiConverterSequenceString.lower(participants),$0 + ) +}) +} +/** + * Returns the list of participant addresses from a multisignature signature. + * + * # Errors + * Returns [`AlgoKitTransactError`] if the multisignature is invalid. + */ +public func participantsFromMultisigSignature(multisigSignature: MultisigSignature)throws -> [String] { + return try FfiConverterSequenceString.lift(try rustCallWithError(FfiConverterTypeAlgoKitTransactError_lift) { + uniffi_algokit_transact_ffi_fn_func_participants_from_multisig_signature( + FfiConverterTypeMultisigSignature_lower(multisigSignature),$0 + ) +}) +} +public func publicKeyFromAddress(address: String)throws -> Data { + return try FfiConverterData.lift(try rustCallWithError(FfiConverterTypeAlgoKitTransactError_lift) { + uniffi_algokit_transact_ffi_fn_func_public_key_from_address( + FfiConverterString.lower(address),$0 ) }) } @@ -1419,28 +3804,52 @@ private enum InitializationResult { // the code inside is only computed once. private let initializationResult: InitializationResult = { // Get the bindings contract version from our ComponentInterface - let bindings_contract_version = 26 + let bindings_contract_version = 29 // Get the scaffolding contract version by calling the into the dylib let scaffolding_contract_version = ffi_algokit_transact_ffi_uniffi_contract_version() if bindings_contract_version != scaffolding_contract_version { return InitializationResult.contractVersionMismatch } - if (uniffi_algokit_transact_ffi_checksum_func_address_from_pub_key() != 65205) { + if (uniffi_algokit_transact_ffi_checksum_func_address_from_multisig_signature() != 51026) { + return InitializationResult.apiChecksumMismatch + } + if (uniffi_algokit_transact_ffi_checksum_func_address_from_public_key() != 10716) { + return InitializationResult.apiChecksumMismatch + } + if (uniffi_algokit_transact_ffi_checksum_func_apply_multisig_subsignature() != 42634) { + return InitializationResult.apiChecksumMismatch + } + if (uniffi_algokit_transact_ffi_checksum_func_assign_fee() != 35003) { + return InitializationResult.apiChecksumMismatch + } + if (uniffi_algokit_transact_ffi_checksum_func_calculate_fee() != 7537) { + return InitializationResult.apiChecksumMismatch + } + if (uniffi_algokit_transact_ffi_checksum_func_decode_signed_transaction() != 43569) { return InitializationResult.apiChecksumMismatch } - if (uniffi_algokit_transact_ffi_checksum_func_address_from_string() != 56499) { + if (uniffi_algokit_transact_ffi_checksum_func_decode_signed_transactions() != 62888) { return InitializationResult.apiChecksumMismatch } - if (uniffi_algokit_transact_ffi_checksum_func_attach_signature() != 7369) { + if (uniffi_algokit_transact_ffi_checksum_func_decode_transaction() != 56405) { return InitializationResult.apiChecksumMismatch } - if (uniffi_algokit_transact_ffi_checksum_func_decode_transaction() != 38127) { + if (uniffi_algokit_transact_ffi_checksum_func_decode_transactions() != 26956) { return InitializationResult.apiChecksumMismatch } - if (uniffi_algokit_transact_ffi_checksum_func_encode_transaction() != 62809) { + if (uniffi_algokit_transact_ffi_checksum_func_encode_signed_transaction() != 47064) { return InitializationResult.apiChecksumMismatch } - if (uniffi_algokit_transact_ffi_checksum_func_encode_transaction_raw() != 1774) { + if (uniffi_algokit_transact_ffi_checksum_func_encode_signed_transactions() != 1956) { + return InitializationResult.apiChecksumMismatch + } + if (uniffi_algokit_transact_ffi_checksum_func_encode_transaction() != 11275) { + return InitializationResult.apiChecksumMismatch + } + if (uniffi_algokit_transact_ffi_checksum_func_encode_transaction_raw() != 384) { + return InitializationResult.apiChecksumMismatch + } + if (uniffi_algokit_transact_ffi_checksum_func_encode_transactions() != 59611) { return InitializationResult.apiChecksumMismatch } if (uniffi_algokit_transact_ffi_checksum_func_estimate_transaction_size() != 60858) { @@ -1449,20 +3858,37 @@ private let initializationResult: InitializationResult = { if (uniffi_algokit_transact_ffi_checksum_func_get_algorand_constant() != 49400) { return InitializationResult.apiChecksumMismatch } - if (uniffi_algokit_transact_ffi_checksum_func_get_encoded_transaction_type() != 9866) { + if (uniffi_algokit_transact_ffi_checksum_func_get_encoded_transaction_type() != 42551) { + return InitializationResult.apiChecksumMismatch + } + if (uniffi_algokit_transact_ffi_checksum_func_get_transaction_id() != 10957) { + return InitializationResult.apiChecksumMismatch + } + if (uniffi_algokit_transact_ffi_checksum_func_get_transaction_id_raw() != 48975) { + return InitializationResult.apiChecksumMismatch + } + if (uniffi_algokit_transact_ffi_checksum_func_group_transactions() != 18193) { + return InitializationResult.apiChecksumMismatch + } + if (uniffi_algokit_transact_ffi_checksum_func_merge_multisignatures() != 58688) { + return InitializationResult.apiChecksumMismatch + } + if (uniffi_algokit_transact_ffi_checksum_func_new_multisig_signature() != 29314) { return InitializationResult.apiChecksumMismatch } - if (uniffi_algokit_transact_ffi_checksum_func_get_transaction_id() != 20463) { + if (uniffi_algokit_transact_ffi_checksum_func_participants_from_multisig_signature() != 25095) { return InitializationResult.apiChecksumMismatch } - if (uniffi_algokit_transact_ffi_checksum_func_get_transaction_id_raw() != 37098) { + if (uniffi_algokit_transact_ffi_checksum_func_public_key_from_address() != 58152) { return InitializationResult.apiChecksumMismatch } return InitializationResult.ok }() -private func uniffiEnsureInitialized() { +// Make the ensure init function public so that other modules which have external type references to +// our types can call it. +public func uniffiEnsureAlgokitTransactFfiInitialized() { switch initializationResult { case .ok: break diff --git a/packages/swift/AlgoKitTransact/Frameworks/algokit_transact.xcframework/macos-arm64_x86_64/Headers/algokit_transactFFI.h b/packages/swift/AlgoKitTransact/Frameworks/algokit_transact.xcframework/macos-arm64_x86_64/Headers/algokit_transactFFI.h index 5f1185624..d6dd1e874 100644 --- a/packages/swift/AlgoKitTransact/Frameworks/algokit_transact.xcframework/macos-arm64_x86_64/Headers/algokit_transactFFI.h +++ b/packages/swift/AlgoKitTransact/Frameworks/algokit_transact.xcframework/macos-arm64_x86_64/Headers/algokit_transactFFI.h @@ -251,34 +251,74 @@ typedef void (*UniffiForeignFutureCompleteVoid)(uint64_t, UniffiForeignFutureStr ); #endif -#ifndef UNIFFI_FFIDEF_UNIFFI_ALGOKIT_TRANSACT_FFI_FN_FUNC_ADDRESS_FROM_PUB_KEY -#define UNIFFI_FFIDEF_UNIFFI_ALGOKIT_TRANSACT_FFI_FN_FUNC_ADDRESS_FROM_PUB_KEY -RustBuffer uniffi_algokit_transact_ffi_fn_func_address_from_pub_key(RustBuffer pub_key, RustCallStatus *_Nonnull out_status +#ifndef UNIFFI_FFIDEF_UNIFFI_ALGOKIT_TRANSACT_FFI_FN_FUNC_ADDRESS_FROM_MULTISIG_SIGNATURE +#define UNIFFI_FFIDEF_UNIFFI_ALGOKIT_TRANSACT_FFI_FN_FUNC_ADDRESS_FROM_MULTISIG_SIGNATURE +RustBuffer uniffi_algokit_transact_ffi_fn_func_address_from_multisig_signature(RustBuffer multisig_signature, RustCallStatus *_Nonnull out_status ); #endif -#ifndef UNIFFI_FFIDEF_UNIFFI_ALGOKIT_TRANSACT_FFI_FN_FUNC_ADDRESS_FROM_STRING -#define UNIFFI_FFIDEF_UNIFFI_ALGOKIT_TRANSACT_FFI_FN_FUNC_ADDRESS_FROM_STRING -RustBuffer uniffi_algokit_transact_ffi_fn_func_address_from_string(RustBuffer address, RustCallStatus *_Nonnull out_status +#ifndef UNIFFI_FFIDEF_UNIFFI_ALGOKIT_TRANSACT_FFI_FN_FUNC_ADDRESS_FROM_PUBLIC_KEY +#define UNIFFI_FFIDEF_UNIFFI_ALGOKIT_TRANSACT_FFI_FN_FUNC_ADDRESS_FROM_PUBLIC_KEY +RustBuffer uniffi_algokit_transact_ffi_fn_func_address_from_public_key(RustBuffer public_key, RustCallStatus *_Nonnull out_status ); #endif -#ifndef UNIFFI_FFIDEF_UNIFFI_ALGOKIT_TRANSACT_FFI_FN_FUNC_ATTACH_SIGNATURE -#define UNIFFI_FFIDEF_UNIFFI_ALGOKIT_TRANSACT_FFI_FN_FUNC_ATTACH_SIGNATURE -RustBuffer uniffi_algokit_transact_ffi_fn_func_attach_signature(RustBuffer encoded_tx, RustBuffer signature, RustCallStatus *_Nonnull out_status +#ifndef UNIFFI_FFIDEF_UNIFFI_ALGOKIT_TRANSACT_FFI_FN_FUNC_APPLY_MULTISIG_SUBSIGNATURE +#define UNIFFI_FFIDEF_UNIFFI_ALGOKIT_TRANSACT_FFI_FN_FUNC_APPLY_MULTISIG_SUBSIGNATURE +RustBuffer uniffi_algokit_transact_ffi_fn_func_apply_multisig_subsignature(RustBuffer multisig_signature, RustBuffer participant, RustBuffer subsignature, RustCallStatus *_Nonnull out_status +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_ALGOKIT_TRANSACT_FFI_FN_FUNC_ASSIGN_FEE +#define UNIFFI_FFIDEF_UNIFFI_ALGOKIT_TRANSACT_FFI_FN_FUNC_ASSIGN_FEE +RustBuffer uniffi_algokit_transact_ffi_fn_func_assign_fee(RustBuffer transaction, RustBuffer fee_params, RustCallStatus *_Nonnull out_status +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_ALGOKIT_TRANSACT_FFI_FN_FUNC_CALCULATE_FEE +#define UNIFFI_FFIDEF_UNIFFI_ALGOKIT_TRANSACT_FFI_FN_FUNC_CALCULATE_FEE +uint64_t uniffi_algokit_transact_ffi_fn_func_calculate_fee(RustBuffer transaction, RustBuffer fee_params, RustCallStatus *_Nonnull out_status +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_ALGOKIT_TRANSACT_FFI_FN_FUNC_DECODE_SIGNED_TRANSACTION +#define UNIFFI_FFIDEF_UNIFFI_ALGOKIT_TRANSACT_FFI_FN_FUNC_DECODE_SIGNED_TRANSACTION +RustBuffer uniffi_algokit_transact_ffi_fn_func_decode_signed_transaction(RustBuffer encoded_signed_transaction, RustCallStatus *_Nonnull out_status +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_ALGOKIT_TRANSACT_FFI_FN_FUNC_DECODE_SIGNED_TRANSACTIONS +#define UNIFFI_FFIDEF_UNIFFI_ALGOKIT_TRANSACT_FFI_FN_FUNC_DECODE_SIGNED_TRANSACTIONS +RustBuffer uniffi_algokit_transact_ffi_fn_func_decode_signed_transactions(RustBuffer encoded_signed_transactions, RustCallStatus *_Nonnull out_status ); #endif #ifndef UNIFFI_FFIDEF_UNIFFI_ALGOKIT_TRANSACT_FFI_FN_FUNC_DECODE_TRANSACTION #define UNIFFI_FFIDEF_UNIFFI_ALGOKIT_TRANSACT_FFI_FN_FUNC_DECODE_TRANSACTION -RustBuffer uniffi_algokit_transact_ffi_fn_func_decode_transaction(RustBuffer bytes, RustCallStatus *_Nonnull out_status +RustBuffer uniffi_algokit_transact_ffi_fn_func_decode_transaction(RustBuffer encoded_tx, RustCallStatus *_Nonnull out_status +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_ALGOKIT_TRANSACT_FFI_FN_FUNC_DECODE_TRANSACTIONS +#define UNIFFI_FFIDEF_UNIFFI_ALGOKIT_TRANSACT_FFI_FN_FUNC_DECODE_TRANSACTIONS +RustBuffer uniffi_algokit_transact_ffi_fn_func_decode_transactions(RustBuffer encoded_txs, RustCallStatus *_Nonnull out_status +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_ALGOKIT_TRANSACT_FFI_FN_FUNC_ENCODE_SIGNED_TRANSACTION +#define UNIFFI_FFIDEF_UNIFFI_ALGOKIT_TRANSACT_FFI_FN_FUNC_ENCODE_SIGNED_TRANSACTION +RustBuffer uniffi_algokit_transact_ffi_fn_func_encode_signed_transaction(RustBuffer signed_transaction, RustCallStatus *_Nonnull out_status +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_ALGOKIT_TRANSACT_FFI_FN_FUNC_ENCODE_SIGNED_TRANSACTIONS +#define UNIFFI_FFIDEF_UNIFFI_ALGOKIT_TRANSACT_FFI_FN_FUNC_ENCODE_SIGNED_TRANSACTIONS +RustBuffer uniffi_algokit_transact_ffi_fn_func_encode_signed_transactions(RustBuffer signed_transactions, RustCallStatus *_Nonnull out_status ); #endif #ifndef UNIFFI_FFIDEF_UNIFFI_ALGOKIT_TRANSACT_FFI_FN_FUNC_ENCODE_TRANSACTION #define UNIFFI_FFIDEF_UNIFFI_ALGOKIT_TRANSACT_FFI_FN_FUNC_ENCODE_TRANSACTION -RustBuffer uniffi_algokit_transact_ffi_fn_func_encode_transaction(RustBuffer tx, RustCallStatus *_Nonnull out_status +RustBuffer uniffi_algokit_transact_ffi_fn_func_encode_transaction(RustBuffer transaction, RustCallStatus *_Nonnull out_status ); #endif #ifndef UNIFFI_FFIDEF_UNIFFI_ALGOKIT_TRANSACT_FFI_FN_FUNC_ENCODE_TRANSACTION_RAW #define UNIFFI_FFIDEF_UNIFFI_ALGOKIT_TRANSACT_FFI_FN_FUNC_ENCODE_TRANSACTION_RAW -RustBuffer uniffi_algokit_transact_ffi_fn_func_encode_transaction_raw(RustBuffer tx, RustCallStatus *_Nonnull out_status +RustBuffer uniffi_algokit_transact_ffi_fn_func_encode_transaction_raw(RustBuffer transaction, RustCallStatus *_Nonnull out_status +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_ALGOKIT_TRANSACT_FFI_FN_FUNC_ENCODE_TRANSACTIONS +#define UNIFFI_FFIDEF_UNIFFI_ALGOKIT_TRANSACT_FFI_FN_FUNC_ENCODE_TRANSACTIONS +RustBuffer uniffi_algokit_transact_ffi_fn_func_encode_transactions(RustBuffer transactions, RustCallStatus *_Nonnull out_status ); #endif #ifndef UNIFFI_FFIDEF_UNIFFI_ALGOKIT_TRANSACT_FFI_FN_FUNC_ESTIMATE_TRANSACTION_SIZE @@ -293,17 +333,42 @@ uint64_t uniffi_algokit_transact_ffi_fn_func_get_algorand_constant(RustBuffer co #endif #ifndef UNIFFI_FFIDEF_UNIFFI_ALGOKIT_TRANSACT_FFI_FN_FUNC_GET_ENCODED_TRANSACTION_TYPE #define UNIFFI_FFIDEF_UNIFFI_ALGOKIT_TRANSACT_FFI_FN_FUNC_GET_ENCODED_TRANSACTION_TYPE -RustBuffer uniffi_algokit_transact_ffi_fn_func_get_encoded_transaction_type(RustBuffer bytes, RustCallStatus *_Nonnull out_status +RustBuffer uniffi_algokit_transact_ffi_fn_func_get_encoded_transaction_type(RustBuffer encoded_transaction, RustCallStatus *_Nonnull out_status ); #endif #ifndef UNIFFI_FFIDEF_UNIFFI_ALGOKIT_TRANSACT_FFI_FN_FUNC_GET_TRANSACTION_ID #define UNIFFI_FFIDEF_UNIFFI_ALGOKIT_TRANSACT_FFI_FN_FUNC_GET_TRANSACTION_ID -RustBuffer uniffi_algokit_transact_ffi_fn_func_get_transaction_id(RustBuffer tx, RustCallStatus *_Nonnull out_status +RustBuffer uniffi_algokit_transact_ffi_fn_func_get_transaction_id(RustBuffer transaction, RustCallStatus *_Nonnull out_status ); #endif #ifndef UNIFFI_FFIDEF_UNIFFI_ALGOKIT_TRANSACT_FFI_FN_FUNC_GET_TRANSACTION_ID_RAW #define UNIFFI_FFIDEF_UNIFFI_ALGOKIT_TRANSACT_FFI_FN_FUNC_GET_TRANSACTION_ID_RAW -RustBuffer uniffi_algokit_transact_ffi_fn_func_get_transaction_id_raw(RustBuffer tx, RustCallStatus *_Nonnull out_status +RustBuffer uniffi_algokit_transact_ffi_fn_func_get_transaction_id_raw(RustBuffer transaction, RustCallStatus *_Nonnull out_status +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_ALGOKIT_TRANSACT_FFI_FN_FUNC_GROUP_TRANSACTIONS +#define UNIFFI_FFIDEF_UNIFFI_ALGOKIT_TRANSACT_FFI_FN_FUNC_GROUP_TRANSACTIONS +RustBuffer uniffi_algokit_transact_ffi_fn_func_group_transactions(RustBuffer transactions, RustCallStatus *_Nonnull out_status +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_ALGOKIT_TRANSACT_FFI_FN_FUNC_MERGE_MULTISIGNATURES +#define UNIFFI_FFIDEF_UNIFFI_ALGOKIT_TRANSACT_FFI_FN_FUNC_MERGE_MULTISIGNATURES +RustBuffer uniffi_algokit_transact_ffi_fn_func_merge_multisignatures(RustBuffer multisig_signature_a, RustBuffer multisig_signature_b, RustCallStatus *_Nonnull out_status +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_ALGOKIT_TRANSACT_FFI_FN_FUNC_NEW_MULTISIG_SIGNATURE +#define UNIFFI_FFIDEF_UNIFFI_ALGOKIT_TRANSACT_FFI_FN_FUNC_NEW_MULTISIG_SIGNATURE +RustBuffer uniffi_algokit_transact_ffi_fn_func_new_multisig_signature(uint8_t version, uint8_t threshold, RustBuffer participants, RustCallStatus *_Nonnull out_status +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_ALGOKIT_TRANSACT_FFI_FN_FUNC_PARTICIPANTS_FROM_MULTISIG_SIGNATURE +#define UNIFFI_FFIDEF_UNIFFI_ALGOKIT_TRANSACT_FFI_FN_FUNC_PARTICIPANTS_FROM_MULTISIG_SIGNATURE +RustBuffer uniffi_algokit_transact_ffi_fn_func_participants_from_multisig_signature(RustBuffer multisig_signature, RustCallStatus *_Nonnull out_status +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_ALGOKIT_TRANSACT_FFI_FN_FUNC_PUBLIC_KEY_FROM_ADDRESS +#define UNIFFI_FFIDEF_UNIFFI_ALGOKIT_TRANSACT_FFI_FN_FUNC_PUBLIC_KEY_FROM_ADDRESS +RustBuffer uniffi_algokit_transact_ffi_fn_func_public_key_from_address(RustBuffer address, RustCallStatus *_Nonnull out_status ); #endif #ifndef UNIFFI_FFIDEF_FFI_ALGOKIT_TRANSACT_FFI_RUSTBUFFER_ALLOC @@ -586,21 +651,45 @@ void ffi_algokit_transact_ffi_rust_future_free_void(uint64_t handle void ffi_algokit_transact_ffi_rust_future_complete_void(uint64_t handle, RustCallStatus *_Nonnull out_status ); #endif -#ifndef UNIFFI_FFIDEF_UNIFFI_ALGOKIT_TRANSACT_FFI_CHECKSUM_FUNC_ADDRESS_FROM_PUB_KEY -#define UNIFFI_FFIDEF_UNIFFI_ALGOKIT_TRANSACT_FFI_CHECKSUM_FUNC_ADDRESS_FROM_PUB_KEY -uint16_t uniffi_algokit_transact_ffi_checksum_func_address_from_pub_key(void +#ifndef UNIFFI_FFIDEF_UNIFFI_ALGOKIT_TRANSACT_FFI_CHECKSUM_FUNC_ADDRESS_FROM_MULTISIG_SIGNATURE +#define UNIFFI_FFIDEF_UNIFFI_ALGOKIT_TRANSACT_FFI_CHECKSUM_FUNC_ADDRESS_FROM_MULTISIG_SIGNATURE +uint16_t uniffi_algokit_transact_ffi_checksum_func_address_from_multisig_signature(void + +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_ALGOKIT_TRANSACT_FFI_CHECKSUM_FUNC_ADDRESS_FROM_PUBLIC_KEY +#define UNIFFI_FFIDEF_UNIFFI_ALGOKIT_TRANSACT_FFI_CHECKSUM_FUNC_ADDRESS_FROM_PUBLIC_KEY +uint16_t uniffi_algokit_transact_ffi_checksum_func_address_from_public_key(void ); #endif -#ifndef UNIFFI_FFIDEF_UNIFFI_ALGOKIT_TRANSACT_FFI_CHECKSUM_FUNC_ADDRESS_FROM_STRING -#define UNIFFI_FFIDEF_UNIFFI_ALGOKIT_TRANSACT_FFI_CHECKSUM_FUNC_ADDRESS_FROM_STRING -uint16_t uniffi_algokit_transact_ffi_checksum_func_address_from_string(void +#ifndef UNIFFI_FFIDEF_UNIFFI_ALGOKIT_TRANSACT_FFI_CHECKSUM_FUNC_APPLY_MULTISIG_SUBSIGNATURE +#define UNIFFI_FFIDEF_UNIFFI_ALGOKIT_TRANSACT_FFI_CHECKSUM_FUNC_APPLY_MULTISIG_SUBSIGNATURE +uint16_t uniffi_algokit_transact_ffi_checksum_func_apply_multisig_subsignature(void ); #endif -#ifndef UNIFFI_FFIDEF_UNIFFI_ALGOKIT_TRANSACT_FFI_CHECKSUM_FUNC_ATTACH_SIGNATURE -#define UNIFFI_FFIDEF_UNIFFI_ALGOKIT_TRANSACT_FFI_CHECKSUM_FUNC_ATTACH_SIGNATURE -uint16_t uniffi_algokit_transact_ffi_checksum_func_attach_signature(void +#ifndef UNIFFI_FFIDEF_UNIFFI_ALGOKIT_TRANSACT_FFI_CHECKSUM_FUNC_ASSIGN_FEE +#define UNIFFI_FFIDEF_UNIFFI_ALGOKIT_TRANSACT_FFI_CHECKSUM_FUNC_ASSIGN_FEE +uint16_t uniffi_algokit_transact_ffi_checksum_func_assign_fee(void + +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_ALGOKIT_TRANSACT_FFI_CHECKSUM_FUNC_CALCULATE_FEE +#define UNIFFI_FFIDEF_UNIFFI_ALGOKIT_TRANSACT_FFI_CHECKSUM_FUNC_CALCULATE_FEE +uint16_t uniffi_algokit_transact_ffi_checksum_func_calculate_fee(void + +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_ALGOKIT_TRANSACT_FFI_CHECKSUM_FUNC_DECODE_SIGNED_TRANSACTION +#define UNIFFI_FFIDEF_UNIFFI_ALGOKIT_TRANSACT_FFI_CHECKSUM_FUNC_DECODE_SIGNED_TRANSACTION +uint16_t uniffi_algokit_transact_ffi_checksum_func_decode_signed_transaction(void + +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_ALGOKIT_TRANSACT_FFI_CHECKSUM_FUNC_DECODE_SIGNED_TRANSACTIONS +#define UNIFFI_FFIDEF_UNIFFI_ALGOKIT_TRANSACT_FFI_CHECKSUM_FUNC_DECODE_SIGNED_TRANSACTIONS +uint16_t uniffi_algokit_transact_ffi_checksum_func_decode_signed_transactions(void ); #endif @@ -608,6 +697,24 @@ uint16_t uniffi_algokit_transact_ffi_checksum_func_attach_signature(void #define UNIFFI_FFIDEF_UNIFFI_ALGOKIT_TRANSACT_FFI_CHECKSUM_FUNC_DECODE_TRANSACTION uint16_t uniffi_algokit_transact_ffi_checksum_func_decode_transaction(void +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_ALGOKIT_TRANSACT_FFI_CHECKSUM_FUNC_DECODE_TRANSACTIONS +#define UNIFFI_FFIDEF_UNIFFI_ALGOKIT_TRANSACT_FFI_CHECKSUM_FUNC_DECODE_TRANSACTIONS +uint16_t uniffi_algokit_transact_ffi_checksum_func_decode_transactions(void + +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_ALGOKIT_TRANSACT_FFI_CHECKSUM_FUNC_ENCODE_SIGNED_TRANSACTION +#define UNIFFI_FFIDEF_UNIFFI_ALGOKIT_TRANSACT_FFI_CHECKSUM_FUNC_ENCODE_SIGNED_TRANSACTION +uint16_t uniffi_algokit_transact_ffi_checksum_func_encode_signed_transaction(void + +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_ALGOKIT_TRANSACT_FFI_CHECKSUM_FUNC_ENCODE_SIGNED_TRANSACTIONS +#define UNIFFI_FFIDEF_UNIFFI_ALGOKIT_TRANSACT_FFI_CHECKSUM_FUNC_ENCODE_SIGNED_TRANSACTIONS +uint16_t uniffi_algokit_transact_ffi_checksum_func_encode_signed_transactions(void + ); #endif #ifndef UNIFFI_FFIDEF_UNIFFI_ALGOKIT_TRANSACT_FFI_CHECKSUM_FUNC_ENCODE_TRANSACTION @@ -620,6 +727,12 @@ uint16_t uniffi_algokit_transact_ffi_checksum_func_encode_transaction(void #define UNIFFI_FFIDEF_UNIFFI_ALGOKIT_TRANSACT_FFI_CHECKSUM_FUNC_ENCODE_TRANSACTION_RAW uint16_t uniffi_algokit_transact_ffi_checksum_func_encode_transaction_raw(void +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_ALGOKIT_TRANSACT_FFI_CHECKSUM_FUNC_ENCODE_TRANSACTIONS +#define UNIFFI_FFIDEF_UNIFFI_ALGOKIT_TRANSACT_FFI_CHECKSUM_FUNC_ENCODE_TRANSACTIONS +uint16_t uniffi_algokit_transact_ffi_checksum_func_encode_transactions(void + ); #endif #ifndef UNIFFI_FFIDEF_UNIFFI_ALGOKIT_TRANSACT_FFI_CHECKSUM_FUNC_ESTIMATE_TRANSACTION_SIZE @@ -650,6 +763,36 @@ uint16_t uniffi_algokit_transact_ffi_checksum_func_get_transaction_id(void #define UNIFFI_FFIDEF_UNIFFI_ALGOKIT_TRANSACT_FFI_CHECKSUM_FUNC_GET_TRANSACTION_ID_RAW uint16_t uniffi_algokit_transact_ffi_checksum_func_get_transaction_id_raw(void +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_ALGOKIT_TRANSACT_FFI_CHECKSUM_FUNC_GROUP_TRANSACTIONS +#define UNIFFI_FFIDEF_UNIFFI_ALGOKIT_TRANSACT_FFI_CHECKSUM_FUNC_GROUP_TRANSACTIONS +uint16_t uniffi_algokit_transact_ffi_checksum_func_group_transactions(void + +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_ALGOKIT_TRANSACT_FFI_CHECKSUM_FUNC_MERGE_MULTISIGNATURES +#define UNIFFI_FFIDEF_UNIFFI_ALGOKIT_TRANSACT_FFI_CHECKSUM_FUNC_MERGE_MULTISIGNATURES +uint16_t uniffi_algokit_transact_ffi_checksum_func_merge_multisignatures(void + +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_ALGOKIT_TRANSACT_FFI_CHECKSUM_FUNC_NEW_MULTISIG_SIGNATURE +#define UNIFFI_FFIDEF_UNIFFI_ALGOKIT_TRANSACT_FFI_CHECKSUM_FUNC_NEW_MULTISIG_SIGNATURE +uint16_t uniffi_algokit_transact_ffi_checksum_func_new_multisig_signature(void + +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_ALGOKIT_TRANSACT_FFI_CHECKSUM_FUNC_PARTICIPANTS_FROM_MULTISIG_SIGNATURE +#define UNIFFI_FFIDEF_UNIFFI_ALGOKIT_TRANSACT_FFI_CHECKSUM_FUNC_PARTICIPANTS_FROM_MULTISIG_SIGNATURE +uint16_t uniffi_algokit_transact_ffi_checksum_func_participants_from_multisig_signature(void + +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_ALGOKIT_TRANSACT_FFI_CHECKSUM_FUNC_PUBLIC_KEY_FROM_ADDRESS +#define UNIFFI_FFIDEF_UNIFFI_ALGOKIT_TRANSACT_FFI_CHECKSUM_FUNC_PUBLIC_KEY_FROM_ADDRESS +uint16_t uniffi_algokit_transact_ffi_checksum_func_public_key_from_address(void + ); #endif #ifndef UNIFFI_FFIDEF_FFI_ALGOKIT_TRANSACT_FFI_UNIFFI_CONTRACT_VERSION diff --git a/packages/swift/AlgoKitTransact/Frameworks/algokit_transact.xcframework/macos-arm64_x86_64/Headers/module.modulemap b/packages/swift/AlgoKitTransact/Frameworks/algokit_transact.xcframework/macos-arm64_x86_64/Headers/module.modulemap index 5c45883d7..861b066ff 100644 --- a/packages/swift/AlgoKitTransact/Frameworks/algokit_transact.xcframework/macos-arm64_x86_64/Headers/module.modulemap +++ b/packages/swift/AlgoKitTransact/Frameworks/algokit_transact.xcframework/macos-arm64_x86_64/Headers/module.modulemap @@ -1,4 +1,7 @@ module algokit_transactFFI { header "algokit_transactFFI.h" export * + use "Darwin" + use "_Builtin_stdbool" + use "_Builtin_stdint" } \ No newline at end of file diff --git a/packages/swift/AlgoKitTransact/Frameworks/algokit_transact.xcframework/macos-arm64_x86_64/libalgokit_transact_ffi-macos.a b/packages/swift/AlgoKitTransact/Frameworks/algokit_transact.xcframework/macos-arm64_x86_64/libalgokit_transact_ffi-macos.a index 7f8e43c7e..2be955623 100644 Binary files a/packages/swift/AlgoKitTransact/Frameworks/algokit_transact.xcframework/macos-arm64_x86_64/libalgokit_transact_ffi-macos.a and b/packages/swift/AlgoKitTransact/Frameworks/algokit_transact.xcframework/macos-arm64_x86_64/libalgokit_transact_ffi-macos.a differ diff --git a/packages/swift/AlgoKitTransact/Package.swift b/packages/swift/AlgoKitTransact/Package.swift index 94740469c..bf71171bb 100644 --- a/packages/swift/AlgoKitTransact/Package.swift +++ b/packages/swift/AlgoKitTransact/Package.swift @@ -4,37 +4,37 @@ import PackageDescription let package = Package( - name: "AlgoKitTransact", - products: [ - // Products define the executables and libraries a package produces, making them visible to other packages. - .library( - name: "AlgoKitTransact", - targets: ["AlgoKitTransact"]) - ], - dependencies: [ - .package(url: "https://github.com/pebble8888/ed25519swift.git", from: "1.2.7") - ], - targets: [ - // Targets are the basic building blocks of a package, defining a module or a test suite. - // Targets can depend on other targets in this package and products from dependencies. - .binaryTarget( - name: "algokit_transactFFI", - path: "Frameworks/algokit_transact.xcframework" - ), - .target( - name: "AlgoKitTransact", - dependencies: ["algokit_transactFFI"], - path: "Sources/AlgoKitTransact" - ), - .testTarget( - name: "AlgoKitTransactTests", - dependencies: [ - "AlgoKitTransact", - "ed25519swift", - ], - resources: [ - .process("Resources/test_data.json") - ] - ), - ] + name: "AlgoKitTransact", + products: [ + // Products define the executables and libraries a package produces, making them visible to other packages. + .library( + name: "AlgoKitTransact", + targets: ["AlgoKitTransact"]) + ], + dependencies: [ + .package(url: "https://github.com/pebble8888/ed25519swift.git", from: "1.2.7") + ], + targets: [ + // Targets are the basic building blocks of a package, defining a module or a test suite. + // Targets can depend on other targets in this package and products from dependencies. + .binaryTarget( + name: "algokit_transactFFI", + path: "Frameworks/algokit_transact.xcframework" + ), + .target( + name: "AlgoKitTransact", + dependencies: ["algokit_transactFFI"], + path: "Sources/AlgoKitTransact" + ), + .testTarget( + name: "AlgoKitTransactTests", + dependencies: [ + "AlgoKitTransact", + "ed25519swift", + ], + resources: [ + .process("Resources/test_data.json") + ] + ), + ] ) diff --git a/packages/swift/AlgoKitTransact/Sources/AlgoKitTransact/AlgoKitTransact.swift b/packages/swift/AlgoKitTransact/Sources/AlgoKitTransact/AlgoKitTransact.swift index 8fe29c207..92e86dfc8 100644 --- a/packages/swift/AlgoKitTransact/Sources/AlgoKitTransact/AlgoKitTransact.swift +++ b/packages/swift/AlgoKitTransact/Sources/AlgoKitTransact/AlgoKitTransact.swift @@ -281,7 +281,7 @@ private func makeRustCall( _ callback: (UnsafeMutablePointer) -> T, errorHandler: ((RustBuffer) throws -> E)? ) throws -> T { - uniffiEnsureInitialized() + uniffiEnsureAlgokitTransactFfiInitialized() var callStatus = RustCallStatus.init() let returnedVal = callback(&callStatus) try uniffiCheckCallStatus(callStatus: callStatus, errorHandler: errorHandler) @@ -352,9 +352,10 @@ private func uniffiTraitInterfaceCallWithError( callStatus.pointee.errorBuf = FfiConverterString.lower(String(describing: error)) } } -fileprivate class UniffiHandleMap { - private var map: [UInt64: T] = [:] +fileprivate final class UniffiHandleMap: @unchecked Sendable { + // All mutation happens with this lock held, which is why we implement @unchecked Sendable. private let lock = NSLock() + private var map: [UInt64: T] = [:] private var currentHandle: UInt64 = 1 func insert(obj: T) -> UInt64 { @@ -396,6 +397,38 @@ fileprivate class UniffiHandleMap { // Public interface members begin here. +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +fileprivate struct FfiConverterUInt8: FfiConverterPrimitive { + typealias FfiType = UInt8 + typealias SwiftType = UInt8 + + public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> UInt8 { + return try lift(readInt(&buf)) + } + + public static func write(_ value: UInt8, into buf: inout [UInt8]) { + writeInt(&buf, lower(value)) + } +} + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +fileprivate struct FfiConverterUInt32: FfiConverterPrimitive { + typealias FfiType = UInt32 + typealias SwiftType = UInt32 + + public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> UInt32 { + return try lift(readInt(&buf)) + } + + public static func write(_ value: SwiftType, into buf: inout [UInt8]) { + writeInt(&buf, lower(value)) + } +} + #if swift(>=5.8) @_documentation(visibility: private) #endif @@ -412,6 +445,30 @@ fileprivate struct FfiConverterUInt64: FfiConverterPrimitive { } } +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +fileprivate struct FfiConverterBool : FfiConverter { + typealias FfiType = Int8 + typealias SwiftType = Bool + + public static func lift(_ value: Int8) throws -> Bool { + return value != 0 + } + + public static func lower(_ value: Bool) -> Int8 { + return value ? 1 : 0 + } + + public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> Bool { + return try lift(readInt(&buf)) + } + + public static func write(_ value: Bool, into buf: inout [UInt8]) { + writeInt(&buf, lower(value)) + } +} + #if swift(>=5.8) @_documentation(visibility: private) #endif @@ -472,53 +529,269 @@ fileprivate struct FfiConverterData: FfiConverterRustBuffer { } -public struct Address { - public var address: String - public var pubKey: ByteBuf +/** + * Represents an app call transaction that interacts with Algorand Smart Contracts. + * + * App call transactions are used to create, update, delete, opt-in to, + * close out of, or clear state from Algorand applications (smart contracts). + */ +public struct AppCallTransactionFields { + /** + * ID of the app being called. + * + * Set this to 0 to indicate an app creation call. + */ + public var appId: UInt64 + /** + * Defines what additional actions occur with the transaction. + */ + public var onComplete: OnApplicationComplete + /** + * Logic executed for every app call transaction, except when + * on-completion is set to "clear". + * + * Approval programs may reject the transaction. + * Only required for app creation and update transactions. + */ + public var approvalProgram: Data? + /** + * Logic executed for app call transactions with on-completion set to "clear". + * + * Clear state programs cannot reject the transaction. + * Only required for app creation and update transactions. + */ + public var clearStateProgram: Data? + /** + * Holds the maximum number of global state values. + * + * Only required for app creation transactions. + * This cannot be changed after creation. + */ + public var globalStateSchema: StateSchema? + /** + * Holds the maximum number of local state values. + * + * Only required for app creation transactions. + * This cannot be changed after creation. + */ + public var localStateSchema: StateSchema? + /** + * Number of additional pages allocated to the app's approval + * and clear state programs. + * + * Each extra program page is 2048 bytes. The sum of approval program + * and clear state program may not exceed 2048*(1+extra_program_pages) bytes. + * Currently, the maximum value is 3. + * This cannot be changed after creation. + */ + public var extraProgramPages: UInt32? + /** + * Transaction specific arguments available in the app's + * approval program and clear state program. + */ + public var args: [Data]? + /** + * List of accounts in addition to the sender that may be accessed + * from the app's approval program and clear state program. + */ + public var accountReferences: [String]? + /** + * List of apps in addition to the current app that may be called + * from the app's approval program and clear state program. + */ + public var appReferences: [UInt64]? + /** + * Lists the assets whose parameters may be accessed by this app's + * approval program and clear state program. + * + * The access is read-only. + */ + public var assetReferences: [UInt64]? + /** + * The boxes that should be made available for the runtime of the program. + */ + public var boxReferences: [BoxReference]? // Default memberwise initializers are never public by default, so we // declare one manually. - public init(address: String, pubKey: ByteBuf) { - self.address = address - self.pubKey = pubKey - } -} - + public init( + /** + * ID of the app being called. + * + * Set this to 0 to indicate an app creation call. + */appId: UInt64, + /** + * Defines what additional actions occur with the transaction. + */onComplete: OnApplicationComplete, + /** + * Logic executed for every app call transaction, except when + * on-completion is set to "clear". + * + * Approval programs may reject the transaction. + * Only required for app creation and update transactions. + */approvalProgram: Data? = nil, + /** + * Logic executed for app call transactions with on-completion set to "clear". + * + * Clear state programs cannot reject the transaction. + * Only required for app creation and update transactions. + */clearStateProgram: Data? = nil, + /** + * Holds the maximum number of global state values. + * + * Only required for app creation transactions. + * This cannot be changed after creation. + */globalStateSchema: StateSchema? = nil, + /** + * Holds the maximum number of local state values. + * + * Only required for app creation transactions. + * This cannot be changed after creation. + */localStateSchema: StateSchema? = nil, + /** + * Number of additional pages allocated to the app's approval + * and clear state programs. + * + * Each extra program page is 2048 bytes. The sum of approval program + * and clear state program may not exceed 2048*(1+extra_program_pages) bytes. + * Currently, the maximum value is 3. + * This cannot be changed after creation. + */extraProgramPages: UInt32? = nil, + /** + * Transaction specific arguments available in the app's + * approval program and clear state program. + */args: [Data]? = nil, + /** + * List of accounts in addition to the sender that may be accessed + * from the app's approval program and clear state program. + */accountReferences: [String]? = nil, + /** + * List of apps in addition to the current app that may be called + * from the app's approval program and clear state program. + */appReferences: [UInt64]? = nil, + /** + * Lists the assets whose parameters may be accessed by this app's + * approval program and clear state program. + * + * The access is read-only. + */assetReferences: [UInt64]? = nil, + /** + * The boxes that should be made available for the runtime of the program. + */boxReferences: [BoxReference]? = nil) { + self.appId = appId + self.onComplete = onComplete + self.approvalProgram = approvalProgram + self.clearStateProgram = clearStateProgram + self.globalStateSchema = globalStateSchema + self.localStateSchema = localStateSchema + self.extraProgramPages = extraProgramPages + self.args = args + self.accountReferences = accountReferences + self.appReferences = appReferences + self.assetReferences = assetReferences + self.boxReferences = boxReferences + } +} + +#if compiler(>=6) +extension AppCallTransactionFields: Sendable {} +#endif -extension Address: Equatable, Hashable { - public static func ==(lhs: Address, rhs: Address) -> Bool { - if lhs.address != rhs.address { +extension AppCallTransactionFields: Equatable, Hashable { + public static func ==(lhs: AppCallTransactionFields, rhs: AppCallTransactionFields) -> Bool { + if lhs.appId != rhs.appId { return false } - if lhs.pubKey != rhs.pubKey { + if lhs.onComplete != rhs.onComplete { + return false + } + if lhs.approvalProgram != rhs.approvalProgram { + return false + } + if lhs.clearStateProgram != rhs.clearStateProgram { + return false + } + if lhs.globalStateSchema != rhs.globalStateSchema { + return false + } + if lhs.localStateSchema != rhs.localStateSchema { + return false + } + if lhs.extraProgramPages != rhs.extraProgramPages { + return false + } + if lhs.args != rhs.args { + return false + } + if lhs.accountReferences != rhs.accountReferences { + return false + } + if lhs.appReferences != rhs.appReferences { + return false + } + if lhs.assetReferences != rhs.assetReferences { + return false + } + if lhs.boxReferences != rhs.boxReferences { return false } return true } public func hash(into hasher: inout Hasher) { - hasher.combine(address) - hasher.combine(pubKey) + hasher.combine(appId) + hasher.combine(onComplete) + hasher.combine(approvalProgram) + hasher.combine(clearStateProgram) + hasher.combine(globalStateSchema) + hasher.combine(localStateSchema) + hasher.combine(extraProgramPages) + hasher.combine(args) + hasher.combine(accountReferences) + hasher.combine(appReferences) + hasher.combine(assetReferences) + hasher.combine(boxReferences) } } + #if swift(>=5.8) @_documentation(visibility: private) #endif -public struct FfiConverterTypeAddress: FfiConverterRustBuffer { - public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> Address { +public struct FfiConverterTypeAppCallTransactionFields: FfiConverterRustBuffer { + public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> AppCallTransactionFields { return - try Address( - address: FfiConverterString.read(from: &buf), - pubKey: FfiConverterTypeByteBuf.read(from: &buf) + try AppCallTransactionFields( + appId: FfiConverterUInt64.read(from: &buf), + onComplete: FfiConverterTypeOnApplicationComplete.read(from: &buf), + approvalProgram: FfiConverterOptionData.read(from: &buf), + clearStateProgram: FfiConverterOptionData.read(from: &buf), + globalStateSchema: FfiConverterOptionTypeStateSchema.read(from: &buf), + localStateSchema: FfiConverterOptionTypeStateSchema.read(from: &buf), + extraProgramPages: FfiConverterOptionUInt32.read(from: &buf), + args: FfiConverterOptionSequenceData.read(from: &buf), + accountReferences: FfiConverterOptionSequenceString.read(from: &buf), + appReferences: FfiConverterOptionSequenceUInt64.read(from: &buf), + assetReferences: FfiConverterOptionSequenceUInt64.read(from: &buf), + boxReferences: FfiConverterOptionSequenceTypeBoxReference.read(from: &buf) ) } - public static func write(_ value: Address, into buf: inout [UInt8]) { - FfiConverterString.write(value.address, into: &buf) - FfiConverterTypeByteBuf.write(value.pubKey, into: &buf) + public static func write(_ value: AppCallTransactionFields, into buf: inout [UInt8]) { + FfiConverterUInt64.write(value.appId, into: &buf) + FfiConverterTypeOnApplicationComplete.write(value.onComplete, into: &buf) + FfiConverterOptionData.write(value.approvalProgram, into: &buf) + FfiConverterOptionData.write(value.clearStateProgram, into: &buf) + FfiConverterOptionTypeStateSchema.write(value.globalStateSchema, into: &buf) + FfiConverterOptionTypeStateSchema.write(value.localStateSchema, into: &buf) + FfiConverterOptionUInt32.write(value.extraProgramPages, into: &buf) + FfiConverterOptionSequenceData.write(value.args, into: &buf) + FfiConverterOptionSequenceString.write(value.accountReferences, into: &buf) + FfiConverterOptionSequenceUInt64.write(value.appReferences, into: &buf) + FfiConverterOptionSequenceUInt64.write(value.assetReferences, into: &buf) + FfiConverterOptionSequenceTypeBoxReference.write(value.boxReferences, into: &buf) } } @@ -526,53 +799,306 @@ public struct FfiConverterTypeAddress: FfiConverterRustBuffer { #if swift(>=5.8) @_documentation(visibility: private) #endif -public func FfiConverterTypeAddress_lift(_ buf: RustBuffer) throws -> Address { - return try FfiConverterTypeAddress.lift(buf) +public func FfiConverterTypeAppCallTransactionFields_lift(_ buf: RustBuffer) throws -> AppCallTransactionFields { + return try FfiConverterTypeAppCallTransactionFields.lift(buf) } #if swift(>=5.8) @_documentation(visibility: private) #endif -public func FfiConverterTypeAddress_lower(_ value: Address) -> RustBuffer { - return FfiConverterTypeAddress.lower(value) +public func FfiConverterTypeAppCallTransactionFields_lower(_ value: AppCallTransactionFields) -> RustBuffer { + return FfiConverterTypeAppCallTransactionFields.lower(value) } -public struct AssetTransferTransactionFields { +/** + * Parameters to define an asset config transaction. + * + * For asset creation, the asset ID field must be 0. + * For asset reconfiguration, the asset ID field must be set. Only fields manager, reserve, freeze, and clawback can be set. + * For asset destroy, the asset ID field must be set, all other fields must not be set. + * + * **Note:** The manager, reserve, freeze, and clawback addresses + * are immutably empty if they are not set. If manager is not set then + * all fields are immutable from that point forward. + */ +public struct AssetConfigTransactionFields { + /** + * ID of the asset to operate on. + * + * For asset creation, this must be 0. + * For asset reconfiguration this is the ID of the existing asset to be reconfigured, + * For asset destroy this is the ID of the existing asset to be destroyed. + */ public var assetId: UInt64 - public var amount: UInt64 - public var receiver: Address - public var assetSender: Address? - public var closeRemainderTo: Address? + /** + * The total amount of the smallest divisible (decimal) unit to create. + * + * Required when creating a new asset. + * For example, if creating a asset with 2 decimals and wanting a total supply of 100 units, this value should be 10000. + * + * This field can only be specified upon asset creation. + */ + public var total: UInt64? + /** + * The amount of decimal places the asset should have. + * + * If unspecified then the asset will be in whole units (i.e. `0`). + * * If 0, the asset is not divisible; + * * If 1, the base unit of the asset is in tenths; + * * If 2, the base unit of the asset is in hundredths; + * * If 3, the base unit of the asset is in thousandths; + * + * and so on up to 19 decimal places. + * + * This field can only be specified upon asset creation. + */ + public var decimals: UInt32? + /** + * Whether the asset is frozen by default for all accounts. + * Defaults to `false`. + * + * If `true` then for anyone apart from the creator to hold the + * asset it needs to be unfrozen per account using an asset freeze + * transaction from the `freeze` account, which must be set on creation. + * + * This field can only be specified upon asset creation. + */ + public var defaultFrozen: Bool? + /** + * The optional name of the asset. + * + * Max size is 32 bytes. + * + * This field can only be specified upon asset creation. + */ + public var assetName: String? + /** + * The optional name of the unit of this asset (e.g. ticker name). + * + * Max size is 8 bytes. + * + * This field can only be specified upon asset creation. + */ + public var unitName: String? + /** + * Specifies an optional URL where more information about the asset can be retrieved (e.g. metadata). + * + * Max size is 96 bytes. + * + * This field can only be specified upon asset creation. + */ + public var url: String? + /** + * 32-byte hash of some metadata that is relevant to your asset and/or asset holders. + * + * The format of this metadata is up to the application. + * + * This field can only be specified upon asset creation. + */ + public var metadataHash: Data? + /** + * The address of the optional account that can manage the configuration of the asset and destroy it. + * + * The fields it can change are `manager`, `reserve`, `clawback`, and `freeze`. + * + * If not set or set to the Zero address the asset becomes permanently immutable. + */ + public var manager: String? + /** + * The address of the optional account that holds the reserve (uncirculated supply) units of the asset. + * + * This address has no specific authority in the protocol itself and is informational only. + * + * Some standards like [ARC-19](https://github.com/algorandfoundation/ARCs/blob/main/ARCs/arc-0019.md) + * rely on this field to hold meaningful data. + * + * It can be used in the case where you want to signal to holders of your asset that the uncirculated units + * of the asset reside in an account that is different from the default creator account. + * + * If not set or set to the Zero address is permanently empty. + */ + public var reserve: String? + /** + * The address of the optional account that can be used to freeze or unfreeze holdings of this asset for any account. + * + * If empty, freezing is not permitted. + * + * If not set or set to the Zero address is permanently empty. + */ + public var freeze: String? + /** + * The address of the optional account that can clawback holdings of this asset from any account. + * + * **This field should be used with caution** as the clawback account has the ability to **unconditionally take assets from any account**. + * + * If empty, clawback is not permitted. + * + * If not set or set to the Zero address is permanently empty. + */ + public var clawback: String? // Default memberwise initializers are never public by default, so we // declare one manually. - public init(assetId: UInt64, amount: UInt64, receiver: Address, assetSender: Address? = nil, closeRemainderTo: Address? = nil) { + public init( + /** + * ID of the asset to operate on. + * + * For asset creation, this must be 0. + * For asset reconfiguration this is the ID of the existing asset to be reconfigured, + * For asset destroy this is the ID of the existing asset to be destroyed. + */assetId: UInt64, + /** + * The total amount of the smallest divisible (decimal) unit to create. + * + * Required when creating a new asset. + * For example, if creating a asset with 2 decimals and wanting a total supply of 100 units, this value should be 10000. + * + * This field can only be specified upon asset creation. + */total: UInt64? = nil, + /** + * The amount of decimal places the asset should have. + * + * If unspecified then the asset will be in whole units (i.e. `0`). + * * If 0, the asset is not divisible; + * * If 1, the base unit of the asset is in tenths; + * * If 2, the base unit of the asset is in hundredths; + * * If 3, the base unit of the asset is in thousandths; + * + * and so on up to 19 decimal places. + * + * This field can only be specified upon asset creation. + */decimals: UInt32? = nil, + /** + * Whether the asset is frozen by default for all accounts. + * Defaults to `false`. + * + * If `true` then for anyone apart from the creator to hold the + * asset it needs to be unfrozen per account using an asset freeze + * transaction from the `freeze` account, which must be set on creation. + * + * This field can only be specified upon asset creation. + */defaultFrozen: Bool? = nil, + /** + * The optional name of the asset. + * + * Max size is 32 bytes. + * + * This field can only be specified upon asset creation. + */assetName: String? = nil, + /** + * The optional name of the unit of this asset (e.g. ticker name). + * + * Max size is 8 bytes. + * + * This field can only be specified upon asset creation. + */unitName: String? = nil, + /** + * Specifies an optional URL where more information about the asset can be retrieved (e.g. metadata). + * + * Max size is 96 bytes. + * + * This field can only be specified upon asset creation. + */url: String? = nil, + /** + * 32-byte hash of some metadata that is relevant to your asset and/or asset holders. + * + * The format of this metadata is up to the application. + * + * This field can only be specified upon asset creation. + */metadataHash: Data? = nil, + /** + * The address of the optional account that can manage the configuration of the asset and destroy it. + * + * The fields it can change are `manager`, `reserve`, `clawback`, and `freeze`. + * + * If not set or set to the Zero address the asset becomes permanently immutable. + */manager: String? = nil, + /** + * The address of the optional account that holds the reserve (uncirculated supply) units of the asset. + * + * This address has no specific authority in the protocol itself and is informational only. + * + * Some standards like [ARC-19](https://github.com/algorandfoundation/ARCs/blob/main/ARCs/arc-0019.md) + * rely on this field to hold meaningful data. + * + * It can be used in the case where you want to signal to holders of your asset that the uncirculated units + * of the asset reside in an account that is different from the default creator account. + * + * If not set or set to the Zero address is permanently empty. + */reserve: String? = nil, + /** + * The address of the optional account that can be used to freeze or unfreeze holdings of this asset for any account. + * + * If empty, freezing is not permitted. + * + * If not set or set to the Zero address is permanently empty. + */freeze: String? = nil, + /** + * The address of the optional account that can clawback holdings of this asset from any account. + * + * **This field should be used with caution** as the clawback account has the ability to **unconditionally take assets from any account**. + * + * If empty, clawback is not permitted. + * + * If not set or set to the Zero address is permanently empty. + */clawback: String? = nil) { self.assetId = assetId - self.amount = amount - self.receiver = receiver - self.assetSender = assetSender - self.closeRemainderTo = closeRemainderTo - } -} - + self.total = total + self.decimals = decimals + self.defaultFrozen = defaultFrozen + self.assetName = assetName + self.unitName = unitName + self.url = url + self.metadataHash = metadataHash + self.manager = manager + self.reserve = reserve + self.freeze = freeze + self.clawback = clawback + } +} + +#if compiler(>=6) +extension AssetConfigTransactionFields: Sendable {} +#endif -extension AssetTransferTransactionFields: Equatable, Hashable { - public static func ==(lhs: AssetTransferTransactionFields, rhs: AssetTransferTransactionFields) -> Bool { +extension AssetConfigTransactionFields: Equatable, Hashable { + public static func ==(lhs: AssetConfigTransactionFields, rhs: AssetConfigTransactionFields) -> Bool { if lhs.assetId != rhs.assetId { return false } - if lhs.amount != rhs.amount { + if lhs.total != rhs.total { return false } - if lhs.receiver != rhs.receiver { + if lhs.decimals != rhs.decimals { return false } - if lhs.assetSender != rhs.assetSender { + if lhs.defaultFrozen != rhs.defaultFrozen { return false } - if lhs.closeRemainderTo != rhs.closeRemainderTo { + if lhs.assetName != rhs.assetName { + return false + } + if lhs.unitName != rhs.unitName { + return false + } + if lhs.url != rhs.url { + return false + } + if lhs.metadataHash != rhs.metadataHash { + return false + } + if lhs.manager != rhs.manager { + return false + } + if lhs.reserve != rhs.reserve { + return false + } + if lhs.freeze != rhs.freeze { + return false + } + if lhs.clawback != rhs.clawback { return false } return true @@ -580,35 +1106,57 @@ extension AssetTransferTransactionFields: Equatable, Hashable { public func hash(into hasher: inout Hasher) { hasher.combine(assetId) - hasher.combine(amount) - hasher.combine(receiver) - hasher.combine(assetSender) - hasher.combine(closeRemainderTo) + hasher.combine(total) + hasher.combine(decimals) + hasher.combine(defaultFrozen) + hasher.combine(assetName) + hasher.combine(unitName) + hasher.combine(url) + hasher.combine(metadataHash) + hasher.combine(manager) + hasher.combine(reserve) + hasher.combine(freeze) + hasher.combine(clawback) } } + #if swift(>=5.8) @_documentation(visibility: private) #endif -public struct FfiConverterTypeAssetTransferTransactionFields: FfiConverterRustBuffer { - public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> AssetTransferTransactionFields { +public struct FfiConverterTypeAssetConfigTransactionFields: FfiConverterRustBuffer { + public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> AssetConfigTransactionFields { return - try AssetTransferTransactionFields( + try AssetConfigTransactionFields( assetId: FfiConverterUInt64.read(from: &buf), - amount: FfiConverterUInt64.read(from: &buf), - receiver: FfiConverterTypeAddress.read(from: &buf), - assetSender: FfiConverterOptionTypeAddress.read(from: &buf), - closeRemainderTo: FfiConverterOptionTypeAddress.read(from: &buf) + total: FfiConverterOptionUInt64.read(from: &buf), + decimals: FfiConverterOptionUInt32.read(from: &buf), + defaultFrozen: FfiConverterOptionBool.read(from: &buf), + assetName: FfiConverterOptionString.read(from: &buf), + unitName: FfiConverterOptionString.read(from: &buf), + url: FfiConverterOptionString.read(from: &buf), + metadataHash: FfiConverterOptionData.read(from: &buf), + manager: FfiConverterOptionString.read(from: &buf), + reserve: FfiConverterOptionString.read(from: &buf), + freeze: FfiConverterOptionString.read(from: &buf), + clawback: FfiConverterOptionString.read(from: &buf) ) } - public static func write(_ value: AssetTransferTransactionFields, into buf: inout [UInt8]) { + public static func write(_ value: AssetConfigTransactionFields, into buf: inout [UInt8]) { FfiConverterUInt64.write(value.assetId, into: &buf) - FfiConverterUInt64.write(value.amount, into: &buf) - FfiConverterTypeAddress.write(value.receiver, into: &buf) - FfiConverterOptionTypeAddress.write(value.assetSender, into: &buf) - FfiConverterOptionTypeAddress.write(value.closeRemainderTo, into: &buf) + FfiConverterOptionUInt64.write(value.total, into: &buf) + FfiConverterOptionUInt32.write(value.decimals, into: &buf) + FfiConverterOptionBool.write(value.defaultFrozen, into: &buf) + FfiConverterOptionString.write(value.assetName, into: &buf) + FfiConverterOptionString.write(value.unitName, into: &buf) + FfiConverterOptionString.write(value.url, into: &buf) + FfiConverterOptionData.write(value.metadataHash, into: &buf) + FfiConverterOptionString.write(value.manager, into: &buf) + FfiConverterOptionString.write(value.reserve, into: &buf) + FfiConverterOptionString.write(value.freeze, into: &buf) + FfiConverterOptionString.write(value.clawback, into: &buf) } } @@ -616,73 +1164,107 @@ public struct FfiConverterTypeAssetTransferTransactionFields: FfiConverterRustBu #if swift(>=5.8) @_documentation(visibility: private) #endif -public func FfiConverterTypeAssetTransferTransactionFields_lift(_ buf: RustBuffer) throws -> AssetTransferTransactionFields { - return try FfiConverterTypeAssetTransferTransactionFields.lift(buf) +public func FfiConverterTypeAssetConfigTransactionFields_lift(_ buf: RustBuffer) throws -> AssetConfigTransactionFields { + return try FfiConverterTypeAssetConfigTransactionFields.lift(buf) } #if swift(>=5.8) @_documentation(visibility: private) #endif -public func FfiConverterTypeAssetTransferTransactionFields_lower(_ value: AssetTransferTransactionFields) -> RustBuffer { - return FfiConverterTypeAssetTransferTransactionFields.lower(value) +public func FfiConverterTypeAssetConfigTransactionFields_lower(_ value: AssetConfigTransactionFields) -> RustBuffer { + return FfiConverterTypeAssetConfigTransactionFields.lower(value) } -public struct PaymentTransactionFields { - public var receiver: Address - public var amount: UInt64 - public var closeRemainderTo: Address? +/** + * Represents an asset freeze transaction that freezes or unfreezes asset holdings. + * + * Asset freeze transactions are used by the asset freeze account to control + * whether a specific account can transfer a particular asset. + */ +public struct AssetFreezeTransactionFields { + /** + * The ID of the asset being frozen/unfrozen. + */ + public var assetId: UInt64 + /** + * The target account whose asset holdings will be affected. + */ + public var freezeTarget: String + /** + * The new freeze status. + * + * `true` to freeze the asset holdings (prevent transfers), + * `false` to unfreeze the asset holdings (allow transfers). + */ + public var frozen: Bool // Default memberwise initializers are never public by default, so we // declare one manually. - public init(receiver: Address, amount: UInt64, closeRemainderTo: Address? = nil) { - self.receiver = receiver - self.amount = amount - self.closeRemainderTo = closeRemainderTo + public init( + /** + * The ID of the asset being frozen/unfrozen. + */assetId: UInt64, + /** + * The target account whose asset holdings will be affected. + */freezeTarget: String, + /** + * The new freeze status. + * + * `true` to freeze the asset holdings (prevent transfers), + * `false` to unfreeze the asset holdings (allow transfers). + */frozen: Bool) { + self.assetId = assetId + self.freezeTarget = freezeTarget + self.frozen = frozen } } +#if compiler(>=6) +extension AssetFreezeTransactionFields: Sendable {} +#endif -extension PaymentTransactionFields: Equatable, Hashable { - public static func ==(lhs: PaymentTransactionFields, rhs: PaymentTransactionFields) -> Bool { - if lhs.receiver != rhs.receiver { +extension AssetFreezeTransactionFields: Equatable, Hashable { + public static func ==(lhs: AssetFreezeTransactionFields, rhs: AssetFreezeTransactionFields) -> Bool { + if lhs.assetId != rhs.assetId { return false } - if lhs.amount != rhs.amount { + if lhs.freezeTarget != rhs.freezeTarget { return false } - if lhs.closeRemainderTo != rhs.closeRemainderTo { + if lhs.frozen != rhs.frozen { return false } return true } public func hash(into hasher: inout Hasher) { - hasher.combine(receiver) - hasher.combine(amount) - hasher.combine(closeRemainderTo) + hasher.combine(assetId) + hasher.combine(freezeTarget) + hasher.combine(frozen) } } + #if swift(>=5.8) @_documentation(visibility: private) #endif -public struct FfiConverterTypePaymentTransactionFields: FfiConverterRustBuffer { - public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> PaymentTransactionFields { +public struct FfiConverterTypeAssetFreezeTransactionFields: FfiConverterRustBuffer { + public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> AssetFreezeTransactionFields { return - try PaymentTransactionFields( - receiver: FfiConverterTypeAddress.read(from: &buf), - amount: FfiConverterUInt64.read(from: &buf), - closeRemainderTo: FfiConverterOptionTypeAddress.read(from: &buf) + try AssetFreezeTransactionFields( + assetId: FfiConverterUInt64.read(from: &buf), + freezeTarget: FfiConverterString.read(from: &buf), + frozen: FfiConverterBool.read(from: &buf) ) } - public static func write(_ value: PaymentTransactionFields, into buf: inout [UInt8]) { - FfiConverterTypeAddress.write(value.receiver, into: &buf) - FfiConverterUInt64.write(value.amount, into: &buf) - FfiConverterOptionTypeAddress.write(value.closeRemainderTo, into: &buf) + public static func write(_ value: AssetFreezeTransactionFields, into buf: inout [UInt8]) { + FfiConverterUInt64.write(value.assetId, into: &buf) + FfiConverterString.write(value.freezeTarget, into: &buf) + FfiConverterBool.write(value.frozen, into: &buf) } } @@ -690,38 +1272,993 @@ public struct FfiConverterTypePaymentTransactionFields: FfiConverterRustBuffer { #if swift(>=5.8) @_documentation(visibility: private) #endif -public func FfiConverterTypePaymentTransactionFields_lift(_ buf: RustBuffer) throws -> PaymentTransactionFields { - return try FfiConverterTypePaymentTransactionFields.lift(buf) +public func FfiConverterTypeAssetFreezeTransactionFields_lift(_ buf: RustBuffer) throws -> AssetFreezeTransactionFields { + return try FfiConverterTypeAssetFreezeTransactionFields.lift(buf) } #if swift(>=5.8) @_documentation(visibility: private) #endif -public func FfiConverterTypePaymentTransactionFields_lower(_ value: PaymentTransactionFields) -> RustBuffer { - return FfiConverterTypePaymentTransactionFields.lower(value) +public func FfiConverterTypeAssetFreezeTransactionFields_lower(_ value: AssetFreezeTransactionFields) -> RustBuffer { + return FfiConverterTypeAssetFreezeTransactionFields.lower(value) } -public struct Transaction { - /** - * The type of transaction - */ - public var transactionType: TransactionType - /** - * The sender of the transaction - */ - public var sender: Address - public var fee: UInt64 - public var firstValid: UInt64 - public var lastValid: UInt64 - public var genesisHash: ByteBuf? - public var genesisId: String? - public var note: ByteBuf? - public var rekeyTo: Address? - public var lease: ByteBuf? - public var group: ByteBuf? - public var payment: PaymentTransactionFields? - public var assetTransfer: AssetTransferTransactionFields? +public struct AssetTransferTransactionFields { + public var assetId: UInt64 + public var amount: UInt64 + public var receiver: String + public var assetSender: String? + public var closeRemainderTo: String? + + // Default memberwise initializers are never public by default, so we + // declare one manually. + public init(assetId: UInt64, amount: UInt64, receiver: String, assetSender: String? = nil, closeRemainderTo: String? = nil) { + self.assetId = assetId + self.amount = amount + self.receiver = receiver + self.assetSender = assetSender + self.closeRemainderTo = closeRemainderTo + } +} + +#if compiler(>=6) +extension AssetTransferTransactionFields: Sendable {} +#endif + + +extension AssetTransferTransactionFields: Equatable, Hashable { + public static func ==(lhs: AssetTransferTransactionFields, rhs: AssetTransferTransactionFields) -> Bool { + if lhs.assetId != rhs.assetId { + return false + } + if lhs.amount != rhs.amount { + return false + } + if lhs.receiver != rhs.receiver { + return false + } + if lhs.assetSender != rhs.assetSender { + return false + } + if lhs.closeRemainderTo != rhs.closeRemainderTo { + return false + } + return true + } + + public func hash(into hasher: inout Hasher) { + hasher.combine(assetId) + hasher.combine(amount) + hasher.combine(receiver) + hasher.combine(assetSender) + hasher.combine(closeRemainderTo) + } +} + + + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +public struct FfiConverterTypeAssetTransferTransactionFields: FfiConverterRustBuffer { + public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> AssetTransferTransactionFields { + return + try AssetTransferTransactionFields( + assetId: FfiConverterUInt64.read(from: &buf), + amount: FfiConverterUInt64.read(from: &buf), + receiver: FfiConverterString.read(from: &buf), + assetSender: FfiConverterOptionString.read(from: &buf), + closeRemainderTo: FfiConverterOptionString.read(from: &buf) + ) + } + + public static func write(_ value: AssetTransferTransactionFields, into buf: inout [UInt8]) { + FfiConverterUInt64.write(value.assetId, into: &buf) + FfiConverterUInt64.write(value.amount, into: &buf) + FfiConverterString.write(value.receiver, into: &buf) + FfiConverterOptionString.write(value.assetSender, into: &buf) + FfiConverterOptionString.write(value.closeRemainderTo, into: &buf) + } +} + + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +public func FfiConverterTypeAssetTransferTransactionFields_lift(_ buf: RustBuffer) throws -> AssetTransferTransactionFields { + return try FfiConverterTypeAssetTransferTransactionFields.lift(buf) +} + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +public func FfiConverterTypeAssetTransferTransactionFields_lower(_ value: AssetTransferTransactionFields) -> RustBuffer { + return FfiConverterTypeAssetTransferTransactionFields.lower(value) +} + + +/** + * Box reference for app call transactions. + * + * References a specific box that should be made available for the runtime + * of the program. + */ +public struct BoxReference { + /** + * App ID that owns the box. + * A value of 0 indicates the current app. + */ + public var appId: UInt64 + /** + * Name of the box. + */ + public var name: Data + + // Default memberwise initializers are never public by default, so we + // declare one manually. + public init( + /** + * App ID that owns the box. + * A value of 0 indicates the current app. + */appId: UInt64, + /** + * Name of the box. + */name: Data) { + self.appId = appId + self.name = name + } +} + +#if compiler(>=6) +extension BoxReference: Sendable {} +#endif + + +extension BoxReference: Equatable, Hashable { + public static func ==(lhs: BoxReference, rhs: BoxReference) -> Bool { + if lhs.appId != rhs.appId { + return false + } + if lhs.name != rhs.name { + return false + } + return true + } + + public func hash(into hasher: inout Hasher) { + hasher.combine(appId) + hasher.combine(name) + } +} + + + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +public struct FfiConverterTypeBoxReference: FfiConverterRustBuffer { + public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> BoxReference { + return + try BoxReference( + appId: FfiConverterUInt64.read(from: &buf), + name: FfiConverterData.read(from: &buf) + ) + } + + public static func write(_ value: BoxReference, into buf: inout [UInt8]) { + FfiConverterUInt64.write(value.appId, into: &buf) + FfiConverterData.write(value.name, into: &buf) + } +} + + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +public func FfiConverterTypeBoxReference_lift(_ buf: RustBuffer) throws -> BoxReference { + return try FfiConverterTypeBoxReference.lift(buf) +} + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +public func FfiConverterTypeBoxReference_lower(_ value: BoxReference) -> RustBuffer { + return FfiConverterTypeBoxReference.lower(value) +} + + +public struct FeeParams { + public var feePerByte: UInt64 + public var minFee: UInt64 + public var extraFee: UInt64? + public var maxFee: UInt64? + + // Default memberwise initializers are never public by default, so we + // declare one manually. + public init(feePerByte: UInt64, minFee: UInt64, extraFee: UInt64? = nil, maxFee: UInt64? = nil) { + self.feePerByte = feePerByte + self.minFee = minFee + self.extraFee = extraFee + self.maxFee = maxFee + } +} + +#if compiler(>=6) +extension FeeParams: Sendable {} +#endif + + +extension FeeParams: Equatable, Hashable { + public static func ==(lhs: FeeParams, rhs: FeeParams) -> Bool { + if lhs.feePerByte != rhs.feePerByte { + return false + } + if lhs.minFee != rhs.minFee { + return false + } + if lhs.extraFee != rhs.extraFee { + return false + } + if lhs.maxFee != rhs.maxFee { + return false + } + return true + } + + public func hash(into hasher: inout Hasher) { + hasher.combine(feePerByte) + hasher.combine(minFee) + hasher.combine(extraFee) + hasher.combine(maxFee) + } +} + + + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +public struct FfiConverterTypeFeeParams: FfiConverterRustBuffer { + public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> FeeParams { + return + try FeeParams( + feePerByte: FfiConverterUInt64.read(from: &buf), + minFee: FfiConverterUInt64.read(from: &buf), + extraFee: FfiConverterOptionUInt64.read(from: &buf), + maxFee: FfiConverterOptionUInt64.read(from: &buf) + ) + } + + public static func write(_ value: FeeParams, into buf: inout [UInt8]) { + FfiConverterUInt64.write(value.feePerByte, into: &buf) + FfiConverterUInt64.write(value.minFee, into: &buf) + FfiConverterOptionUInt64.write(value.extraFee, into: &buf) + FfiConverterOptionUInt64.write(value.maxFee, into: &buf) + } +} + + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +public func FfiConverterTypeFeeParams_lift(_ buf: RustBuffer) throws -> FeeParams { + return try FfiConverterTypeFeeParams.lift(buf) +} + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +public func FfiConverterTypeFeeParams_lower(_ value: FeeParams) -> RustBuffer { + return FfiConverterTypeFeeParams.lower(value) +} + + +public struct KeyPairAccount { + public var pubKey: Data + + // Default memberwise initializers are never public by default, so we + // declare one manually. + public init(pubKey: Data) { + self.pubKey = pubKey + } +} + +#if compiler(>=6) +extension KeyPairAccount: Sendable {} +#endif + + +extension KeyPairAccount: Equatable, Hashable { + public static func ==(lhs: KeyPairAccount, rhs: KeyPairAccount) -> Bool { + if lhs.pubKey != rhs.pubKey { + return false + } + return true + } + + public func hash(into hasher: inout Hasher) { + hasher.combine(pubKey) + } +} + + + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +public struct FfiConverterTypeKeyPairAccount: FfiConverterRustBuffer { + public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> KeyPairAccount { + return + try KeyPairAccount( + pubKey: FfiConverterData.read(from: &buf) + ) + } + + public static func write(_ value: KeyPairAccount, into buf: inout [UInt8]) { + FfiConverterData.write(value.pubKey, into: &buf) + } +} + + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +public func FfiConverterTypeKeyPairAccount_lift(_ buf: RustBuffer) throws -> KeyPairAccount { + return try FfiConverterTypeKeyPairAccount.lift(buf) +} + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +public func FfiConverterTypeKeyPairAccount_lower(_ value: KeyPairAccount) -> RustBuffer { + return FfiConverterTypeKeyPairAccount.lower(value) +} + + +public struct KeyRegistrationTransactionFields { + /** + * Root participation public key (32 bytes) + */ + public var voteKey: Data? + /** + * VRF public key (32 bytes) + */ + public var selectionKey: Data? + /** + * State proof key (64 bytes) + */ + public var stateProofKey: Data? + /** + * First round for which the participation key is valid + */ + public var voteFirst: UInt64? + /** + * Last round for which the participation key is valid + */ + public var voteLast: UInt64? + /** + * Key dilution for the 2-level participation key + */ + public var voteKeyDilution: UInt64? + /** + * Mark account as non-reward earning + */ + public var nonParticipation: Bool? + + // Default memberwise initializers are never public by default, so we + // declare one manually. + public init( + /** + * Root participation public key (32 bytes) + */voteKey: Data? = nil, + /** + * VRF public key (32 bytes) + */selectionKey: Data? = nil, + /** + * State proof key (64 bytes) + */stateProofKey: Data? = nil, + /** + * First round for which the participation key is valid + */voteFirst: UInt64? = nil, + /** + * Last round for which the participation key is valid + */voteLast: UInt64? = nil, + /** + * Key dilution for the 2-level participation key + */voteKeyDilution: UInt64? = nil, + /** + * Mark account as non-reward earning + */nonParticipation: Bool? = nil) { + self.voteKey = voteKey + self.selectionKey = selectionKey + self.stateProofKey = stateProofKey + self.voteFirst = voteFirst + self.voteLast = voteLast + self.voteKeyDilution = voteKeyDilution + self.nonParticipation = nonParticipation + } +} + +#if compiler(>=6) +extension KeyRegistrationTransactionFields: Sendable {} +#endif + + +extension KeyRegistrationTransactionFields: Equatable, Hashable { + public static func ==(lhs: KeyRegistrationTransactionFields, rhs: KeyRegistrationTransactionFields) -> Bool { + if lhs.voteKey != rhs.voteKey { + return false + } + if lhs.selectionKey != rhs.selectionKey { + return false + } + if lhs.stateProofKey != rhs.stateProofKey { + return false + } + if lhs.voteFirst != rhs.voteFirst { + return false + } + if lhs.voteLast != rhs.voteLast { + return false + } + if lhs.voteKeyDilution != rhs.voteKeyDilution { + return false + } + if lhs.nonParticipation != rhs.nonParticipation { + return false + } + return true + } + + public func hash(into hasher: inout Hasher) { + hasher.combine(voteKey) + hasher.combine(selectionKey) + hasher.combine(stateProofKey) + hasher.combine(voteFirst) + hasher.combine(voteLast) + hasher.combine(voteKeyDilution) + hasher.combine(nonParticipation) + } +} + + + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +public struct FfiConverterTypeKeyRegistrationTransactionFields: FfiConverterRustBuffer { + public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> KeyRegistrationTransactionFields { + return + try KeyRegistrationTransactionFields( + voteKey: FfiConverterOptionData.read(from: &buf), + selectionKey: FfiConverterOptionData.read(from: &buf), + stateProofKey: FfiConverterOptionData.read(from: &buf), + voteFirst: FfiConverterOptionUInt64.read(from: &buf), + voteLast: FfiConverterOptionUInt64.read(from: &buf), + voteKeyDilution: FfiConverterOptionUInt64.read(from: &buf), + nonParticipation: FfiConverterOptionBool.read(from: &buf) + ) + } + + public static func write(_ value: KeyRegistrationTransactionFields, into buf: inout [UInt8]) { + FfiConverterOptionData.write(value.voteKey, into: &buf) + FfiConverterOptionData.write(value.selectionKey, into: &buf) + FfiConverterOptionData.write(value.stateProofKey, into: &buf) + FfiConverterOptionUInt64.write(value.voteFirst, into: &buf) + FfiConverterOptionUInt64.write(value.voteLast, into: &buf) + FfiConverterOptionUInt64.write(value.voteKeyDilution, into: &buf) + FfiConverterOptionBool.write(value.nonParticipation, into: &buf) + } +} + + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +public func FfiConverterTypeKeyRegistrationTransactionFields_lift(_ buf: RustBuffer) throws -> KeyRegistrationTransactionFields { + return try FfiConverterTypeKeyRegistrationTransactionFields.lift(buf) +} + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +public func FfiConverterTypeKeyRegistrationTransactionFields_lower(_ value: KeyRegistrationTransactionFields) -> RustBuffer { + return FfiConverterTypeKeyRegistrationTransactionFields.lower(value) +} + + +/** + * Representation of an Algorand multisignature signature. + */ +public struct MultisigSignature { + /** + * Multisig version. + */ + public var version: UInt8 + /** + * Minimum number of signatures required. + */ + public var threshold: UInt8 + /** + * List of subsignatures for each participant. + */ + public var subsignatures: [MultisigSubsignature] + + // Default memberwise initializers are never public by default, so we + // declare one manually. + public init( + /** + * Multisig version. + */version: UInt8, + /** + * Minimum number of signatures required. + */threshold: UInt8, + /** + * List of subsignatures for each participant. + */subsignatures: [MultisigSubsignature]) { + self.version = version + self.threshold = threshold + self.subsignatures = subsignatures + } +} + +#if compiler(>=6) +extension MultisigSignature: Sendable {} +#endif + + +extension MultisigSignature: Equatable, Hashable { + public static func ==(lhs: MultisigSignature, rhs: MultisigSignature) -> Bool { + if lhs.version != rhs.version { + return false + } + if lhs.threshold != rhs.threshold { + return false + } + if lhs.subsignatures != rhs.subsignatures { + return false + } + return true + } + + public func hash(into hasher: inout Hasher) { + hasher.combine(version) + hasher.combine(threshold) + hasher.combine(subsignatures) + } +} + + + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +public struct FfiConverterTypeMultisigSignature: FfiConverterRustBuffer { + public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> MultisigSignature { + return + try MultisigSignature( + version: FfiConverterUInt8.read(from: &buf), + threshold: FfiConverterUInt8.read(from: &buf), + subsignatures: FfiConverterSequenceTypeMultisigSubsignature.read(from: &buf) + ) + } + + public static func write(_ value: MultisigSignature, into buf: inout [UInt8]) { + FfiConverterUInt8.write(value.version, into: &buf) + FfiConverterUInt8.write(value.threshold, into: &buf) + FfiConverterSequenceTypeMultisigSubsignature.write(value.subsignatures, into: &buf) + } +} + + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +public func FfiConverterTypeMultisigSignature_lift(_ buf: RustBuffer) throws -> MultisigSignature { + return try FfiConverterTypeMultisigSignature.lift(buf) +} + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +public func FfiConverterTypeMultisigSignature_lower(_ value: MultisigSignature) -> RustBuffer { + return FfiConverterTypeMultisigSignature.lower(value) +} + + +/** + * Representation of a single subsignature in a multisignature transaction. + * + * Each subsignature contains the participant's address and an optional signature. + */ +public struct MultisigSubsignature { + /** + * Address of the participant. + */ + public var address: String + /** + * Optional signature bytes for the participant. + */ + public var signature: Data? + + // Default memberwise initializers are never public by default, so we + // declare one manually. + public init( + /** + * Address of the participant. + */address: String, + /** + * Optional signature bytes for the participant. + */signature: Data? = nil) { + self.address = address + self.signature = signature + } +} + +#if compiler(>=6) +extension MultisigSubsignature: Sendable {} +#endif + + +extension MultisigSubsignature: Equatable, Hashable { + public static func ==(lhs: MultisigSubsignature, rhs: MultisigSubsignature) -> Bool { + if lhs.address != rhs.address { + return false + } + if lhs.signature != rhs.signature { + return false + } + return true + } + + public func hash(into hasher: inout Hasher) { + hasher.combine(address) + hasher.combine(signature) + } +} + + + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +public struct FfiConverterTypeMultisigSubsignature: FfiConverterRustBuffer { + public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> MultisigSubsignature { + return + try MultisigSubsignature( + address: FfiConverterString.read(from: &buf), + signature: FfiConverterOptionData.read(from: &buf) + ) + } + + public static func write(_ value: MultisigSubsignature, into buf: inout [UInt8]) { + FfiConverterString.write(value.address, into: &buf) + FfiConverterOptionData.write(value.signature, into: &buf) + } +} + + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +public func FfiConverterTypeMultisigSubsignature_lift(_ buf: RustBuffer) throws -> MultisigSubsignature { + return try FfiConverterTypeMultisigSubsignature.lift(buf) +} + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +public func FfiConverterTypeMultisigSubsignature_lower(_ value: MultisigSubsignature) -> RustBuffer { + return FfiConverterTypeMultisigSubsignature.lower(value) +} + + +public struct PaymentTransactionFields { + public var receiver: String + public var amount: UInt64 + public var closeRemainderTo: String? + + // Default memberwise initializers are never public by default, so we + // declare one manually. + public init(receiver: String, amount: UInt64, closeRemainderTo: String? = nil) { + self.receiver = receiver + self.amount = amount + self.closeRemainderTo = closeRemainderTo + } +} + +#if compiler(>=6) +extension PaymentTransactionFields: Sendable {} +#endif + + +extension PaymentTransactionFields: Equatable, Hashable { + public static func ==(lhs: PaymentTransactionFields, rhs: PaymentTransactionFields) -> Bool { + if lhs.receiver != rhs.receiver { + return false + } + if lhs.amount != rhs.amount { + return false + } + if lhs.closeRemainderTo != rhs.closeRemainderTo { + return false + } + return true + } + + public func hash(into hasher: inout Hasher) { + hasher.combine(receiver) + hasher.combine(amount) + hasher.combine(closeRemainderTo) + } +} + + + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +public struct FfiConverterTypePaymentTransactionFields: FfiConverterRustBuffer { + public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> PaymentTransactionFields { + return + try PaymentTransactionFields( + receiver: FfiConverterString.read(from: &buf), + amount: FfiConverterUInt64.read(from: &buf), + closeRemainderTo: FfiConverterOptionString.read(from: &buf) + ) + } + + public static func write(_ value: PaymentTransactionFields, into buf: inout [UInt8]) { + FfiConverterString.write(value.receiver, into: &buf) + FfiConverterUInt64.write(value.amount, into: &buf) + FfiConverterOptionString.write(value.closeRemainderTo, into: &buf) + } +} + + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +public func FfiConverterTypePaymentTransactionFields_lift(_ buf: RustBuffer) throws -> PaymentTransactionFields { + return try FfiConverterTypePaymentTransactionFields.lift(buf) +} + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +public func FfiConverterTypePaymentTransactionFields_lower(_ value: PaymentTransactionFields) -> RustBuffer { + return FfiConverterTypePaymentTransactionFields.lower(value) +} + + +public struct SignedTransaction { + /** + * The transaction that has been signed. + */ + public var transaction: Transaction + /** + * Optional Ed25519 signature authorizing the transaction. + */ + public var signature: Data? + /** + * Optional auth address applicable if the transaction sender is a rekeyed account. + */ + public var authAddress: String? + /** + * Optional multisig signature if the transaction is a multisig transaction. + */ + public var multisignature: MultisigSignature? + + // Default memberwise initializers are never public by default, so we + // declare one manually. + public init( + /** + * The transaction that has been signed. + */transaction: Transaction, + /** + * Optional Ed25519 signature authorizing the transaction. + */signature: Data? = nil, + /** + * Optional auth address applicable if the transaction sender is a rekeyed account. + */authAddress: String? = nil, + /** + * Optional multisig signature if the transaction is a multisig transaction. + */multisignature: MultisigSignature? = nil) { + self.transaction = transaction + self.signature = signature + self.authAddress = authAddress + self.multisignature = multisignature + } +} + +#if compiler(>=6) +extension SignedTransaction: Sendable {} +#endif + + +extension SignedTransaction: Equatable, Hashable { + public static func ==(lhs: SignedTransaction, rhs: SignedTransaction) -> Bool { + if lhs.transaction != rhs.transaction { + return false + } + if lhs.signature != rhs.signature { + return false + } + if lhs.authAddress != rhs.authAddress { + return false + } + if lhs.multisignature != rhs.multisignature { + return false + } + return true + } + + public func hash(into hasher: inout Hasher) { + hasher.combine(transaction) + hasher.combine(signature) + hasher.combine(authAddress) + hasher.combine(multisignature) + } +} + + + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +public struct FfiConverterTypeSignedTransaction: FfiConverterRustBuffer { + public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> SignedTransaction { + return + try SignedTransaction( + transaction: FfiConverterTypeTransaction.read(from: &buf), + signature: FfiConverterOptionData.read(from: &buf), + authAddress: FfiConverterOptionString.read(from: &buf), + multisignature: FfiConverterOptionTypeMultisigSignature.read(from: &buf) + ) + } + + public static func write(_ value: SignedTransaction, into buf: inout [UInt8]) { + FfiConverterTypeTransaction.write(value.transaction, into: &buf) + FfiConverterOptionData.write(value.signature, into: &buf) + FfiConverterOptionString.write(value.authAddress, into: &buf) + FfiConverterOptionTypeMultisigSignature.write(value.multisignature, into: &buf) + } +} + + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +public func FfiConverterTypeSignedTransaction_lift(_ buf: RustBuffer) throws -> SignedTransaction { + return try FfiConverterTypeSignedTransaction.lift(buf) +} + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +public func FfiConverterTypeSignedTransaction_lower(_ value: SignedTransaction) -> RustBuffer { + return FfiConverterTypeSignedTransaction.lower(value) +} + + +/** + * Schema for app state storage. + * + * Defines the maximum number of values that may be stored in app + * key/value storage for both global and local state. + */ +public struct StateSchema { + /** + * Maximum number of integer values that may be stored. + */ + public var numUints: UInt32 + /** + * Maximum number of byte slice values that may be stored. + */ + public var numByteSlices: UInt32 + + // Default memberwise initializers are never public by default, so we + // declare one manually. + public init( + /** + * Maximum number of integer values that may be stored. + */numUints: UInt32, + /** + * Maximum number of byte slice values that may be stored. + */numByteSlices: UInt32) { + self.numUints = numUints + self.numByteSlices = numByteSlices + } +} + +#if compiler(>=6) +extension StateSchema: Sendable {} +#endif + + +extension StateSchema: Equatable, Hashable { + public static func ==(lhs: StateSchema, rhs: StateSchema) -> Bool { + if lhs.numUints != rhs.numUints { + return false + } + if lhs.numByteSlices != rhs.numByteSlices { + return false + } + return true + } + + public func hash(into hasher: inout Hasher) { + hasher.combine(numUints) + hasher.combine(numByteSlices) + } +} + + + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +public struct FfiConverterTypeStateSchema: FfiConverterRustBuffer { + public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> StateSchema { + return + try StateSchema( + numUints: FfiConverterUInt32.read(from: &buf), + numByteSlices: FfiConverterUInt32.read(from: &buf) + ) + } + + public static func write(_ value: StateSchema, into buf: inout [UInt8]) { + FfiConverterUInt32.write(value.numUints, into: &buf) + FfiConverterUInt32.write(value.numByteSlices, into: &buf) + } +} + + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +public func FfiConverterTypeStateSchema_lift(_ buf: RustBuffer) throws -> StateSchema { + return try FfiConverterTypeStateSchema.lift(buf) +} + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +public func FfiConverterTypeStateSchema_lower(_ value: StateSchema) -> RustBuffer { + return FfiConverterTypeStateSchema.lower(value) +} + + +public struct Transaction { + /** + * The type of transaction + */ + public var transactionType: TransactionType + /** + * The sender of the transaction + */ + public var sender: String + /** + * Optional transaction fee in microALGO. + * + * If not set, the fee will be interpreted as 0 by the network. + */ + public var fee: UInt64? + public var firstValid: UInt64 + public var lastValid: UInt64 + public var genesisHash: Data? + public var genesisId: String? + public var note: Data? + public var rekeyTo: String? + public var lease: Data? + public var group: Data? + public var payment: PaymentTransactionFields? + public var assetTransfer: AssetTransferTransactionFields? + public var assetConfig: AssetConfigTransactionFields? + public var appCall: AppCallTransactionFields? + public var keyRegistration: KeyRegistrationTransactionFields? + public var assetFreeze: AssetFreezeTransactionFields? // Default memberwise initializers are never public by default, so we // declare one manually. @@ -731,7 +2268,12 @@ public struct Transaction { */transactionType: TransactionType, /** * The sender of the transaction - */sender: Address, fee: UInt64, firstValid: UInt64, lastValid: UInt64, genesisHash: ByteBuf?, genesisId: String?, note: ByteBuf? = nil, rekeyTo: Address? = nil, lease: ByteBuf? = nil, group: ByteBuf? = nil, payment: PaymentTransactionFields? = nil, assetTransfer: AssetTransferTransactionFields? = nil) { + */sender: String, + /** + * Optional transaction fee in microALGO. + * + * If not set, the fee will be interpreted as 0 by the network. + */fee: UInt64? = nil, firstValid: UInt64, lastValid: UInt64, genesisHash: Data?, genesisId: String?, note: Data? = nil, rekeyTo: String? = nil, lease: Data? = nil, group: Data? = nil, payment: PaymentTransactionFields? = nil, assetTransfer: AssetTransferTransactionFields? = nil, assetConfig: AssetConfigTransactionFields? = nil, appCall: AppCallTransactionFields? = nil, keyRegistration: KeyRegistrationTransactionFields? = nil, assetFreeze: AssetFreezeTransactionFields? = nil) { self.transactionType = transactionType self.sender = sender self.fee = fee @@ -745,9 +2287,16 @@ public struct Transaction { self.group = group self.payment = payment self.assetTransfer = assetTransfer + self.assetConfig = assetConfig + self.appCall = appCall + self.keyRegistration = keyRegistration + self.assetFreeze = assetFreeze } } +#if compiler(>=6) +extension Transaction: Sendable {} +#endif extension Transaction: Equatable, Hashable { @@ -791,6 +2340,18 @@ extension Transaction: Equatable, Hashable { if lhs.assetTransfer != rhs.assetTransfer { return false } + if lhs.assetConfig != rhs.assetConfig { + return false + } + if lhs.appCall != rhs.appCall { + return false + } + if lhs.keyRegistration != rhs.keyRegistration { + return false + } + if lhs.assetFreeze != rhs.assetFreeze { + return false + } return true } @@ -808,10 +2369,15 @@ extension Transaction: Equatable, Hashable { hasher.combine(group) hasher.combine(payment) hasher.combine(assetTransfer) + hasher.combine(assetConfig) + hasher.combine(appCall) + hasher.combine(keyRegistration) + hasher.combine(assetFreeze) } } + #if swift(>=5.8) @_documentation(visibility: private) #endif @@ -820,35 +2386,43 @@ public struct FfiConverterTypeTransaction: FfiConverterRustBuffer { return try Transaction( transactionType: FfiConverterTypeTransactionType.read(from: &buf), - sender: FfiConverterTypeAddress.read(from: &buf), - fee: FfiConverterUInt64.read(from: &buf), + sender: FfiConverterString.read(from: &buf), + fee: FfiConverterOptionUInt64.read(from: &buf), firstValid: FfiConverterUInt64.read(from: &buf), lastValid: FfiConverterUInt64.read(from: &buf), - genesisHash: FfiConverterOptionTypeByteBuf.read(from: &buf), + genesisHash: FfiConverterOptionData.read(from: &buf), genesisId: FfiConverterOptionString.read(from: &buf), - note: FfiConverterOptionTypeByteBuf.read(from: &buf), - rekeyTo: FfiConverterOptionTypeAddress.read(from: &buf), - lease: FfiConverterOptionTypeByteBuf.read(from: &buf), - group: FfiConverterOptionTypeByteBuf.read(from: &buf), + note: FfiConverterOptionData.read(from: &buf), + rekeyTo: FfiConverterOptionString.read(from: &buf), + lease: FfiConverterOptionData.read(from: &buf), + group: FfiConverterOptionData.read(from: &buf), payment: FfiConverterOptionTypePaymentTransactionFields.read(from: &buf), - assetTransfer: FfiConverterOptionTypeAssetTransferTransactionFields.read(from: &buf) + assetTransfer: FfiConverterOptionTypeAssetTransferTransactionFields.read(from: &buf), + assetConfig: FfiConverterOptionTypeAssetConfigTransactionFields.read(from: &buf), + appCall: FfiConverterOptionTypeAppCallTransactionFields.read(from: &buf), + keyRegistration: FfiConverterOptionTypeKeyRegistrationTransactionFields.read(from: &buf), + assetFreeze: FfiConverterOptionTypeAssetFreezeTransactionFields.read(from: &buf) ) } public static func write(_ value: Transaction, into buf: inout [UInt8]) { FfiConverterTypeTransactionType.write(value.transactionType, into: &buf) - FfiConverterTypeAddress.write(value.sender, into: &buf) - FfiConverterUInt64.write(value.fee, into: &buf) + FfiConverterString.write(value.sender, into: &buf) + FfiConverterOptionUInt64.write(value.fee, into: &buf) FfiConverterUInt64.write(value.firstValid, into: &buf) FfiConverterUInt64.write(value.lastValid, into: &buf) - FfiConverterOptionTypeByteBuf.write(value.genesisHash, into: &buf) + FfiConverterOptionData.write(value.genesisHash, into: &buf) FfiConverterOptionString.write(value.genesisId, into: &buf) - FfiConverterOptionTypeByteBuf.write(value.note, into: &buf) - FfiConverterOptionTypeAddress.write(value.rekeyTo, into: &buf) - FfiConverterOptionTypeByteBuf.write(value.lease, into: &buf) - FfiConverterOptionTypeByteBuf.write(value.group, into: &buf) + FfiConverterOptionData.write(value.note, into: &buf) + FfiConverterOptionString.write(value.rekeyTo, into: &buf) + FfiConverterOptionData.write(value.lease, into: &buf) + FfiConverterOptionData.write(value.group, into: &buf) FfiConverterOptionTypePaymentTransactionFields.write(value.payment, into: &buf) FfiConverterOptionTypeAssetTransferTransactionFields.write(value.assetTransfer, into: &buf) + FfiConverterOptionTypeAssetConfigTransactionFields.write(value.assetConfig, into: &buf) + FfiConverterOptionTypeAppCallTransactionFields.write(value.appCall, into: &buf) + FfiConverterOptionTypeKeyRegistrationTransactionFields.write(value.keyRegistration, into: &buf) + FfiConverterOptionTypeAssetFreezeTransactionFields.write(value.assetFreeze, into: &buf) } } @@ -868,13 +2442,17 @@ public func FfiConverterTypeTransaction_lower(_ value: Transaction) -> RustBuffe } -public enum AlgoKitTransactError { +public enum AlgoKitTransactError: Swift.Error { - case EncodingError(String + case EncodingError(errorMsg: String + ) + case DecodingError(errorMsg: String ) - case DecodingError(String + case InputError(errorMsg: String + ) + case MsgPackError(errorMsg: String ) } @@ -893,10 +2471,16 @@ public struct FfiConverterTypeAlgoKitTransactError: FfiConverterRustBuffer { case 1: return .EncodingError( - try FfiConverterString.read(from: &buf) + errorMsg: try FfiConverterString.read(from: &buf) ) case 2: return .DecodingError( - try FfiConverterString.read(from: &buf) + errorMsg: try FfiConverterString.read(from: &buf) + ) + case 3: return .InputError( + errorMsg: try FfiConverterString.read(from: &buf) + ) + case 4: return .MsgPackError( + errorMsg: try FfiConverterString.read(from: &buf) ) default: throw UniffiInternalError.unexpectedEnumCase @@ -910,126 +2494,300 @@ public struct FfiConverterTypeAlgoKitTransactError: FfiConverterRustBuffer { - case let .EncodingError(v1): + case let .EncodingError(errorMsg): writeInt(&buf, Int32(1)) - FfiConverterString.write(v1, into: &buf) + FfiConverterString.write(errorMsg, into: &buf) - case let .DecodingError(v1): + case let .DecodingError(errorMsg): writeInt(&buf, Int32(2)) - FfiConverterString.write(v1, into: &buf) + FfiConverterString.write(errorMsg, into: &buf) + + + case let .InputError(errorMsg): + writeInt(&buf, Int32(3)) + FfiConverterString.write(errorMsg, into: &buf) + + + case let .MsgPackError(errorMsg): + writeInt(&buf, Int32(4)) + FfiConverterString.write(errorMsg, into: &buf) } } } -extension AlgoKitTransactError: Equatable, Hashable {} +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +public func FfiConverterTypeAlgoKitTransactError_lift(_ buf: RustBuffer) throws -> AlgoKitTransactError { + return try FfiConverterTypeAlgoKitTransactError.lift(buf) +} + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +public func FfiConverterTypeAlgoKitTransactError_lower(_ value: AlgoKitTransactError) -> RustBuffer { + return FfiConverterTypeAlgoKitTransactError.lower(value) +} + + +extension AlgoKitTransactError: Equatable, Hashable {} + + + + +extension AlgoKitTransactError: Foundation.LocalizedError { + public var errorDescription: String? { + String(reflecting: self) + } +} + + + + +// Note that we don't yet support `indirect` for enums. +// See https://github.com/mozilla/uniffi-rs/issues/396 for further discussion. +/** + * Enum containing all constants used in this crate. + */ + +public enum AlgorandConstant { + + /** + * Length of hash digests (32) + */ + case hashLength + /** + * Length of the checksum used in Algorand addresses (4) + */ + case checksumLength + /** + * Length of a base32-encoded Algorand address (58) + */ + case addressLength + /** + * Length of an Algorand public key in bytes (32) + */ + case publicKeyLength + /** + * Length of an Algorand secret key in bytes (32) + */ + case secretKeyLength + /** + * Length of an Algorand signature in bytes (64) + */ + case signatureLength + /** + * Increment in the encoded byte size when a signature is attached to a transaction (75) + */ + case signatureEncodingIncrLength + /** + * The maximum number of transactions in a group (16) + */ + case maxTxGroupSize +} + + +#if compiler(>=6) +extension AlgorandConstant: Sendable {} +#endif + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +public struct FfiConverterTypeAlgorandConstant: FfiConverterRustBuffer { + typealias SwiftType = AlgorandConstant + + public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> AlgorandConstant { + let variant: Int32 = try readInt(&buf) + switch variant { + + case 1: return .hashLength + + case 2: return .checksumLength + + case 3: return .addressLength + + case 4: return .publicKeyLength + + case 5: return .secretKeyLength + + case 6: return .signatureLength + + case 7: return .signatureEncodingIncrLength + + case 8: return .maxTxGroupSize + + default: throw UniffiInternalError.unexpectedEnumCase + } + } + + public static func write(_ value: AlgorandConstant, into buf: inout [UInt8]) { + switch value { + + + case .hashLength: + writeInt(&buf, Int32(1)) + + + case .checksumLength: + writeInt(&buf, Int32(2)) + + + case .addressLength: + writeInt(&buf, Int32(3)) + + + case .publicKeyLength: + writeInt(&buf, Int32(4)) + + + case .secretKeyLength: + writeInt(&buf, Int32(5)) + + + case .signatureLength: + writeInt(&buf, Int32(6)) + + + case .signatureEncodingIncrLength: + writeInt(&buf, Int32(7)) + + + case .maxTxGroupSize: + writeInt(&buf, Int32(8)) + + } + } +} + + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +public func FfiConverterTypeAlgorandConstant_lift(_ buf: RustBuffer) throws -> AlgorandConstant { + return try FfiConverterTypeAlgorandConstant.lift(buf) +} + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +public func FfiConverterTypeAlgorandConstant_lower(_ value: AlgorandConstant) -> RustBuffer { + return FfiConverterTypeAlgorandConstant.lower(value) +} + + +extension AlgorandConstant: Equatable, Hashable {} + + + + -extension AlgoKitTransactError: Foundation.LocalizedError { - public var errorDescription: String? { - String(reflecting: self) - } -} // Note that we don't yet support `indirect` for enums. // See https://github.com/mozilla/uniffi-rs/issues/396 for further discussion. /** - * Enum containing all constants used in this crate. + * On-completion actions for app transactions. + * + * These values define what additional actions occur with the transaction. */ -public enum AlgorandConstant { +public enum OnApplicationComplete { /** - * Length of hash digests (32) - */ - case hashLength - /** - * Length of the checksum used in Algorand addresses (4) + * NoOp indicates that an app transaction will simply call its + * approval program without any additional action. */ - case checksumLength + case noOp /** - * Length of a base32-encoded Algorand address (58) + * OptIn indicates that an app transaction will allocate some + * local state for the app in the sender's account. */ - case addressLength + case optIn /** - * Length of an Algorand public key in bytes (32) + * CloseOut indicates that an app transaction will deallocate + * some local state for the app from the user's account. */ - case publicKeyLength + case closeOut /** - * Length of an Algorand secret key in bytes (32) + * ClearState is similar to CloseOut, but may never fail. This + * allows users to reclaim their minimum balance from an app + * they no longer wish to opt in to. */ - case secretKeyLength + case clearState /** - * Length of an Algorand signature in bytes (64) + * UpdateApplication indicates that an app transaction will + * update the approval program and clear state program for the app. */ - case signatureLength + case updateApplication /** - * Increment in the encoded byte size when a signature is attached to a transaction (75) + * DeleteApplication indicates that an app transaction will + * delete the app parameters for the app from the creator's + * balance record. */ - case signatureEncodingIncrLength + case deleteApplication } +#if compiler(>=6) +extension OnApplicationComplete: Sendable {} +#endif + #if swift(>=5.8) @_documentation(visibility: private) #endif -public struct FfiConverterTypeAlgorandConstant: FfiConverterRustBuffer { - typealias SwiftType = AlgorandConstant +public struct FfiConverterTypeOnApplicationComplete: FfiConverterRustBuffer { + typealias SwiftType = OnApplicationComplete - public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> AlgorandConstant { + public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> OnApplicationComplete { let variant: Int32 = try readInt(&buf) switch variant { - case 1: return .hashLength - - case 2: return .checksumLength + case 1: return .noOp - case 3: return .addressLength + case 2: return .optIn - case 4: return .publicKeyLength + case 3: return .closeOut - case 5: return .secretKeyLength + case 4: return .clearState - case 6: return .signatureLength + case 5: return .updateApplication - case 7: return .signatureEncodingIncrLength + case 6: return .deleteApplication default: throw UniffiInternalError.unexpectedEnumCase } } - public static func write(_ value: AlgorandConstant, into buf: inout [UInt8]) { + public static func write(_ value: OnApplicationComplete, into buf: inout [UInt8]) { switch value { - case .hashLength: + case .noOp: writeInt(&buf, Int32(1)) - case .checksumLength: + case .optIn: writeInt(&buf, Int32(2)) - case .addressLength: + case .closeOut: writeInt(&buf, Int32(3)) - case .publicKeyLength: + case .clearState: writeInt(&buf, Int32(4)) - case .secretKeyLength: + case .updateApplication: writeInt(&buf, Int32(5)) - case .signatureLength: + case .deleteApplication: writeInt(&buf, Int32(6)) - - case .signatureEncodingIncrLength: - writeInt(&buf, Int32(7)) - } } } @@ -1038,20 +2796,22 @@ public struct FfiConverterTypeAlgorandConstant: FfiConverterRustBuffer { #if swift(>=5.8) @_documentation(visibility: private) #endif -public func FfiConverterTypeAlgorandConstant_lift(_ buf: RustBuffer) throws -> AlgorandConstant { - return try FfiConverterTypeAlgorandConstant.lift(buf) +public func FfiConverterTypeOnApplicationComplete_lift(_ buf: RustBuffer) throws -> OnApplicationComplete { + return try FfiConverterTypeOnApplicationComplete.lift(buf) } #if swift(>=5.8) @_documentation(visibility: private) #endif -public func FfiConverterTypeAlgorandConstant_lower(_ value: AlgorandConstant) -> RustBuffer { - return FfiConverterTypeAlgorandConstant.lower(value) +public func FfiConverterTypeOnApplicationComplete_lower(_ value: OnApplicationComplete) -> RustBuffer { + return FfiConverterTypeOnApplicationComplete.lower(value) } +extension OnApplicationComplete: Equatable, Hashable {} + + -extension AlgorandConstant: Equatable, Hashable {} @@ -1065,10 +2825,14 @@ public enum TransactionType { case assetFreeze case assetConfig case keyRegistration - case applicationCall + case appCall } +#if compiler(>=6) +extension TransactionType: Sendable {} +#endif + #if swift(>=5.8) @_documentation(visibility: private) #endif @@ -1089,7 +2853,7 @@ public struct FfiConverterTypeTransactionType: FfiConverterRustBuffer { case 5: return .keyRegistration - case 6: return .applicationCall + case 6: return .appCall default: throw UniffiInternalError.unexpectedEnumCase } @@ -1119,39 +2883,329 @@ public struct FfiConverterTypeTransactionType: FfiConverterRustBuffer { writeInt(&buf, Int32(5)) - case .applicationCall: + case .appCall: writeInt(&buf, Int32(6)) } } -} +} + + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +public func FfiConverterTypeTransactionType_lift(_ buf: RustBuffer) throws -> TransactionType { + return try FfiConverterTypeTransactionType.lift(buf) +} + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +public func FfiConverterTypeTransactionType_lower(_ value: TransactionType) -> RustBuffer { + return FfiConverterTypeTransactionType.lower(value) +} + + +extension TransactionType: Equatable, Hashable {} + + + + + + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +fileprivate struct FfiConverterOptionUInt32: FfiConverterRustBuffer { + typealias SwiftType = UInt32? + + public static func write(_ value: SwiftType, into buf: inout [UInt8]) { + guard let value = value else { + writeInt(&buf, Int8(0)) + return + } + writeInt(&buf, Int8(1)) + FfiConverterUInt32.write(value, into: &buf) + } + + public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> SwiftType { + switch try readInt(&buf) as Int8 { + case 0: return nil + case 1: return try FfiConverterUInt32.read(from: &buf) + default: throw UniffiInternalError.unexpectedOptionalTag + } + } +} + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +fileprivate struct FfiConverterOptionUInt64: FfiConverterRustBuffer { + typealias SwiftType = UInt64? + + public static func write(_ value: SwiftType, into buf: inout [UInt8]) { + guard let value = value else { + writeInt(&buf, Int8(0)) + return + } + writeInt(&buf, Int8(1)) + FfiConverterUInt64.write(value, into: &buf) + } + + public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> SwiftType { + switch try readInt(&buf) as Int8 { + case 0: return nil + case 1: return try FfiConverterUInt64.read(from: &buf) + default: throw UniffiInternalError.unexpectedOptionalTag + } + } +} + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +fileprivate struct FfiConverterOptionBool: FfiConverterRustBuffer { + typealias SwiftType = Bool? + + public static func write(_ value: SwiftType, into buf: inout [UInt8]) { + guard let value = value else { + writeInt(&buf, Int8(0)) + return + } + writeInt(&buf, Int8(1)) + FfiConverterBool.write(value, into: &buf) + } + + public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> SwiftType { + switch try readInt(&buf) as Int8 { + case 0: return nil + case 1: return try FfiConverterBool.read(from: &buf) + default: throw UniffiInternalError.unexpectedOptionalTag + } + } +} + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +fileprivate struct FfiConverterOptionString: FfiConverterRustBuffer { + typealias SwiftType = String? + + public static func write(_ value: SwiftType, into buf: inout [UInt8]) { + guard let value = value else { + writeInt(&buf, Int8(0)) + return + } + writeInt(&buf, Int8(1)) + FfiConverterString.write(value, into: &buf) + } + + public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> SwiftType { + switch try readInt(&buf) as Int8 { + case 0: return nil + case 1: return try FfiConverterString.read(from: &buf) + default: throw UniffiInternalError.unexpectedOptionalTag + } + } +} + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +fileprivate struct FfiConverterOptionData: FfiConverterRustBuffer { + typealias SwiftType = Data? + + public static func write(_ value: SwiftType, into buf: inout [UInt8]) { + guard let value = value else { + writeInt(&buf, Int8(0)) + return + } + writeInt(&buf, Int8(1)) + FfiConverterData.write(value, into: &buf) + } + + public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> SwiftType { + switch try readInt(&buf) as Int8 { + case 0: return nil + case 1: return try FfiConverterData.read(from: &buf) + default: throw UniffiInternalError.unexpectedOptionalTag + } + } +} + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +fileprivate struct FfiConverterOptionTypeAppCallTransactionFields: FfiConverterRustBuffer { + typealias SwiftType = AppCallTransactionFields? + + public static func write(_ value: SwiftType, into buf: inout [UInt8]) { + guard let value = value else { + writeInt(&buf, Int8(0)) + return + } + writeInt(&buf, Int8(1)) + FfiConverterTypeAppCallTransactionFields.write(value, into: &buf) + } + + public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> SwiftType { + switch try readInt(&buf) as Int8 { + case 0: return nil + case 1: return try FfiConverterTypeAppCallTransactionFields.read(from: &buf) + default: throw UniffiInternalError.unexpectedOptionalTag + } + } +} + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +fileprivate struct FfiConverterOptionTypeAssetConfigTransactionFields: FfiConverterRustBuffer { + typealias SwiftType = AssetConfigTransactionFields? + + public static func write(_ value: SwiftType, into buf: inout [UInt8]) { + guard let value = value else { + writeInt(&buf, Int8(0)) + return + } + writeInt(&buf, Int8(1)) + FfiConverterTypeAssetConfigTransactionFields.write(value, into: &buf) + } + + public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> SwiftType { + switch try readInt(&buf) as Int8 { + case 0: return nil + case 1: return try FfiConverterTypeAssetConfigTransactionFields.read(from: &buf) + default: throw UniffiInternalError.unexpectedOptionalTag + } + } +} + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +fileprivate struct FfiConverterOptionTypeAssetFreezeTransactionFields: FfiConverterRustBuffer { + typealias SwiftType = AssetFreezeTransactionFields? + + public static func write(_ value: SwiftType, into buf: inout [UInt8]) { + guard let value = value else { + writeInt(&buf, Int8(0)) + return + } + writeInt(&buf, Int8(1)) + FfiConverterTypeAssetFreezeTransactionFields.write(value, into: &buf) + } + + public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> SwiftType { + switch try readInt(&buf) as Int8 { + case 0: return nil + case 1: return try FfiConverterTypeAssetFreezeTransactionFields.read(from: &buf) + default: throw UniffiInternalError.unexpectedOptionalTag + } + } +} + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +fileprivate struct FfiConverterOptionTypeAssetTransferTransactionFields: FfiConverterRustBuffer { + typealias SwiftType = AssetTransferTransactionFields? + + public static func write(_ value: SwiftType, into buf: inout [UInt8]) { + guard let value = value else { + writeInt(&buf, Int8(0)) + return + } + writeInt(&buf, Int8(1)) + FfiConverterTypeAssetTransferTransactionFields.write(value, into: &buf) + } + public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> SwiftType { + switch try readInt(&buf) as Int8 { + case 0: return nil + case 1: return try FfiConverterTypeAssetTransferTransactionFields.read(from: &buf) + default: throw UniffiInternalError.unexpectedOptionalTag + } + } +} #if swift(>=5.8) @_documentation(visibility: private) #endif -public func FfiConverterTypeTransactionType_lift(_ buf: RustBuffer) throws -> TransactionType { - return try FfiConverterTypeTransactionType.lift(buf) +fileprivate struct FfiConverterOptionTypeKeyRegistrationTransactionFields: FfiConverterRustBuffer { + typealias SwiftType = KeyRegistrationTransactionFields? + + public static func write(_ value: SwiftType, into buf: inout [UInt8]) { + guard let value = value else { + writeInt(&buf, Int8(0)) + return + } + writeInt(&buf, Int8(1)) + FfiConverterTypeKeyRegistrationTransactionFields.write(value, into: &buf) + } + + public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> SwiftType { + switch try readInt(&buf) as Int8 { + case 0: return nil + case 1: return try FfiConverterTypeKeyRegistrationTransactionFields.read(from: &buf) + default: throw UniffiInternalError.unexpectedOptionalTag + } + } } #if swift(>=5.8) @_documentation(visibility: private) #endif -public func FfiConverterTypeTransactionType_lower(_ value: TransactionType) -> RustBuffer { - return FfiConverterTypeTransactionType.lower(value) -} +fileprivate struct FfiConverterOptionTypeMultisigSignature: FfiConverterRustBuffer { + typealias SwiftType = MultisigSignature? + public static func write(_ value: SwiftType, into buf: inout [UInt8]) { + guard let value = value else { + writeInt(&buf, Int8(0)) + return + } + writeInt(&buf, Int8(1)) + FfiConverterTypeMultisigSignature.write(value, into: &buf) + } + public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> SwiftType { + switch try readInt(&buf) as Int8 { + case 0: return nil + case 1: return try FfiConverterTypeMultisigSignature.read(from: &buf) + default: throw UniffiInternalError.unexpectedOptionalTag + } + } +} -extension TransactionType: Equatable, Hashable {} +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +fileprivate struct FfiConverterOptionTypePaymentTransactionFields: FfiConverterRustBuffer { + typealias SwiftType = PaymentTransactionFields? + public static func write(_ value: SwiftType, into buf: inout [UInt8]) { + guard let value = value else { + writeInt(&buf, Int8(0)) + return + } + writeInt(&buf, Int8(1)) + FfiConverterTypePaymentTransactionFields.write(value, into: &buf) + } + public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> SwiftType { + switch try readInt(&buf) as Int8 { + case 0: return nil + case 1: return try FfiConverterTypePaymentTransactionFields.read(from: &buf) + default: throw UniffiInternalError.unexpectedOptionalTag + } + } +} #if swift(>=5.8) @_documentation(visibility: private) #endif -fileprivate struct FfiConverterOptionString: FfiConverterRustBuffer { - typealias SwiftType = String? +fileprivate struct FfiConverterOptionTypeStateSchema: FfiConverterRustBuffer { + typealias SwiftType = StateSchema? public static func write(_ value: SwiftType, into buf: inout [UInt8]) { guard let value = value else { @@ -1159,13 +3213,13 @@ fileprivate struct FfiConverterOptionString: FfiConverterRustBuffer { return } writeInt(&buf, Int8(1)) - FfiConverterString.write(value, into: &buf) + FfiConverterTypeStateSchema.write(value, into: &buf) } public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> SwiftType { switch try readInt(&buf) as Int8 { case 0: return nil - case 1: return try FfiConverterString.read(from: &buf) + case 1: return try FfiConverterTypeStateSchema.read(from: &buf) default: throw UniffiInternalError.unexpectedOptionalTag } } @@ -1174,8 +3228,8 @@ fileprivate struct FfiConverterOptionString: FfiConverterRustBuffer { #if swift(>=5.8) @_documentation(visibility: private) #endif -fileprivate struct FfiConverterOptionTypeAddress: FfiConverterRustBuffer { - typealias SwiftType = Address? +fileprivate struct FfiConverterOptionSequenceUInt64: FfiConverterRustBuffer { + typealias SwiftType = [UInt64]? public static func write(_ value: SwiftType, into buf: inout [UInt8]) { guard let value = value else { @@ -1183,13 +3237,13 @@ fileprivate struct FfiConverterOptionTypeAddress: FfiConverterRustBuffer { return } writeInt(&buf, Int8(1)) - FfiConverterTypeAddress.write(value, into: &buf) + FfiConverterSequenceUInt64.write(value, into: &buf) } public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> SwiftType { switch try readInt(&buf) as Int8 { case 0: return nil - case 1: return try FfiConverterTypeAddress.read(from: &buf) + case 1: return try FfiConverterSequenceUInt64.read(from: &buf) default: throw UniffiInternalError.unexpectedOptionalTag } } @@ -1198,8 +3252,8 @@ fileprivate struct FfiConverterOptionTypeAddress: FfiConverterRustBuffer { #if swift(>=5.8) @_documentation(visibility: private) #endif -fileprivate struct FfiConverterOptionTypeAssetTransferTransactionFields: FfiConverterRustBuffer { - typealias SwiftType = AssetTransferTransactionFields? +fileprivate struct FfiConverterOptionSequenceString: FfiConverterRustBuffer { + typealias SwiftType = [String]? public static func write(_ value: SwiftType, into buf: inout [UInt8]) { guard let value = value else { @@ -1207,13 +3261,13 @@ fileprivate struct FfiConverterOptionTypeAssetTransferTransactionFields: FfiConv return } writeInt(&buf, Int8(1)) - FfiConverterTypeAssetTransferTransactionFields.write(value, into: &buf) + FfiConverterSequenceString.write(value, into: &buf) } public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> SwiftType { switch try readInt(&buf) as Int8 { case 0: return nil - case 1: return try FfiConverterTypeAssetTransferTransactionFields.read(from: &buf) + case 1: return try FfiConverterSequenceString.read(from: &buf) default: throw UniffiInternalError.unexpectedOptionalTag } } @@ -1222,8 +3276,8 @@ fileprivate struct FfiConverterOptionTypeAssetTransferTransactionFields: FfiConv #if swift(>=5.8) @_documentation(visibility: private) #endif -fileprivate struct FfiConverterOptionTypePaymentTransactionFields: FfiConverterRustBuffer { - typealias SwiftType = PaymentTransactionFields? +fileprivate struct FfiConverterOptionSequenceData: FfiConverterRustBuffer { + typealias SwiftType = [Data]? public static func write(_ value: SwiftType, into buf: inout [UInt8]) { guard let value = value else { @@ -1231,13 +3285,13 @@ fileprivate struct FfiConverterOptionTypePaymentTransactionFields: FfiConverterR return } writeInt(&buf, Int8(1)) - FfiConverterTypePaymentTransactionFields.write(value, into: &buf) + FfiConverterSequenceData.write(value, into: &buf) } public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> SwiftType { switch try readInt(&buf) as Int8 { case 0: return nil - case 1: return try FfiConverterTypePaymentTransactionFields.read(from: &buf) + case 1: return try FfiConverterSequenceData.read(from: &buf) default: throw UniffiInternalError.unexpectedOptionalTag } } @@ -1246,8 +3300,8 @@ fileprivate struct FfiConverterOptionTypePaymentTransactionFields: FfiConverterR #if swift(>=5.8) @_documentation(visibility: private) #endif -fileprivate struct FfiConverterOptionTypeByteBuf: FfiConverterRustBuffer { - typealias SwiftType = ByteBuf? +fileprivate struct FfiConverterOptionSequenceTypeBoxReference: FfiConverterRustBuffer { + typealias SwiftType = [BoxReference]? public static func write(_ value: SwiftType, into buf: inout [UInt8]) { guard let value = value else { @@ -1255,97 +3309,351 @@ fileprivate struct FfiConverterOptionTypeByteBuf: FfiConverterRustBuffer { return } writeInt(&buf, Int8(1)) - FfiConverterTypeByteBuf.write(value, into: &buf) + FfiConverterSequenceTypeBoxReference.write(value, into: &buf) } public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> SwiftType { switch try readInt(&buf) as Int8 { case 0: return nil - case 1: return try FfiConverterTypeByteBuf.read(from: &buf) + case 1: return try FfiConverterSequenceTypeBoxReference.read(from: &buf) default: throw UniffiInternalError.unexpectedOptionalTag } } } +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +fileprivate struct FfiConverterSequenceUInt64: FfiConverterRustBuffer { + typealias SwiftType = [UInt64] -/** - * Typealias from the type name used in the UDL file to the builtin type. This - * is needed because the UDL type name is used in function/method signatures. - */ -public typealias ByteBuf = Data + public static func write(_ value: [UInt64], into buf: inout [UInt8]) { + let len = Int32(value.count) + writeInt(&buf, len) + for item in value { + FfiConverterUInt64.write(item, into: &buf) + } + } + + public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> [UInt64] { + let len: Int32 = try readInt(&buf) + var seq = [UInt64]() + seq.reserveCapacity(Int(len)) + for _ in 0 ..< len { + seq.append(try FfiConverterUInt64.read(from: &buf)) + } + return seq + } +} #if swift(>=5.8) @_documentation(visibility: private) #endif -public struct FfiConverterTypeByteBuf: FfiConverter { - public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> ByteBuf { - return try FfiConverterData.read(from: &buf) +fileprivate struct FfiConverterSequenceString: FfiConverterRustBuffer { + typealias SwiftType = [String] + + public static func write(_ value: [String], into buf: inout [UInt8]) { + let len = Int32(value.count) + writeInt(&buf, len) + for item in value { + FfiConverterString.write(item, into: &buf) + } } - public static func write(_ value: ByteBuf, into buf: inout [UInt8]) { - return FfiConverterData.write(value, into: &buf) + public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> [String] { + let len: Int32 = try readInt(&buf) + var seq = [String]() + seq.reserveCapacity(Int(len)) + for _ in 0 ..< len { + seq.append(try FfiConverterString.read(from: &buf)) + } + return seq } +} + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +fileprivate struct FfiConverterSequenceData: FfiConverterRustBuffer { + typealias SwiftType = [Data] - public static func lift(_ value: RustBuffer) throws -> ByteBuf { - return try FfiConverterData.lift(value) + public static func write(_ value: [Data], into buf: inout [UInt8]) { + let len = Int32(value.count) + writeInt(&buf, len) + for item in value { + FfiConverterData.write(item, into: &buf) + } } - public static func lower(_ value: ByteBuf) -> RustBuffer { - return FfiConverterData.lower(value) + public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> [Data] { + let len: Int32 = try readInt(&buf) + var seq = [Data]() + seq.reserveCapacity(Int(len)) + for _ in 0 ..< len { + seq.append(try FfiConverterData.read(from: &buf)) + } + return seq } } +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +fileprivate struct FfiConverterSequenceTypeBoxReference: FfiConverterRustBuffer { + typealias SwiftType = [BoxReference] + + public static func write(_ value: [BoxReference], into buf: inout [UInt8]) { + let len = Int32(value.count) + writeInt(&buf, len) + for item in value { + FfiConverterTypeBoxReference.write(item, into: &buf) + } + } + + public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> [BoxReference] { + let len: Int32 = try readInt(&buf) + var seq = [BoxReference]() + seq.reserveCapacity(Int(len)) + for _ in 0 ..< len { + seq.append(try FfiConverterTypeBoxReference.read(from: &buf)) + } + return seq + } +} #if swift(>=5.8) @_documentation(visibility: private) #endif -public func FfiConverterTypeByteBuf_lift(_ value: RustBuffer) throws -> ByteBuf { - return try FfiConverterTypeByteBuf.lift(value) +fileprivate struct FfiConverterSequenceTypeMultisigSubsignature: FfiConverterRustBuffer { + typealias SwiftType = [MultisigSubsignature] + + public static func write(_ value: [MultisigSubsignature], into buf: inout [UInt8]) { + let len = Int32(value.count) + writeInt(&buf, len) + for item in value { + FfiConverterTypeMultisigSubsignature.write(item, into: &buf) + } + } + + public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> [MultisigSubsignature] { + let len: Int32 = try readInt(&buf) + var seq = [MultisigSubsignature]() + seq.reserveCapacity(Int(len)) + for _ in 0 ..< len { + seq.append(try FfiConverterTypeMultisigSubsignature.read(from: &buf)) + } + return seq + } } #if swift(>=5.8) @_documentation(visibility: private) #endif -public func FfiConverterTypeByteBuf_lower(_ value: ByteBuf) -> RustBuffer { - return FfiConverterTypeByteBuf.lower(value) +fileprivate struct FfiConverterSequenceTypeSignedTransaction: FfiConverterRustBuffer { + typealias SwiftType = [SignedTransaction] + + public static func write(_ value: [SignedTransaction], into buf: inout [UInt8]) { + let len = Int32(value.count) + writeInt(&buf, len) + for item in value { + FfiConverterTypeSignedTransaction.write(item, into: &buf) + } + } + + public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> [SignedTransaction] { + let len: Int32 = try readInt(&buf) + var seq = [SignedTransaction]() + seq.reserveCapacity(Int(len)) + for _ in 0 ..< len { + seq.append(try FfiConverterTypeSignedTransaction.read(from: &buf)) + } + return seq + } } -public func addressFromPubKey(pubKey: Data)throws -> Address { - return try FfiConverterTypeAddress.lift(try rustCallWithError(FfiConverterTypeAlgoKitTransactError.lift) { - uniffi_algokit_transact_ffi_fn_func_address_from_pub_key( - FfiConverterData.lower(pubKey),$0 +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +fileprivate struct FfiConverterSequenceTypeTransaction: FfiConverterRustBuffer { + typealias SwiftType = [Transaction] + + public static func write(_ value: [Transaction], into buf: inout [UInt8]) { + let len = Int32(value.count) + writeInt(&buf, len) + for item in value { + FfiConverterTypeTransaction.write(item, into: &buf) + } + } + + public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> [Transaction] { + let len: Int32 = try readInt(&buf) + var seq = [Transaction]() + seq.reserveCapacity(Int(len)) + for _ in 0 ..< len { + seq.append(try FfiConverterTypeTransaction.read(from: &buf)) + } + return seq + } +} +/** + * Returns the address of the multisignature account. + * + * # Errors + * /// Returns [`AlgoKitTransactError`] if the multisignature signature is invalid or the address cannot be derived. + */ +public func addressFromMultisigSignature(multisigSignature: MultisigSignature)throws -> String { + return try FfiConverterString.lift(try rustCallWithError(FfiConverterTypeAlgoKitTransactError_lift) { + uniffi_algokit_transact_ffi_fn_func_address_from_multisig_signature( + FfiConverterTypeMultisigSignature_lower(multisigSignature),$0 ) }) } -public func addressFromString(address: String)throws -> Address { - return try FfiConverterTypeAddress.lift(try rustCallWithError(FfiConverterTypeAlgoKitTransactError.lift) { - uniffi_algokit_transact_ffi_fn_func_address_from_string( - FfiConverterString.lower(address),$0 +public func addressFromPublicKey(publicKey: Data)throws -> String { + return try FfiConverterString.lift(try rustCallWithError(FfiConverterTypeAlgoKitTransactError_lift) { + uniffi_algokit_transact_ffi_fn_func_address_from_public_key( + FfiConverterData.lower(publicKey),$0 + ) +}) +} +/** + * Applies a subsignature for a participant to a multisignature signature, replacing any existing signature. + * + * # Errors + * + * Returns [`AlgoKitTransactError`] if the participant address is invalid or not found, or if the signature bytes are invalid. + */ +public func applyMultisigSubsignature(multisigSignature: MultisigSignature, participant: String, subsignature: Data)throws -> MultisigSignature { + return try FfiConverterTypeMultisigSignature_lift(try rustCallWithError(FfiConverterTypeAlgoKitTransactError_lift) { + uniffi_algokit_transact_ffi_fn_func_apply_multisig_subsignature( + FfiConverterTypeMultisigSignature_lower(multisigSignature), + FfiConverterString.lower(participant), + FfiConverterData.lower(subsignature),$0 + ) +}) +} +public func assignFee(transaction: Transaction, feeParams: FeeParams)throws -> Transaction { + return try FfiConverterTypeTransaction_lift(try rustCallWithError(FfiConverterTypeAlgoKitTransactError_lift) { + uniffi_algokit_transact_ffi_fn_func_assign_fee( + FfiConverterTypeTransaction_lower(transaction), + FfiConverterTypeFeeParams_lower(feeParams),$0 + ) +}) +} +public func calculateFee(transaction: Transaction, feeParams: FeeParams)throws -> UInt64 { + return try FfiConverterUInt64.lift(try rustCallWithError(FfiConverterTypeAlgoKitTransactError_lift) { + uniffi_algokit_transact_ffi_fn_func_calculate_fee( + FfiConverterTypeTransaction_lower(transaction), + FfiConverterTypeFeeParams_lower(feeParams),$0 + ) +}) +} +/** + * Decodes a signed transaction. + * + * # Parameters + * * `encoded_signed_transaction` - The MsgPack encoded signed transaction bytes + * + * # Returns + * The decoded SignedTransaction or an error if decoding fails. + */ +public func decodeSignedTransaction(encodedSignedTransaction: Data)throws -> SignedTransaction { + return try FfiConverterTypeSignedTransaction_lift(try rustCallWithError(FfiConverterTypeAlgoKitTransactError_lift) { + uniffi_algokit_transact_ffi_fn_func_decode_signed_transaction( + FfiConverterData.lower(encodedSignedTransaction),$0 ) }) } -public func attachSignature(encodedTx: Data, signature: Data)throws -> Data { - return try FfiConverterData.lift(try rustCallWithError(FfiConverterTypeAlgoKitTransactError.lift) { - uniffi_algokit_transact_ffi_fn_func_attach_signature( - FfiConverterData.lower(encodedTx), - FfiConverterData.lower(signature),$0 +/** + * Decodes a collection of MsgPack bytes into a signed transaction collection. + * + * # Parameters + * * `encoded_signed_transactions` - A collection of MsgPack encoded bytes, each representing a signed transaction. + * + * # Returns + * A collection of decoded signed transactions or an error if decoding fails. + */ +public func decodeSignedTransactions(encodedSignedTransactions: [Data])throws -> [SignedTransaction] { + return try FfiConverterSequenceTypeSignedTransaction.lift(try rustCallWithError(FfiConverterTypeAlgoKitTransactError_lift) { + uniffi_algokit_transact_ffi_fn_func_decode_signed_transactions( + FfiConverterSequenceData.lower(encodedSignedTransactions),$0 ) }) } -public func decodeTransaction(bytes: Data)throws -> Transaction { - return try FfiConverterTypeTransaction.lift(try rustCallWithError(FfiConverterTypeAlgoKitTransactError.lift) { +/** + * Decodes MsgPack bytes into a transaction. + * + * # Parameters + * * `encoded_tx` - MsgPack encoded bytes representing a transaction. + * + * # Returns + * A decoded transaction or an error if decoding fails. + */ +public func decodeTransaction(encodedTx: Data)throws -> Transaction { + return try FfiConverterTypeTransaction_lift(try rustCallWithError(FfiConverterTypeAlgoKitTransactError_lift) { uniffi_algokit_transact_ffi_fn_func_decode_transaction( - FfiConverterData.lower(bytes),$0 + FfiConverterData.lower(encodedTx),$0 + ) +}) +} +/** + * Decodes a collection of MsgPack bytes into a transaction collection. + * + * # Parameters + * * `encoded_txs` - A collection of MsgPack encoded bytes, each representing a transaction. + * + * # Returns + * A collection of decoded transactions or an error if decoding fails. + */ +public func decodeTransactions(encodedTxs: [Data])throws -> [Transaction] { + return try FfiConverterSequenceTypeTransaction.lift(try rustCallWithError(FfiConverterTypeAlgoKitTransactError_lift) { + uniffi_algokit_transact_ffi_fn_func_decode_transactions( + FfiConverterSequenceData.lower(encodedTxs),$0 + ) +}) +} +/** + * Encode a signed transaction to MsgPack for sending on the network. + * + * This method performs canonical encoding. No domain separation prefix is applicable. + * + * # Parameters + * * `signed_transaction` - The signed transaction to encode + * + * # Returns + * The MsgPack encoded bytes or an error if encoding fails. + */ +public func encodeSignedTransaction(signedTransaction: SignedTransaction)throws -> Data { + return try FfiConverterData.lift(try rustCallWithError(FfiConverterTypeAlgoKitTransactError_lift) { + uniffi_algokit_transact_ffi_fn_func_encode_signed_transaction( + FfiConverterTypeSignedTransaction_lower(signedTransaction),$0 + ) +}) +} +/** + * Encode signed transactions to MsgPack for sending on the network. + * + * This method performs canonical encoding. No domain separation prefix is applicable. + * + * # Parameters + * * `signed_transactions` - A collection of signed transactions to encode + * + * # Returns + * A collection of MsgPack encoded bytes or an error if encoding fails. + */ +public func encodeSignedTransactions(signedTransactions: [SignedTransaction])throws -> [Data] { + return try FfiConverterSequenceData.lift(try rustCallWithError(FfiConverterTypeAlgoKitTransactError_lift) { + uniffi_algokit_transact_ffi_fn_func_encode_signed_transactions( + FfiConverterSequenceTypeSignedTransaction.lower(signedTransactions),$0 ) }) } /** * Encode the transaction with the domain separation (e.g. "TX") prefix */ -public func encodeTransaction(tx: Transaction)throws -> Data { - return try FfiConverterData.lift(try rustCallWithError(FfiConverterTypeAlgoKitTransactError.lift) { +public func encodeTransaction(transaction: Transaction)throws -> Data { + return try FfiConverterData.lift(try rustCallWithError(FfiConverterTypeAlgoKitTransactError_lift) { uniffi_algokit_transact_ffi_fn_func_encode_transaction( - FfiConverterTypeTransaction.lower(tx),$0 + FfiConverterTypeTransaction_lower(transaction),$0 ) }) } @@ -1353,10 +3661,26 @@ public func encodeTransaction(tx: Transaction)throws -> Data { * Encode the transaction without the domain separation (e.g. "TX") prefix * This is useful for encoding the transaction for signing with tools that automatically add "TX" prefix to the transaction bytes. */ -public func encodeTransactionRaw(tx: Transaction)throws -> Data { - return try FfiConverterData.lift(try rustCallWithError(FfiConverterTypeAlgoKitTransactError.lift) { +public func encodeTransactionRaw(transaction: Transaction)throws -> Data { + return try FfiConverterData.lift(try rustCallWithError(FfiConverterTypeAlgoKitTransactError_lift) { uniffi_algokit_transact_ffi_fn_func_encode_transaction_raw( - FfiConverterTypeTransaction.lower(tx),$0 + FfiConverterTypeTransaction_lower(transaction),$0 + ) +}) +} +/** + * Encode transactions to MsgPack with the domain separation (e.g. "TX") prefix. + * + * # Parameters + * * `transactions` - A collection of transactions to encode + * + * # Returns + * A collection of MsgPack encoded bytes or an error if encoding fails. + */ +public func encodeTransactions(transactions: [Transaction])throws -> [Data] { + return try FfiConverterSequenceData.lift(try rustCallWithError(FfiConverterTypeAlgoKitTransactError_lift) { + uniffi_algokit_transact_ffi_fn_func_encode_transactions( + FfiConverterSequenceTypeTransaction.lower(transactions),$0 ) }) } @@ -1364,17 +3688,17 @@ public func encodeTransactionRaw(tx: Transaction)throws -> Data { * Return the size of the transaction in bytes as if it was already signed and encoded. * This is useful for estimating the fee for the transaction. */ -public func estimateTransactionSize(transaction: Transaction)throws -> UInt64 { - return try FfiConverterUInt64.lift(try rustCallWithError(FfiConverterTypeAlgoKitTransactError.lift) { +public func estimateTransactionSize(transaction: Transaction)throws -> UInt64 { + return try FfiConverterUInt64.lift(try rustCallWithError(FfiConverterTypeAlgoKitTransactError_lift) { uniffi_algokit_transact_ffi_fn_func_estimate_transaction_size( - FfiConverterTypeTransaction.lower(transaction),$0 + FfiConverterTypeTransaction_lower(transaction),$0 ) }) } -public func getAlgorandConstant(constant: AlgorandConstant) -> UInt64 { +public func getAlgorandConstant(constant: AlgorandConstant) -> UInt64 { return try! FfiConverterUInt64.lift(try! rustCall() { uniffi_algokit_transact_ffi_fn_func_get_algorand_constant( - FfiConverterTypeAlgorandConstant.lower(constant),$0 + FfiConverterTypeAlgorandConstant_lower(constant),$0 ) }) } @@ -1382,30 +3706,91 @@ public func getAlgorandConstant(constant: AlgorandConstant) -> UInt64 { * Get the transaction type from the encoded transaction. * This is particularly useful when decoding a transaction that has an unknown type */ -public func getEncodedTransactionType(bytes: Data)throws -> TransactionType { - return try FfiConverterTypeTransactionType.lift(try rustCallWithError(FfiConverterTypeAlgoKitTransactError.lift) { +public func getEncodedTransactionType(encodedTransaction: Data)throws -> TransactionType { + return try FfiConverterTypeTransactionType_lift(try rustCallWithError(FfiConverterTypeAlgoKitTransactError_lift) { uniffi_algokit_transact_ffi_fn_func_get_encoded_transaction_type( - FfiConverterData.lower(bytes),$0 + FfiConverterData.lower(encodedTransaction),$0 ) }) } /** * Get the base32 transaction ID string for a transaction. */ -public func getTransactionId(tx: Transaction)throws -> String { - return try FfiConverterString.lift(try rustCallWithError(FfiConverterTypeAlgoKitTransactError.lift) { +public func getTransactionId(transaction: Transaction)throws -> String { + return try FfiConverterString.lift(try rustCallWithError(FfiConverterTypeAlgoKitTransactError_lift) { uniffi_algokit_transact_ffi_fn_func_get_transaction_id( - FfiConverterTypeTransaction.lower(tx),$0 + FfiConverterTypeTransaction_lower(transaction),$0 ) }) } /** * Get the raw 32-byte transaction ID for a transaction. */ -public func getTransactionIdRaw(tx: Transaction)throws -> Data { - return try FfiConverterData.lift(try rustCallWithError(FfiConverterTypeAlgoKitTransactError.lift) { +public func getTransactionIdRaw(transaction: Transaction)throws -> Data { + return try FfiConverterData.lift(try rustCallWithError(FfiConverterTypeAlgoKitTransactError_lift) { uniffi_algokit_transact_ffi_fn_func_get_transaction_id_raw( - FfiConverterTypeTransaction.lower(tx),$0 + FfiConverterTypeTransaction_lower(transaction),$0 + ) +}) +} +/** + * Groups a collection of transactions by calculating and assigning the group to each transaction. + */ +public func groupTransactions(transactions: [Transaction])throws -> [Transaction] { + return try FfiConverterSequenceTypeTransaction.lift(try rustCallWithError(FfiConverterTypeAlgoKitTransactError_lift) { + uniffi_algokit_transact_ffi_fn_func_group_transactions( + FfiConverterSequenceTypeTransaction.lower(transactions),$0 + ) +}) +} +/** + * Merges two multisignature signatures, replacing signatures in the first with those from the second where present. + * + * # Errors + * + * Returns [`AlgoKitTransactError`] if the multisignature parameters or participants do not match. + */ +public func mergeMultisignatures(multisigSignatureA: MultisigSignature, multisigSignatureB: MultisigSignature)throws -> MultisigSignature { + return try FfiConverterTypeMultisigSignature_lift(try rustCallWithError(FfiConverterTypeAlgoKitTransactError_lift) { + uniffi_algokit_transact_ffi_fn_func_merge_multisignatures( + FfiConverterTypeMultisigSignature_lower(multisigSignatureA), + FfiConverterTypeMultisigSignature_lower(multisigSignatureB),$0 + ) +}) +} +/** + * Creates an empty multisignature signature from a list of participant addresses. + * + * # Errors + * + * Returns [`AlgoKitTransactError`] if any address is invalid or the multisignature parameters are invalid. + */ +public func newMultisigSignature(version: UInt8, threshold: UInt8, participants: [String])throws -> MultisigSignature { + return try FfiConverterTypeMultisigSignature_lift(try rustCallWithError(FfiConverterTypeAlgoKitTransactError_lift) { + uniffi_algokit_transact_ffi_fn_func_new_multisig_signature( + FfiConverterUInt8.lower(version), + FfiConverterUInt8.lower(threshold), + FfiConverterSequenceString.lower(participants),$0 + ) +}) +} +/** + * Returns the list of participant addresses from a multisignature signature. + * + * # Errors + * Returns [`AlgoKitTransactError`] if the multisignature is invalid. + */ +public func participantsFromMultisigSignature(multisigSignature: MultisigSignature)throws -> [String] { + return try FfiConverterSequenceString.lift(try rustCallWithError(FfiConverterTypeAlgoKitTransactError_lift) { + uniffi_algokit_transact_ffi_fn_func_participants_from_multisig_signature( + FfiConverterTypeMultisigSignature_lower(multisigSignature),$0 + ) +}) +} +public func publicKeyFromAddress(address: String)throws -> Data { + return try FfiConverterData.lift(try rustCallWithError(FfiConverterTypeAlgoKitTransactError_lift) { + uniffi_algokit_transact_ffi_fn_func_public_key_from_address( + FfiConverterString.lower(address),$0 ) }) } @@ -1419,28 +3804,52 @@ private enum InitializationResult { // the code inside is only computed once. private let initializationResult: InitializationResult = { // Get the bindings contract version from our ComponentInterface - let bindings_contract_version = 26 + let bindings_contract_version = 29 // Get the scaffolding contract version by calling the into the dylib let scaffolding_contract_version = ffi_algokit_transact_ffi_uniffi_contract_version() if bindings_contract_version != scaffolding_contract_version { return InitializationResult.contractVersionMismatch } - if (uniffi_algokit_transact_ffi_checksum_func_address_from_pub_key() != 65205) { + if (uniffi_algokit_transact_ffi_checksum_func_address_from_multisig_signature() != 51026) { + return InitializationResult.apiChecksumMismatch + } + if (uniffi_algokit_transact_ffi_checksum_func_address_from_public_key() != 10716) { + return InitializationResult.apiChecksumMismatch + } + if (uniffi_algokit_transact_ffi_checksum_func_apply_multisig_subsignature() != 42634) { + return InitializationResult.apiChecksumMismatch + } + if (uniffi_algokit_transact_ffi_checksum_func_assign_fee() != 35003) { + return InitializationResult.apiChecksumMismatch + } + if (uniffi_algokit_transact_ffi_checksum_func_calculate_fee() != 7537) { + return InitializationResult.apiChecksumMismatch + } + if (uniffi_algokit_transact_ffi_checksum_func_decode_signed_transaction() != 43569) { return InitializationResult.apiChecksumMismatch } - if (uniffi_algokit_transact_ffi_checksum_func_address_from_string() != 56499) { + if (uniffi_algokit_transact_ffi_checksum_func_decode_signed_transactions() != 62888) { return InitializationResult.apiChecksumMismatch } - if (uniffi_algokit_transact_ffi_checksum_func_attach_signature() != 7369) { + if (uniffi_algokit_transact_ffi_checksum_func_decode_transaction() != 56405) { return InitializationResult.apiChecksumMismatch } - if (uniffi_algokit_transact_ffi_checksum_func_decode_transaction() != 38127) { + if (uniffi_algokit_transact_ffi_checksum_func_decode_transactions() != 26956) { return InitializationResult.apiChecksumMismatch } - if (uniffi_algokit_transact_ffi_checksum_func_encode_transaction() != 62809) { + if (uniffi_algokit_transact_ffi_checksum_func_encode_signed_transaction() != 47064) { return InitializationResult.apiChecksumMismatch } - if (uniffi_algokit_transact_ffi_checksum_func_encode_transaction_raw() != 1774) { + if (uniffi_algokit_transact_ffi_checksum_func_encode_signed_transactions() != 1956) { + return InitializationResult.apiChecksumMismatch + } + if (uniffi_algokit_transact_ffi_checksum_func_encode_transaction() != 11275) { + return InitializationResult.apiChecksumMismatch + } + if (uniffi_algokit_transact_ffi_checksum_func_encode_transaction_raw() != 384) { + return InitializationResult.apiChecksumMismatch + } + if (uniffi_algokit_transact_ffi_checksum_func_encode_transactions() != 59611) { return InitializationResult.apiChecksumMismatch } if (uniffi_algokit_transact_ffi_checksum_func_estimate_transaction_size() != 60858) { @@ -1449,20 +3858,37 @@ private let initializationResult: InitializationResult = { if (uniffi_algokit_transact_ffi_checksum_func_get_algorand_constant() != 49400) { return InitializationResult.apiChecksumMismatch } - if (uniffi_algokit_transact_ffi_checksum_func_get_encoded_transaction_type() != 9866) { + if (uniffi_algokit_transact_ffi_checksum_func_get_encoded_transaction_type() != 42551) { + return InitializationResult.apiChecksumMismatch + } + if (uniffi_algokit_transact_ffi_checksum_func_get_transaction_id() != 10957) { + return InitializationResult.apiChecksumMismatch + } + if (uniffi_algokit_transact_ffi_checksum_func_get_transaction_id_raw() != 48975) { + return InitializationResult.apiChecksumMismatch + } + if (uniffi_algokit_transact_ffi_checksum_func_group_transactions() != 18193) { + return InitializationResult.apiChecksumMismatch + } + if (uniffi_algokit_transact_ffi_checksum_func_merge_multisignatures() != 58688) { + return InitializationResult.apiChecksumMismatch + } + if (uniffi_algokit_transact_ffi_checksum_func_new_multisig_signature() != 29314) { return InitializationResult.apiChecksumMismatch } - if (uniffi_algokit_transact_ffi_checksum_func_get_transaction_id() != 20463) { + if (uniffi_algokit_transact_ffi_checksum_func_participants_from_multisig_signature() != 25095) { return InitializationResult.apiChecksumMismatch } - if (uniffi_algokit_transact_ffi_checksum_func_get_transaction_id_raw() != 37098) { + if (uniffi_algokit_transact_ffi_checksum_func_public_key_from_address() != 58152) { return InitializationResult.apiChecksumMismatch } return InitializationResult.ok }() -private func uniffiEnsureInitialized() { +// Make the ensure init function public so that other modules which have external type references to +// our types can call it. +public func uniffiEnsureAlgokitTransactFfiInitialized() { switch initializationResult { case .ok: break diff --git a/packages/swift/AlgoKitTransact/Tests/AlgoKitTransactTests/GenericTransactionTests.swift b/packages/swift/AlgoKitTransact/Tests/AlgoKitTransactTests/GenericTransactionTests.swift index 147170557..927cd7074 100644 --- a/packages/swift/AlgoKitTransact/Tests/AlgoKitTransactTests/GenericTransactionTests.swift +++ b/packages/swift/AlgoKitTransact/Tests/AlgoKitTransactTests/GenericTransactionTests.swift @@ -9,24 +9,24 @@ import Testing @Test("Generic Transaction: malformed bytes") func genericTransactionMalformedBytes() throws { - let testData = try loadTestData() - let simplePayment = testData.simplePayment - let badBytes = Data(simplePayment.unsignedBytes[13..<37]) - do { - _ = try decodeTransaction(bytes: badBytes) - #expect(Bool(false), "Expected DecodingError to be thrown") - } catch AlgoKitTransactError.DecodingError { - // Success - expected error was thrown - #expect(Bool(true)) - } + let testData = try loadTestData() + let simplePayment = testData.simplePayment + let badBytes = Data(simplePayment.unsignedBytes[13..<37]) + do { + _ = try decodeTransaction(encodedTx: badBytes) + #expect(Bool(false), "Expected DecodingError to be thrown") + } catch AlgoKitTransactError.DecodingError { + // Success - expected error was thrown + #expect(Bool(true)) + } } @Test("Generic Transaction: encode 0 bytes") func genericTransactionEncode0Bytes() throws { - do { - _ = try decodeTransaction(bytes: Data()) - #expect(Bool(false), "Expected DecodingError to be thrown") - } catch AlgoKitTransactError.DecodingError(let message) { - #expect(message == "attempted to decode 0 bytes") - } + do { + _ = try decodeTransaction(encodedTx: Data()) + #expect(Bool(false), "Expected DecodingError to be thrown") + } catch AlgoKitTransactError.InputError(let message) { + #expect(message == "attempted to decode 0 bytes") + } } diff --git a/packages/swift/AlgoKitTransact/Tests/AlgoKitTransactTests/PaymentTests.swift b/packages/swift/AlgoKitTransact/Tests/AlgoKitTransactTests/PaymentTests.swift index b1657a7a7..8e8c81c73 100644 --- a/packages/swift/AlgoKitTransact/Tests/AlgoKitTransactTests/PaymentTests.swift +++ b/packages/swift/AlgoKitTransact/Tests/AlgoKitTransactTests/PaymentTests.swift @@ -10,82 +10,86 @@ import ed25519swift @Test("Payment: example") func paymentExample() throws { - let aliceKeyPair = Ed25519.generateKeyPair() - let alice = try addressFromPubKey(pubKey: Data(aliceKeyPair.publicKey)) - let bob = try addressFromString( - address: "B72WNFFEZ7EOGMQPP7ROHYS3DSLL5JW74QASYNWGZGQXWRPJECJJLJIJ2Y" - ) + let aliceKeyPair = Ed25519.generateKeyPair() + let alice = try addressFromPublicKey(publicKey: Data(aliceKeyPair.publicKey)) + let bob = "B72WNFFEZ7EOGMQPP7ROHYS3DSLL5JW74QASYNWGZGQXWRPJECJJLJIJ2Y" - let txn: Transaction = Transaction( - transactionType: .payment, - sender: alice, - fee: 1000, - firstValid: 1337, - lastValid: 1347, - genesisHash: Data(repeating: 65, count: 32), // pretend this is a valid hash - genesisId: "localnet", - payment: PaymentTransactionFields( - receiver: bob, - amount: 1337 - ) + let txn: Transaction = Transaction( + transactionType: .payment, + sender: alice, + fee: 1000, + firstValid: 1337, + lastValid: 1347, + genesisHash: Data(repeating: 65, count: 32), // pretend this is a valid hash + genesisId: "localnet", + payment: PaymentTransactionFields( + receiver: bob, + amount: 1337 ) + ) - let sig = Ed25519.sign( - message: [UInt8](try encodeTransaction(tx: txn)), secretKey: aliceKeyPair.secretKey) + let sig = Ed25519.sign( + message: [UInt8](try encodeTransaction(transaction: txn)), secretKey: aliceKeyPair.secretKey) - let signedTxn = try attachSignature( - encodedTx: try encodeTransaction(tx: txn), - signature: Data(sig) - ) + let signedTxn = SignedTransaction( + transaction: txn, + signature: Data(sig) + ) - #expect(signedTxn.count > 0) + let encodedStxn = try encodeSignedTransaction(signedTransaction: signedTxn) + + #expect(encodedStxn.count > 0) } @Test("Payment: get encoded transaction type") func paymentGetEncodedTransactionType() throws { - let testData = try loadTestData() - let simplePayment = testData.simplePayment - let txType = try getEncodedTransactionType(bytes: Data(simplePayment.unsignedBytes)) - #expect(txType == .payment) + let testData = try loadTestData() + let simplePayment = testData.simplePayment + let txType = try getEncodedTransactionType(encodedTransaction: Data(simplePayment.unsignedBytes)) + #expect(txType == .payment) } @Test("Payment: decode without prefix") func paymentDecodeWithoutPrefix() throws { - let testData = try loadTestData() - let simplePayment = testData.simplePayment - let transaction = makeTransaction(from: simplePayment) - let bytesWithoutPrefix = Data(simplePayment.unsignedBytes.dropFirst(2)) - let decoded = try decodeTransaction(bytes: bytesWithoutPrefix) - #expect(decoded == transaction) + let testData = try loadTestData() + let simplePayment = testData.simplePayment + let transaction = makeTransaction(from: simplePayment) + let bytesWithoutPrefix = Data(simplePayment.unsignedBytes.dropFirst(2)) + let decoded = try decodeTransaction(encodedTx: bytesWithoutPrefix) + #expect(decoded == transaction) } @Test("Payment: decode with prefix") func paymentDecodeWithPrefix() throws { - let testData = try loadTestData() - let simplePayment = testData.simplePayment - let transaction = makeTransaction(from: simplePayment) - let decoded = try decodeTransaction(bytes: Data(simplePayment.unsignedBytes)) - #expect(decoded == transaction) + let testData = try loadTestData() + let simplePayment = testData.simplePayment + let transaction = makeTransaction(from: simplePayment) + let decoded = try decodeTransaction(encodedTx: Data(simplePayment.unsignedBytes)) + #expect(decoded == transaction) } @Test("Payment: encode with signature") func paymentEncodeWithSignature() throws { - let testData = try loadTestData() - let simplePayment = testData.simplePayment - let signature = Ed25519.sign( - message: simplePayment.unsignedBytes, secretKey: simplePayment.signingPrivateKey) - let signedTx = try attachSignature( - encodedTx: Data(simplePayment.unsignedBytes), - signature: Data(signature) - ) - #expect([UInt8](signedTx) == simplePayment.signedBytes) + let testData = try loadTestData() + let simplePayment = testData.simplePayment + let signature = Ed25519.sign( + message: simplePayment.unsignedBytes, secretKey: simplePayment.signingPrivateKey) + + let signedTx = SignedTransaction( + transaction: makeTransaction(from: simplePayment), + signature: Data(signature) + ) + + let encodedStxn = try encodeSignedTransaction(signedTransaction: signedTx) + + #expect([UInt8](encodedStxn) == simplePayment.signedBytes) } @Test("Payment: encode") func paymentEncode() throws { - let testData = try loadTestData() - let simplePayment = testData.simplePayment - let transaction = makeTransaction(from: simplePayment) - let encoded = try encodeTransaction(tx: transaction) - #expect([UInt8](encoded) == simplePayment.unsignedBytes) + let testData = try loadTestData() + let simplePayment = testData.simplePayment + let transaction = makeTransaction(from: simplePayment) + let encoded = try encodeTransaction(transaction: transaction) + #expect([UInt8](encoded) == simplePayment.unsignedBytes) } diff --git a/packages/swift/AlgoKitTransact/Tests/AlgoKitTransactTests/Resources/test_data.json b/packages/swift/AlgoKitTransact/Tests/AlgoKitTransactTests/Resources/test_data.json index 52d2bff14..a25a0ac0a 100644 --- a/packages/swift/AlgoKitTransact/Tests/AlgoKitTransactTests/Resources/test_data.json +++ b/packages/swift/AlgoKitTransact/Tests/AlgoKitTransactTests/Resources/test_data.json @@ -1,489 +1,65570 @@ { - "optInAssetTransfer": { - "id": "JIDBHDPLBASULQZFI4EY5FJWR6VQRMPPFSGYBKE2XKW65N3UQJXA", + "appCall": { + "id": "6Y644M5SGTKNBH7ZX6D7QAAHDF6YL6FDJPRAGSUHNZLR4IKGVSPQ", "idRaw": [ + 246, + 61, + 206, + 51, + 178, + 52, + 212, + 208, + 159, + 249, + 191, + 135, + 248, + 0, + 7, + 25, + 125, + 133, + 248, + 163, + 75, + 226, + 3, 74, - 6, - 19, - 141, - 235, - 8, - 37, - 69, - 195, - 37, - 71, - 9, - 142, - 149, - 54, - 143, - 171, - 8, - 177, - 239, - 44, - 141, - 128, - 168, - 154, - 186, - 173, - 238, - 183, - 116, - 130, - 110 + 135, + 110, + 87, + 30, + 33, + 70, + 172, + 159 ], - "signedBytes": [ + "multisigAddresses": [ + "424ZV7KBBUJ52DUKP2KLQ6I5GBOHKBXOW7Q7UQIOOYNDWYRM4EKOSMVVRI", + "NY6DHEEFW73R2NUWY562U2NNKSKBKVYY5OOQFLD3M2II5RUNKRZDEGUGEA" + ], + "multisigSignedBytes": [ 130, - 163, + 164, + 109, + 115, + 105, + 103, + 131, + 166, + 115, + 117, + 98, 115, 105, 103, + 146, + 130, + 162, + 112, + 107, + 196, + 32, + 230, + 185, + 154, + 253, + 65, + 13, + 19, + 221, + 14, + 138, + 126, + 148, + 184, + 121, + 29, + 48, + 92, + 117, + 6, + 238, + 183, + 225, + 250, + 65, + 14, + 118, + 26, + 59, + 98, + 44, + 225, + 20, + 161, + 115, 196, 64, - 108, - 27, - 242, - 197, - 141, - 1, - 233, - 137, - 108, - 190, - 54, - 245, - 55, - 173, - 43, + 172, + 166, + 51, + 229, + 118, + 182, + 194, 72, - 68, - 36, - 204, + 48, + 212, + 41, + 152, + 211, + 120, + 138, + 160, 128, - 202, + 218, + 209, + 67, + 144, + 140, + 173, + 156, + 227, + 127, 112, - 148, - 46, - 178, + 147, + 27, + 112, + 68, + 236, + 121, + 19, + 174, + 239, + 5, 69, + 242, + 6, + 52, + 89, 192, - 121, - 3, - 159, - 167, - 170, - 75, - 211, - 7, - 248, - 87, - 195, - 171, - 222, - 105, - 44, - 38, - 162, - 25, - 58, - 154, - 189, - 182, - 48, - 252, - 167, - 101, - 145, - 73, - 180, - 101, - 107, - 181, - 191, - 37, + 53, + 83, + 19, + 16, + 72, + 55, + 35, + 233, + 70, 57, - 211, - 1, - 163, 116, - 120, - 110, - 137, - 164, - 97, - 114, - 99, - 118, + 10, + 207, + 215, + 191, + 2, + 67, + 210, + 94, + 47, + 12, + 130, + 162, + 112, + 107, 196, 32, - 72, - 118, - 175, - 30, - 96, - 187, - 134, - 238, - 76, - 228, - 146, - 219, - 137, - 200, - 222, - 52, - 40, - 86, - 146, - 168, - 129, - 190, - 15, - 103, + 110, + 60, + 51, + 144, + 133, + 183, + 247, + 29, + 54, + 150, + 199, + 125, + 170, + 105, + 173, + 84, + 148, 21, + 87, 24, - 5, - 31, - 88, - 27, - 201, + 235, + 157, + 2, + 172, 123, - 163, - 102, - 101, - 101, - 205, - 3, - 232, - 162, 102, + 144, + 142, + 198, + 141, + 84, + 114, + 161, + 115, + 196, + 64, + 172, + 166, + 51, + 229, 118, - 206, - 3, - 13, - 0, - 56, + 182, + 194, + 72, + 48, + 212, + 41, + 152, + 211, + 120, + 138, + 160, + 128, + 218, + 209, + 67, + 144, + 140, + 173, + 156, + 227, + 127, + 112, + 147, + 27, + 112, + 68, + 236, + 121, + 19, + 174, + 239, + 5, + 69, + 242, + 6, + 52, + 89, + 192, + 53, + 83, + 19, + 16, + 72, + 55, + 35, + 233, + 70, + 57, + 116, + 10, + 207, + 215, + 191, + 2, + 67, + 210, + 94, + 47, + 12, 163, - 103, - 101, - 110, - 172, 116, - 101, - 115, + 104, + 114, + 2, + 161, + 118, + 1, + 163, 116, + 120, + 110, + 141, + 164, + 97, + 112, + 97, + 97, + 148, + 196, + 4, + 109, + 105, 110, + 116, + 196, + 8, + 0, + 0, + 0, + 0, + 0, + 15, + 66, + 64, + 196, + 15, + 115, 101, + 99, + 117, + 114, + 105, 116, - 45, - 118, - 49, + 105, + 122, + 101, 46, - 48, - 162, + 97, + 108, 103, - 104, + 111, 196, - 32, - 72, - 99, - 181, - 24, - 164, - 179, - 200, - 78, - 200, - 16, - 242, + 60, + 116, + 101, + 109, + 112, + 108, + 97, + 116, + 101, 45, - 79, - 16, - 129, - 203, - 15, - 113, - 240, - 89, - 167, - 172, - 32, - 222, - 198, - 47, - 127, + 105, 112, - 229, - 9, + 102, + 115, 58, - 34, - 162, - 108, - 118, - 206, - 3, - 13, - 1, - 0, - 163, + 47, + 47, + 123, + 105, + 112, + 102, 115, - 110, + 99, + 105, 100, - 196, - 32, - 72, - 118, - 175, - 30, - 96, - 187, - 134, - 238, - 76, - 228, - 146, - 219, - 137, - 200, - 222, - 52, - 40, - 86, - 146, - 168, - 129, - 190, - 15, + 58, + 49, + 58, + 100, + 97, 103, - 21, - 24, - 5, - 31, - 88, - 27, - 201, - 123, - 164, - 116, - 121, + 45, 112, + 98, + 58, + 114, 101, - 165, - 97, - 120, - 102, + 115, 101, 114, - 164, - 120, + 118, + 101, + 58, + 115, + 104, 97, - 105, + 50, + 45, + 50, + 53, + 54, + 125, + 47, + 110, + 102, 100, + 46, + 106, + 115, + 111, + 110, + 164, + 97, + 112, + 97, + 115, + 145, 206, - 6, - 107, + 5, + 7, + 85, + 184, + 164, + 97, + 112, + 97, + 116, + 146, + 196, + 32, + 85, + 64, + 108, + 163, + 118, + 74, + 55, + 233, + 206, + 106, + 77, + 17, + 191, + 16, + 70, + 126, + 218, + 115, + 71, + 181, + 10, + 90, + 139, + 155, + 99, + 139, + 142, + 243, + 31, + 87, 40, - 157 - ], - "signingPrivateKey": [ - 2, + 183, + 196, + 32, + 85, + 64, + 108, + 163, + 118, + 74, + 55, + 233, + 206, + 106, + 77, + 17, + 191, + 16, + 70, + 126, + 218, + 115, + 71, + 181, + 10, + 90, + 139, + 155, + 99, + 139, + 142, + 243, + 31, + 87, + 40, + 183, + 164, + 97, + 112, + 105, + 100, + 206, + 5, + 7, + 85, + 233, + 163, + 102, + 101, + 101, 205, + 19, + 136, + 162, + 102, + 118, + 206, + 1, + 65, + 4, + 220, + 163, + 103, + 101, + 110, + 172, + 116, + 101, + 115, + 116, + 110, + 101, + 116, + 45, + 118, + 49, + 46, + 48, + 162, + 103, + 104, + 196, + 32, + 72, + 99, + 181, + 24, + 164, + 179, + 200, + 78, + 200, + 16, + 242, + 45, + 79, + 16, + 129, + 203, + 15, + 113, + 240, + 89, + 167, + 172, + 32, + 222, + 198, + 47, + 127, + 112, + 229, + 9, + 58, + 34, + 163, 103, + 114, + 112, + 196, + 32, + 146, + 220, + 65, + 99, + 253, + 148, + 21, + 250, + 175, + 135, + 2, + 138, + 199, + 8, + 161, + 75, + 214, 33, - 67, - 14, - 82, + 124, + 111, + 168, + 127, + 120, + 115, + 216, + 141, + 196, + 174, + 3, + 89, + 101, + 42, + 162, + 108, + 118, + 206, + 1, + 65, + 8, + 196, + 164, + 110, + 111, + 116, + 101, + 196, + 8, + 0, + 0, + 0, + 0, + 0, + 15, + 66, + 64, + 163, + 115, + 110, + 100, 196, + 32, + 85, + 64, + 108, + 163, + 118, + 74, + 55, + 233, + 206, + 106, + 77, + 17, + 191, + 16, + 70, + 126, + 218, + 115, + 71, + 181, + 10, + 90, + 139, + 155, + 99, + 139, + 142, + 243, + 31, + 87, + 40, + 183, + 164, + 116, + 121, + 112, + 101, + 164, + 97, + 112, + 112, + 108 + ], + "rekeyedSenderAuthAddress": "BKDYDIDVSZCP75JVCB76P3WBJRY6HWAIFDSEOKYHJY5WMNJ2UWJ65MYETU", + "rekeyedSenderSignedBytes": [ + 131, + 164, 115, + 103, + 110, + 114, 196, + 32, + 10, + 135, + 129, + 160, + 117, + 150, + 68, + 255, + 245, + 53, + 16, + 127, + 231, + 238, + 193, + 76, + 113, + 227, + 216, + 8, + 40, + 228, + 71, + 43, + 7, + 78, + 59, + 102, + 53, + 58, + 165, + 147, + 163, + 115, + 105, + 103, + 196, + 64, + 172, + 166, + 51, + 229, + 118, + 182, + 194, + 72, + 48, + 212, + 41, + 152, + 211, + 120, + 138, + 160, + 128, + 218, + 209, + 67, + 144, + 140, + 173, + 156, + 227, + 127, + 112, + 147, + 27, + 112, + 68, + 236, + 121, + 19, + 174, + 239, + 5, + 69, + 242, + 6, + 52, + 89, + 192, + 53, + 83, + 19, + 16, + 72, + 55, + 35, + 233, + 70, + 57, + 116, + 10, + 207, + 215, + 191, + 2, + 67, + 210, + 94, + 47, + 12, + 163, + 116, + 120, + 110, + 141, + 164, + 97, + 112, + 97, + 97, + 148, + 196, + 4, + 109, + 105, + 110, + 116, + 196, + 8, + 0, + 0, + 0, + 0, + 0, + 15, + 66, + 64, + 196, + 15, + 115, + 101, + 99, + 117, + 114, + 105, + 116, + 105, + 122, + 101, + 46, + 97, + 108, + 103, + 111, + 196, + 60, + 116, + 101, + 109, + 112, + 108, + 97, + 116, + 101, + 45, + 105, + 112, + 102, + 115, + 58, + 47, + 47, + 123, + 105, + 112, + 102, + 115, + 99, + 105, + 100, + 58, + 49, + 58, + 100, + 97, + 103, + 45, + 112, + 98, + 58, + 114, + 101, + 115, + 101, + 114, + 118, + 101, + 58, + 115, + 104, + 97, + 50, + 45, + 50, + 53, + 54, + 125, + 47, + 110, + 102, + 100, + 46, + 106, + 115, + 111, + 110, + 164, + 97, + 112, + 97, + 115, + 145, + 206, + 5, + 7, + 85, + 184, + 164, + 97, + 112, + 97, + 116, + 146, + 196, + 32, + 85, + 64, + 108, + 163, + 118, + 74, + 55, + 233, + 206, + 106, + 77, + 17, + 191, + 16, + 70, + 126, + 218, + 115, + 71, + 181, + 10, + 90, + 139, + 155, + 99, + 139, + 142, + 243, + 31, + 87, + 40, + 183, + 196, + 32, + 85, + 64, + 108, + 163, + 118, + 74, + 55, + 233, + 206, + 106, + 77, + 17, + 191, + 16, + 70, + 126, + 218, + 115, + 71, + 181, + 10, + 90, + 139, + 155, + 99, + 139, + 142, + 243, + 31, + 87, + 40, + 183, + 164, + 97, + 112, + 105, + 100, + 206, + 5, + 7, + 85, + 233, + 163, + 102, + 101, + 101, + 205, + 19, + 136, + 162, + 102, + 118, + 206, + 1, + 65, + 4, + 220, + 163, + 103, + 101, + 110, + 172, + 116, + 101, + 115, + 116, + 110, + 101, + 116, + 45, + 118, + 49, + 46, + 48, + 162, + 103, + 104, + 196, + 32, + 72, + 99, + 181, + 24, + 164, + 179, + 200, + 78, + 200, + 16, + 242, + 45, + 79, + 16, + 129, + 203, + 15, + 113, + 240, + 89, + 167, + 172, + 32, + 222, + 198, + 47, + 127, + 112, + 229, + 9, + 58, + 34, + 163, + 103, + 114, + 112, + 196, + 32, + 146, + 220, + 65, + 99, + 253, + 148, + 21, + 250, + 175, + 135, + 2, + 138, + 199, + 8, + 161, + 75, + 214, + 33, + 124, + 111, + 168, + 127, + 120, + 115, + 216, + 141, + 196, + 174, + 3, + 89, + 101, + 42, + 162, + 108, + 118, + 206, + 1, + 65, + 8, + 196, + 164, + 110, + 111, + 116, + 101, + 196, + 8, + 0, + 0, + 0, + 0, + 0, + 15, + 66, + 64, + 163, + 115, + 110, + 100, + 196, + 32, + 85, + 64, + 108, + 163, + 118, + 74, + 55, + 233, + 206, + 106, + 77, + 17, + 191, + 16, + 70, + 126, + 218, + 115, + 71, + 181, + 10, + 90, + 139, + 155, + 99, + 139, + 142, + 243, + 31, + 87, + 40, + 183, + 164, + 116, + 121, + 112, + 101, + 164, + 97, + 112, + 112, + 108 + ], + "signedBytes": [ + 130, + 163, + 115, + 105, + 103, + 196, + 64, + 172, + 166, + 51, + 229, + 118, + 182, + 194, + 72, + 48, + 212, + 41, + 152, + 211, + 120, + 138, + 160, + 128, + 218, + 209, + 67, + 144, + 140, + 173, + 156, + 227, + 127, + 112, + 147, + 27, + 112, + 68, + 236, + 121, + 19, + 174, + 239, + 5, + 69, + 242, + 6, + 52, + 89, + 192, + 53, + 83, + 19, + 16, + 72, + 55, + 35, + 233, + 70, + 57, + 116, + 10, + 207, + 215, + 191, + 2, + 67, + 210, + 94, + 47, + 12, + 163, + 116, + 120, + 110, + 141, + 164, + 97, + 112, + 97, + 97, + 148, + 196, + 4, + 109, + 105, + 110, + 116, + 196, + 8, + 0, + 0, + 0, + 0, + 0, + 15, + 66, + 64, + 196, + 15, + 115, + 101, + 99, + 117, + 114, + 105, + 116, + 105, + 122, + 101, + 46, + 97, + 108, + 103, + 111, + 196, + 60, + 116, + 101, + 109, + 112, + 108, + 97, + 116, + 101, + 45, + 105, + 112, + 102, + 115, + 58, + 47, + 47, + 123, + 105, + 112, + 102, + 115, + 99, + 105, + 100, + 58, + 49, + 58, + 100, + 97, + 103, + 45, + 112, + 98, + 58, + 114, + 101, + 115, + 101, + 114, + 118, + 101, + 58, + 115, + 104, + 97, + 50, + 45, + 50, + 53, + 54, + 125, + 47, + 110, + 102, + 100, + 46, + 106, + 115, + 111, + 110, + 164, + 97, + 112, + 97, + 115, + 145, + 206, + 5, + 7, + 85, + 184, + 164, + 97, + 112, + 97, + 116, + 146, + 196, + 32, + 85, + 64, + 108, + 163, + 118, + 74, + 55, + 233, + 206, + 106, + 77, + 17, + 191, + 16, + 70, + 126, + 218, + 115, + 71, + 181, + 10, + 90, + 139, + 155, + 99, + 139, + 142, + 243, + 31, + 87, + 40, + 183, + 196, + 32, + 85, + 64, + 108, + 163, + 118, + 74, + 55, + 233, + 206, + 106, + 77, + 17, + 191, + 16, + 70, + 126, + 218, + 115, + 71, + 181, + 10, + 90, + 139, + 155, + 99, + 139, + 142, + 243, + 31, + 87, + 40, + 183, + 164, + 97, + 112, + 105, + 100, + 206, + 5, + 7, + 85, + 233, + 163, + 102, + 101, + 101, + 205, + 19, + 136, + 162, + 102, + 118, + 206, + 1, + 65, + 4, + 220, + 163, + 103, + 101, + 110, + 172, + 116, + 101, + 115, + 116, + 110, + 101, + 116, + 45, + 118, + 49, + 46, + 48, + 162, + 103, + 104, + 196, + 32, + 72, + 99, + 181, + 24, + 164, + 179, + 200, + 78, + 200, + 16, + 242, + 45, + 79, + 16, + 129, + 203, + 15, + 113, + 240, + 89, + 167, + 172, + 32, + 222, + 198, + 47, + 127, + 112, + 229, + 9, + 58, + 34, + 163, + 103, + 114, + 112, + 196, + 32, + 146, + 220, + 65, + 99, + 253, + 148, + 21, + 250, + 175, + 135, + 2, + 138, + 199, + 8, + 161, + 75, + 214, + 33, + 124, + 111, + 168, + 127, + 120, + 115, + 216, + 141, + 196, + 174, + 3, + 89, + 101, + 42, + 162, + 108, + 118, + 206, + 1, + 65, + 8, + 196, + 164, + 110, + 111, + 116, + 101, + 196, + 8, + 0, + 0, + 0, + 0, + 0, + 15, + 66, + 64, + 163, + 115, + 110, + 100, + 196, + 32, + 85, + 64, + 108, + 163, + 118, + 74, + 55, + 233, + 206, + 106, + 77, + 17, + 191, + 16, + 70, + 126, + 218, + 115, + 71, + 181, + 10, + 90, + 139, + 155, + 99, + 139, + 142, + 243, + 31, + 87, + 40, + 183, + 164, + 116, + 121, + 112, + 101, + 164, + 97, + 112, + 112, + 108 + ], + "signingPrivateKey": [ + 2, + 205, + 103, + 33, + 67, + 14, + 82, + 196, + 115, + 196, + 206, + 254, + 50, + 110, + 63, + 182, + 149, + 229, + 184, + 216, + 93, + 11, + 13, + 99, + 69, + 213, + 218, + 165, + 134, + 118, + 47, + 44 + ], + "transaction": { + "appCall": { + "accountReferences": [ + "KVAGZI3WJI36TTTKJUI36ECGP3NHGR5VBJNIXG3DROHPGH2XFC36D4HENE", + "KVAGZI3WJI36TTTKJUI36ECGP3NHGR5VBJNIXG3DROHPGH2XFC36D4HENE" + ], + "appId": 84366825, + "args": [ + [ + 109, + 105, + 110, + 116 + ], + [ + 0, + 0, + 0, + 0, + 0, + 15, + 66, + 64 + ], + [ + 115, + 101, + 99, + 117, + 114, + 105, + 116, + 105, + 122, + 101, + 46, + 97, + 108, + 103, + 111 + ], + [ + 116, + 101, + 109, + 112, + 108, + 97, + 116, + 101, + 45, + 105, + 112, + 102, + 115, + 58, + 47, + 47, + 123, + 105, + 112, + 102, + 115, + 99, + 105, + 100, + 58, + 49, + 58, + 100, + 97, + 103, + 45, + 112, + 98, + 58, + 114, + 101, + 115, + 101, + 114, + 118, + 101, + 58, + 115, + 104, + 97, + 50, + 45, + 50, + 53, + 54, + 125, + 47, + 110, + 102, + 100, + 46, + 106, + 115, + 111, + 110 + ] + ], + "assetReferences": [ + 84366776 + ], + "onComplete": "NoOp" + }, + "fee": 5000, + "firstValid": 21038300, + "genesisHash": [ + 72, + 99, + 181, + 24, + 164, + 179, + 200, + 78, + 200, + 16, + 242, + 45, + 79, + 16, + 129, + 203, + 15, + 113, + 240, + 89, + 167, + 172, + 32, + 222, + 198, + 47, + 127, + 112, + 229, + 9, + 58, + 34 + ], + "genesisId": "testnet-v1.0", + "group": [ + 146, + 220, + 65, + 99, + 253, + 148, + 21, + 250, + 175, + 135, + 2, + 138, + 199, + 8, + 161, + 75, + 214, + 33, + 124, + 111, + 168, + 127, + 120, + 115, + 216, + 141, + 196, + 174, + 3, + 89, + 101, + 42 + ], + "lastValid": 21039300, + "note": [ + 0, + 0, + 0, + 0, + 0, + 15, + 66, + 64 + ], + "sender": "KVAGZI3WJI36TTTKJUI36ECGP3NHGR5VBJNIXG3DROHPGH2XFC36D4HENE", + "transactionType": "AppCall" + }, + "unsignedBytes": [ + 84, + 88, + 141, + 164, + 97, + 112, + 97, + 97, + 148, + 196, + 4, + 109, + 105, + 110, + 116, + 196, + 8, + 0, + 0, + 0, + 0, + 0, + 15, + 66, + 64, + 196, + 15, + 115, + 101, + 99, + 117, + 114, + 105, + 116, + 105, + 122, + 101, + 46, + 97, + 108, + 103, + 111, + 196, + 60, + 116, + 101, + 109, + 112, + 108, + 97, + 116, + 101, + 45, + 105, + 112, + 102, + 115, + 58, + 47, + 47, + 123, + 105, + 112, + 102, + 115, + 99, + 105, + 100, + 58, + 49, + 58, + 100, + 97, + 103, + 45, + 112, + 98, + 58, + 114, + 101, + 115, + 101, + 114, + 118, + 101, + 58, + 115, + 104, + 97, + 50, + 45, + 50, + 53, + 54, + 125, + 47, + 110, + 102, + 100, + 46, + 106, + 115, + 111, + 110, + 164, + 97, + 112, + 97, + 115, + 145, + 206, + 5, + 7, + 85, + 184, + 164, + 97, + 112, + 97, + 116, + 146, + 196, + 32, + 85, + 64, + 108, + 163, + 118, + 74, + 55, + 233, + 206, + 106, + 77, + 17, + 191, + 16, + 70, + 126, + 218, + 115, + 71, + 181, + 10, + 90, + 139, + 155, + 99, + 139, + 142, + 243, + 31, + 87, + 40, + 183, + 196, + 32, + 85, + 64, + 108, + 163, + 118, + 74, + 55, + 233, + 206, + 106, + 77, + 17, + 191, + 16, + 70, + 126, + 218, + 115, + 71, + 181, + 10, + 90, + 139, + 155, + 99, + 139, + 142, + 243, + 31, + 87, + 40, + 183, + 164, + 97, + 112, + 105, + 100, + 206, + 5, + 7, + 85, + 233, + 163, + 102, + 101, + 101, + 205, + 19, + 136, + 162, + 102, + 118, + 206, + 1, + 65, + 4, + 220, + 163, + 103, + 101, + 110, + 172, + 116, + 101, + 115, + 116, + 110, + 101, + 116, + 45, + 118, + 49, + 46, + 48, + 162, + 103, + 104, + 196, + 32, + 72, + 99, + 181, + 24, + 164, + 179, + 200, + 78, + 200, + 16, + 242, + 45, + 79, + 16, + 129, + 203, + 15, + 113, + 240, + 89, + 167, + 172, + 32, + 222, + 198, + 47, + 127, + 112, + 229, + 9, + 58, + 34, + 163, + 103, + 114, + 112, + 196, + 32, + 146, + 220, + 65, + 99, + 253, + 148, + 21, + 250, + 175, + 135, + 2, + 138, + 199, + 8, + 161, + 75, + 214, + 33, + 124, + 111, + 168, + 127, + 120, + 115, + 216, + 141, + 196, + 174, + 3, + 89, + 101, + 42, + 162, + 108, + 118, + 206, + 1, + 65, + 8, + 196, + 164, + 110, + 111, + 116, + 101, + 196, + 8, + 0, + 0, + 0, + 0, + 0, + 15, + 66, + 64, + 163, + 115, + 110, + 100, + 196, + 32, + 85, + 64, + 108, + 163, + 118, + 74, + 55, + 233, + 206, + 106, + 77, + 17, + 191, + 16, + 70, + 126, + 218, + 115, + 71, + 181, + 10, + 90, + 139, + 155, + 99, + 139, + 142, + 243, + 31, + 87, + 40, + 183, + 164, + 116, + 121, + 112, + 101, + 164, + 97, + 112, + 112, + 108 + ] + }, + "appCreate": { + "id": "L6B56N2BAXE43PUI7IDBXCJN5DEB6NLCH4AAN3ON64CXPSCTJNTA", + "idRaw": [ + 95, + 131, + 223, + 55, + 65, + 5, + 201, + 205, + 190, + 136, + 250, + 6, + 27, + 137, + 45, + 232, + 200, + 31, + 53, + 98, + 63, + 0, + 6, + 237, + 205, + 247, + 5, + 119, + 200, + 83, + 75, + 102 + ], + "multisigAddresses": [ + "424ZV7KBBUJ52DUKP2KLQ6I5GBOHKBXOW7Q7UQIOOYNDWYRM4EKOSMVVRI", + "NY6DHEEFW73R2NUWY562U2NNKSKBKVYY5OOQFLD3M2II5RUNKRZDEGUGEA" + ], + "multisigSignedBytes": [ + 130, + 164, + 109, + 115, + 105, + 103, + 131, + 166, + 115, + 117, + 98, + 115, + 105, + 103, + 146, + 130, + 162, + 112, + 107, + 196, + 32, + 230, + 185, + 154, + 253, + 65, + 13, + 19, + 221, + 14, + 138, + 126, + 148, + 184, + 121, + 29, + 48, + 92, + 117, + 6, + 238, + 183, + 225, + 250, + 65, + 14, + 118, + 26, + 59, + 98, + 44, + 225, + 20, + 161, + 115, + 196, + 64, + 18, + 136, + 195, + 154, + 235, + 35, + 125, + 113, + 143, + 63, + 83, + 209, + 85, + 113, + 114, + 50, + 84, + 157, + 30, + 107, + 81, + 172, + 153, + 43, + 46, + 120, + 164, + 12, + 15, + 117, + 28, + 251, + 172, + 139, + 160, + 156, + 93, + 189, + 17, + 7, + 225, + 72, + 180, + 211, + 134, + 72, + 79, + 156, + 136, + 254, + 121, + 51, + 94, + 135, + 109, + 149, + 90, + 158, + 27, + 70, + 94, + 220, + 37, + 5, + 130, + 162, + 112, + 107, + 196, + 32, + 110, + 60, + 51, + 144, + 133, + 183, + 247, + 29, + 54, + 150, + 199, + 125, + 170, + 105, + 173, + 84, + 148, + 21, + 87, + 24, + 235, + 157, + 2, + 172, + 123, + 102, + 144, + 142, + 198, + 141, + 84, + 114, + 161, + 115, + 196, + 64, + 18, + 136, + 195, + 154, + 235, + 35, + 125, + 113, + 143, + 63, + 83, + 209, + 85, + 113, + 114, + 50, + 84, + 157, + 30, + 107, + 81, + 172, + 153, + 43, + 46, + 120, + 164, + 12, + 15, + 117, + 28, + 251, + 172, + 139, + 160, + 156, + 93, + 189, + 17, + 7, + 225, + 72, + 180, + 211, + 134, + 72, + 79, + 156, + 136, + 254, + 121, + 51, + 94, + 135, + 109, + 149, + 90, + 158, + 27, + 70, + 94, + 220, + 37, + 5, + 163, + 116, + 104, + 114, + 2, + 161, + 118, + 1, + 163, + 116, + 120, + 110, + 140, + 164, + 97, + 112, + 97, + 112, + 197, + 4, + 170, + 6, + 32, + 10, + 1, + 0, + 2, + 8, + 4, + 6, + 16, + 10, + 5, + 3, + 38, + 3, + 6, + 105, + 46, + 97, + 112, + 112, + 115, + 8, + 97, + 100, + 100, + 95, + 97, + 100, + 100, + 114, + 0, + 49, + 22, + 36, + 12, + 64, + 2, + 166, + 49, + 22, + 34, + 9, + 53, + 0, + 35, + 64, + 2, + 154, + 49, + 25, + 33, + 8, + 18, + 64, + 2, + 144, + 49, + 25, + 33, + 4, + 18, + 64, + 2, + 130, + 49, + 24, + 35, + 18, + 64, + 2, + 121, + 49, + 25, + 36, + 18, + 64, + 2, + 112, + 49, + 25, + 34, + 18, + 64, + 1, + 191, + 49, + 25, + 35, + 18, + 64, + 0, + 1, + 0, + 54, + 26, + 0, + 128, + 3, + 103, + 97, + 115, + 18, + 64, + 1, + 169, + 50, + 4, + 36, + 15, + 52, + 0, + 56, + 16, + 34, + 18, + 16, + 52, + 0, + 56, + 32, + 50, + 3, + 18, + 16, + 52, + 0, + 56, + 9, + 50, + 3, + 18, + 16, + 52, + 0, + 56, + 8, + 50, + 0, + 15, + 52, + 0, + 56, + 1, + 50, + 0, + 13, + 17, + 16, + 52, + 0, + 136, + 2, + 129, + 34, + 18, + 16, + 64, + 0, + 2, + 35, + 67, + 49, + 27, + 36, + 18, + 54, + 26, + 0, + 41, + 18, + 16, + 49, + 22, + 34, + 9, + 56, + 7, + 49, + 0, + 18, + 16, + 64, + 1, + 75, + 49, + 27, + 36, + 18, + 54, + 26, + 0, + 128, + 11, + 114, + 101, + 109, + 111, + 118, + 101, + 95, + 97, + 100, + 100, + 114, + 18, + 16, + 49, + 22, + 34, + 9, + 56, + 7, + 49, + 0, + 18, + 16, + 64, + 1, + 25, + 50, + 4, + 33, + 4, + 15, + 54, + 26, + 0, + 128, + 4, + 109, + 105, + 110, + 116, + 18, + 16, + 49, + 27, + 33, + 4, + 18, + 16, + 64, + 0, + 1, + 0, + 49, + 22, + 33, + 9, + 9, + 56, + 61, + 53, + 1, + 52, + 1, + 114, + 8, + 53, + 4, + 53, + 3, + 49, + 22, + 34, + 9, + 136, + 2, + 13, + 49, + 22, + 136, + 2, + 8, + 16, + 20, + 64, + 0, + 219, + 49, + 22, + 36, + 9, + 136, + 1, + 252, + 49, + 22, + 36, + 9, + 56, + 8, + 35, + 18, + 16, + 64, + 0, + 194, + 54, + 26, + 1, + 23, + 53, + 2, + 49, + 22, + 36, + 9, + 56, + 7, + 50, + 10, + 18, + 49, + 22, + 36, + 9, + 56, + 8, + 52, + 2, + 18, + 16, + 49, + 22, + 34, + 9, + 56, + 7, + 50, + 10, + 18, + 16, + 49, + 22, + 34, + 9, + 56, + 8, + 129, + 192, + 154, + 12, + 18, + 16, + 49, + 24, + 50, + 8, + 18, + 16, + 49, + 16, + 33, + 5, + 18, + 16, + 20, + 64, + 0, + 129, + 177, + 34, + 178, + 16, + 49, + 22, + 34, + 9, + 56, + 8, + 52, + 2, + 8, + 178, + 8, + 52, + 3, + 178, + 7, + 35, + 178, + 1, + 182, + 33, + 5, + 178, + 16, + 35, + 178, + 25, + 49, + 0, + 178, + 28, + 54, + 48, + 0, + 178, + 48, + 52, + 1, + 178, + 24, + 54, + 26, + 0, + 178, + 26, + 54, + 26, + 2, + 178, + 26, + 54, + 26, + 3, + 178, + 26, + 35, + 178, + 1, + 182, + 33, + 5, + 178, + 16, + 35, + 178, + 25, + 49, + 0, + 178, + 28, + 54, + 48, + 0, + 178, + 48, + 52, + 1, + 178, + 24, + 128, + 14, + 111, + 102, + 102, + 101, + 114, + 95, + 102, + 111, + 114, + 95, + 115, + 97, + 108, + 101, + 178, + 26, + 54, + 26, + 1, + 178, + 26, + 49, + 22, + 33, + 9, + 9, + 57, + 26, + 3, + 178, + 26, + 35, + 178, + 1, + 179, + 184, + 1, + 58, + 0, + 53, + 200, + 34, + 66, + 254, + 182, + 35, + 67, + 35, + 53, + 2, + 66, + 255, + 62, + 35, + 67, + 49, + 0, + 40, + 33, + 6, + 54, + 26, + 1, + 23, + 136, + 2, + 117, + 66, + 254, + 157, + 49, + 0, + 40, + 33, + 6, + 54, + 26, + 1, + 23, + 136, + 2, + 50, + 66, + 254, + 142, + 34, + 67, + 50, + 4, + 36, + 15, + 52, + 0, + 56, + 16, + 34, + 18, + 16, + 52, + 0, + 56, + 32, + 50, + 3, + 18, + 16, + 52, + 0, + 56, + 9, + 50, + 3, + 18, + 16, + 52, + 0, + 56, + 8, + 50, + 0, + 15, + 52, + 0, + 56, + 1, + 50, + 0, + 13, + 17, + 16, + 52, + 0, + 136, + 0, + 214, + 34, + 18, + 16, + 52, + 0, + 56, + 7, + 49, + 0, + 18, + 16, + 64, + 0, + 2, + 35, + 67, + 50, + 4, + 36, + 15, + 49, + 27, + 34, + 18, + 16, + 54, + 26, + 0, + 128, + 6, + 97, + 115, + 115, + 105, + 103, + 110, + 18, + 16, + 64, + 0, + 39, + 49, + 27, + 36, + 18, + 54, + 26, + 0, + 41, + 18, + 16, + 49, + 22, + 34, + 9, + 56, + 7, + 49, + 0, + 18, + 16, + 64, + 0, + 1, + 0, + 49, + 0, + 40, + 33, + 6, + 54, + 26, + 1, + 23, + 136, + 1, + 176, + 66, + 255, + 191, + 49, + 0, + 128, + 7, + 105, + 46, + 97, + 115, + 97, + 105, + 100, + 49, + 22, + 36, + 9, + 59, + 200, + 102, + 49, + 0, + 128, + 7, + 105, + 46, + 97, + 112, + 112, + 105, + 100, + 49, + 22, + 33, + 8, + 9, + 56, + 61, + 22, + 102, + 34, + 66, + 255, + 149, + 34, + 67, + 34, + 67, + 49, + 0, + 50, + 9, + 18, + 67, + 35, + 67, + 35, + 67, + 35, + 53, + 0, + 66, + 253, + 90, + 53, + 14, + 128, + 10, + 48, + 49, + 50, + 51, + 52, + 53, + 54, + 55, + 56, + 57, + 52, + 14, + 34, + 88, + 137, + 53, + 13, + 52, + 13, + 35, + 18, + 64, + 0, + 40, + 52, + 13, + 33, + 7, + 10, + 35, + 13, + 64, + 0, + 13, + 42, + 52, + 13, + 33, + 7, + 24, + 136, + 255, + 209, + 80, + 66, + 0, + 20, + 52, + 13, + 33, + 7, + 10, + 52, + 13, + 76, + 136, + 255, + 213, + 76, + 53, + 13, + 66, + 255, + 227, + 128, + 1, + 48, + 137, + 53, + 5, + 52, + 5, + 56, + 0, + 129, + 184, + 171, + 157, + 40, + 112, + 0, + 53, + 7, + 53, + 6, + 52, + 6, + 34, + 18, + 52, + 5, + 56, + 9, + 50, + 3, + 18, + 16, + 52, + 5, + 56, + 32, + 50, + 3, + 18, + 16, + 137, + 53, + 23, + 53, + 22, + 53, + 21, + 52, + 21, + 52, + 22, + 52, + 23, + 99, + 53, + 25, + 53, + 24, + 52, + 25, + 64, + 0, + 4, + 42, + 66, + 0, + 2, + 52, + 24, + 137, + 53, + 17, + 53, + 16, + 53, + 15, + 52, + 15, + 50, + 8, + 52, + 16, + 136, + 255, + 212, + 21, + 35, + 18, + 64, + 0, + 113, + 52, + 15, + 52, + 16, + 98, + 53, + 18, + 35, + 53, + 19, + 52, + 19, + 52, + 18, + 21, + 37, + 10, + 12, + 64, + 0, + 25, + 52, + 18, + 21, + 129, + 120, + 12, + 64, + 0, + 2, + 35, + 137, + 52, + 15, + 52, + 16, + 52, + 18, + 52, + 17, + 22, + 80, + 102, + 66, + 0, + 77, + 52, + 18, + 52, + 19, + 37, + 11, + 91, + 53, + 20, + 52, + 20, + 35, + 18, + 64, + 0, + 19, + 52, + 20, + 52, + 17, + 18, + 64, + 0, + 9, + 52, + 19, + 34, + 8, + 53, + 19, + 66, + 255, + 187, + 34, + 137, + 52, + 15, + 52, + 16, + 52, + 18, + 35, + 52, + 19, + 37, + 11, + 82, + 52, + 17, + 22, + 80, + 52, + 18, + 52, + 19, + 37, + 11, + 37, + 8, + 52, + 18, + 21, + 82, + 80, + 102, + 34, + 137, + 52, + 15, + 52, + 16, + 52, + 17, + 22, + 102, + 34, + 137, + 34, + 137, + 53, + 33, + 53, + 32, + 53, + 31, + 52, + 31, + 52, + 32, + 98, + 53, + 34, + 35, + 53, + 35, + 52, + 35, + 52, + 34, + 21, + 37, + 10, + 12, + 65, + 0, + 53, + 52, + 34, + 52, + 35, + 37, + 11, + 91, + 52, + 33, + 18, + 64, + 0, + 9, + 52, + 35, + 34, + 8, + 53, + 35, + 66, + 255, + 223, + 52, + 31, + 52, + 32, + 52, + 34, + 35, + 52, + 35, + 37, + 11, + 82, + 35, + 22, + 80, + 52, + 34, + 52, + 35, + 37, + 11, + 37, + 8, + 52, + 34, + 21, + 82, + 80, + 102, + 34, + 137, + 35, + 137, + 53, + 11, + 53, + 10, + 53, + 9, + 53, + 8, + 35, + 53, + 12, + 52, + 12, + 52, + 10, + 12, + 65, + 0, + 31, + 52, + 8, + 52, + 9, + 52, + 12, + 136, + 254, + 136, + 80, + 52, + 11, + 136, + 254, + 250, + 34, + 18, + 64, + 0, + 9, + 52, + 12, + 34, + 8, + 53, + 12, + 66, + 255, + 219, + 34, + 137, + 35, + 137, + 53, + 29, + 53, + 28, + 53, + 27, + 53, + 26, + 35, + 53, + 30, + 52, + 30, + 52, + 28, + 12, + 65, + 0, + 31, + 52, + 26, + 52, + 27, + 52, + 30, + 136, + 254, + 84, + 80, + 52, + 29, + 136, + 255, + 88, + 34, + 18, + 64, + 0, + 9, + 52, + 30, + 34, + 8, + 53, + 30, + 66, + 255, + 219, + 34, + 137, + 35, + 137, + 164, + 97, + 112, + 101, + 112, + 3, + 164, + 97, + 112, + 108, + 115, + 129, + 163, + 110, + 98, + 115, + 16, + 164, + 97, + 112, + 115, + 117, + 196, + 4, + 6, + 129, + 1, + 67, + 163, + 102, + 101, + 101, + 205, + 3, + 232, + 162, + 102, + 118, + 206, + 1, + 65, + 3, + 233, + 163, + 103, + 101, + 110, + 172, + 116, + 101, + 115, + 116, + 110, + 101, + 116, + 45, + 118, + 49, + 46, + 48, + 162, + 103, + 104, + 196, + 32, + 72, + 99, + 181, + 24, + 164, + 179, + 200, + 78, + 200, + 16, + 242, + 45, + 79, + 16, + 129, + 203, + 15, + 113, + 240, + 89, + 167, + 172, + 32, + 222, + 198, + 47, + 127, + 112, + 229, + 9, + 58, + 34, + 162, + 108, + 118, + 206, + 1, + 65, + 7, + 209, + 164, + 110, + 111, + 116, + 101, + 196, + 21, + 78, + 70, + 68, + 32, + 82, + 101, + 103, + 105, + 115, + 116, + 114, + 121, + 32, + 67, + 111, + 110, + 116, + 114, + 97, + 99, + 116, + 163, + 115, + 110, + 100, + 196, + 32, + 222, + 61, + 163, + 205, + 60, + 182, + 36, + 130, + 40, + 95, + 229, + 201, + 178, + 233, + 37, + 20, + 191, + 255, + 240, + 141, + 216, + 176, + 218, + 30, + 2, + 33, + 80, + 223, + 192, + 56, + 40, + 44, + 164, + 116, + 121, + 112, + 101, + 164, + 97, + 112, + 112, + 108 + ], + "rekeyedSenderAuthAddress": "BKDYDIDVSZCP75JVCB76P3WBJRY6HWAIFDSEOKYHJY5WMNJ2UWJ65MYETU", + "rekeyedSenderSignedBytes": [ + 131, + 164, + 115, + 103, + 110, + 114, + 196, + 32, + 10, + 135, + 129, + 160, + 117, + 150, + 68, + 255, + 245, + 53, + 16, + 127, + 231, + 238, + 193, + 76, + 113, + 227, + 216, + 8, + 40, + 228, + 71, + 43, + 7, + 78, + 59, + 102, + 53, + 58, + 165, + 147, + 163, + 115, + 105, + 103, + 196, + 64, + 18, + 136, + 195, + 154, + 235, + 35, + 125, + 113, + 143, + 63, + 83, + 209, + 85, + 113, + 114, + 50, + 84, + 157, + 30, + 107, + 81, + 172, + 153, + 43, + 46, + 120, + 164, + 12, + 15, + 117, + 28, + 251, + 172, + 139, + 160, + 156, + 93, + 189, + 17, + 7, + 225, + 72, + 180, + 211, + 134, + 72, + 79, + 156, + 136, + 254, + 121, + 51, + 94, + 135, + 109, + 149, + 90, + 158, + 27, + 70, + 94, + 220, + 37, + 5, + 163, + 116, + 120, + 110, + 140, + 164, + 97, + 112, + 97, + 112, + 197, + 4, + 170, + 6, + 32, + 10, + 1, + 0, + 2, + 8, + 4, + 6, + 16, + 10, + 5, + 3, + 38, + 3, + 6, + 105, + 46, + 97, + 112, + 112, + 115, + 8, + 97, + 100, + 100, + 95, + 97, + 100, + 100, + 114, + 0, + 49, + 22, + 36, + 12, + 64, + 2, + 166, + 49, + 22, + 34, + 9, + 53, + 0, + 35, + 64, + 2, + 154, + 49, + 25, + 33, + 8, + 18, + 64, + 2, + 144, + 49, + 25, + 33, + 4, + 18, + 64, + 2, + 130, + 49, + 24, + 35, + 18, + 64, + 2, + 121, + 49, + 25, + 36, + 18, + 64, + 2, + 112, + 49, + 25, + 34, + 18, + 64, + 1, + 191, + 49, + 25, + 35, + 18, + 64, + 0, + 1, + 0, + 54, + 26, + 0, + 128, + 3, + 103, + 97, + 115, + 18, + 64, + 1, + 169, + 50, + 4, + 36, + 15, + 52, + 0, + 56, + 16, + 34, + 18, + 16, + 52, + 0, + 56, + 32, + 50, + 3, + 18, + 16, + 52, + 0, + 56, + 9, + 50, + 3, + 18, + 16, + 52, + 0, + 56, + 8, + 50, + 0, + 15, + 52, + 0, + 56, + 1, + 50, + 0, + 13, + 17, + 16, + 52, + 0, + 136, + 2, + 129, + 34, + 18, + 16, + 64, + 0, + 2, + 35, + 67, + 49, + 27, + 36, + 18, + 54, + 26, + 0, + 41, + 18, + 16, + 49, + 22, + 34, + 9, + 56, + 7, + 49, + 0, + 18, + 16, + 64, + 1, + 75, + 49, + 27, + 36, + 18, + 54, + 26, + 0, + 128, + 11, + 114, + 101, + 109, + 111, + 118, + 101, + 95, + 97, + 100, + 100, + 114, + 18, + 16, + 49, + 22, + 34, + 9, + 56, + 7, + 49, + 0, + 18, + 16, + 64, + 1, + 25, + 50, + 4, + 33, + 4, + 15, + 54, + 26, + 0, + 128, + 4, + 109, + 105, + 110, + 116, + 18, + 16, + 49, + 27, + 33, + 4, + 18, + 16, + 64, + 0, + 1, + 0, + 49, + 22, + 33, + 9, + 9, + 56, + 61, + 53, + 1, + 52, + 1, + 114, + 8, + 53, + 4, + 53, + 3, + 49, + 22, + 34, + 9, + 136, + 2, + 13, + 49, + 22, + 136, + 2, + 8, + 16, + 20, + 64, + 0, + 219, + 49, + 22, + 36, + 9, + 136, + 1, + 252, + 49, + 22, + 36, + 9, + 56, + 8, + 35, + 18, + 16, + 64, + 0, + 194, + 54, + 26, + 1, + 23, + 53, + 2, + 49, + 22, + 36, + 9, + 56, + 7, + 50, + 10, + 18, + 49, + 22, + 36, + 9, + 56, + 8, + 52, + 2, + 18, + 16, + 49, + 22, + 34, + 9, + 56, + 7, + 50, + 10, + 18, + 16, + 49, + 22, + 34, + 9, + 56, + 8, + 129, + 192, + 154, + 12, + 18, + 16, + 49, + 24, + 50, + 8, + 18, + 16, + 49, + 16, + 33, + 5, + 18, + 16, + 20, + 64, + 0, + 129, + 177, + 34, + 178, + 16, + 49, + 22, + 34, + 9, + 56, + 8, + 52, + 2, + 8, + 178, + 8, + 52, + 3, + 178, + 7, + 35, + 178, + 1, + 182, + 33, + 5, + 178, + 16, + 35, + 178, + 25, + 49, + 0, + 178, + 28, + 54, + 48, + 0, + 178, + 48, + 52, + 1, + 178, + 24, + 54, + 26, + 0, + 178, + 26, + 54, + 26, + 2, + 178, + 26, + 54, + 26, + 3, + 178, + 26, + 35, + 178, + 1, + 182, + 33, + 5, + 178, + 16, + 35, + 178, + 25, + 49, + 0, + 178, + 28, + 54, + 48, + 0, + 178, + 48, + 52, + 1, + 178, + 24, + 128, + 14, + 111, + 102, + 102, + 101, + 114, + 95, + 102, + 111, + 114, + 95, + 115, + 97, + 108, + 101, + 178, + 26, + 54, + 26, + 1, + 178, + 26, + 49, + 22, + 33, + 9, + 9, + 57, + 26, + 3, + 178, + 26, + 35, + 178, + 1, + 179, + 184, + 1, + 58, + 0, + 53, + 200, + 34, + 66, + 254, + 182, + 35, + 67, + 35, + 53, + 2, + 66, + 255, + 62, + 35, + 67, + 49, + 0, + 40, + 33, + 6, + 54, + 26, + 1, + 23, + 136, + 2, + 117, + 66, + 254, + 157, + 49, + 0, + 40, + 33, + 6, + 54, + 26, + 1, + 23, + 136, + 2, + 50, + 66, + 254, + 142, + 34, + 67, + 50, + 4, + 36, + 15, + 52, + 0, + 56, + 16, + 34, + 18, + 16, + 52, + 0, + 56, + 32, + 50, + 3, + 18, + 16, + 52, + 0, + 56, + 9, + 50, + 3, + 18, + 16, + 52, + 0, + 56, + 8, + 50, + 0, + 15, + 52, + 0, + 56, + 1, + 50, + 0, + 13, + 17, + 16, + 52, + 0, + 136, + 0, + 214, + 34, + 18, + 16, + 52, + 0, + 56, + 7, + 49, + 0, + 18, + 16, + 64, + 0, + 2, + 35, + 67, + 50, + 4, + 36, + 15, + 49, + 27, + 34, + 18, + 16, + 54, + 26, + 0, + 128, + 6, + 97, + 115, + 115, + 105, + 103, + 110, + 18, + 16, + 64, + 0, + 39, + 49, + 27, + 36, + 18, + 54, + 26, + 0, + 41, + 18, + 16, + 49, + 22, + 34, + 9, + 56, + 7, + 49, + 0, + 18, + 16, + 64, + 0, + 1, + 0, + 49, + 0, + 40, + 33, + 6, + 54, + 26, + 1, + 23, + 136, + 1, + 176, + 66, + 255, + 191, + 49, + 0, + 128, + 7, + 105, + 46, + 97, + 115, + 97, + 105, + 100, + 49, + 22, + 36, + 9, + 59, + 200, + 102, + 49, + 0, + 128, + 7, + 105, + 46, + 97, + 112, + 112, + 105, + 100, + 49, + 22, + 33, + 8, + 9, + 56, + 61, + 22, + 102, + 34, + 66, + 255, + 149, + 34, + 67, + 34, + 67, + 49, + 0, + 50, + 9, + 18, + 67, + 35, + 67, + 35, + 67, + 35, + 53, + 0, + 66, + 253, + 90, + 53, + 14, + 128, + 10, + 48, + 49, + 50, + 51, + 52, + 53, + 54, + 55, + 56, + 57, + 52, + 14, + 34, + 88, + 137, + 53, + 13, + 52, + 13, + 35, + 18, + 64, + 0, + 40, + 52, + 13, + 33, + 7, + 10, + 35, + 13, + 64, + 0, + 13, + 42, + 52, + 13, + 33, + 7, + 24, + 136, + 255, + 209, + 80, + 66, + 0, + 20, + 52, + 13, + 33, + 7, + 10, + 52, + 13, + 76, + 136, + 255, + 213, + 76, + 53, + 13, + 66, + 255, + 227, + 128, + 1, + 48, + 137, + 53, + 5, + 52, + 5, + 56, + 0, + 129, + 184, + 171, + 157, + 40, + 112, + 0, + 53, + 7, + 53, + 6, + 52, + 6, + 34, + 18, + 52, + 5, + 56, + 9, + 50, + 3, + 18, + 16, + 52, + 5, + 56, + 32, + 50, + 3, + 18, + 16, + 137, + 53, + 23, + 53, + 22, + 53, + 21, + 52, + 21, + 52, + 22, + 52, + 23, + 99, + 53, + 25, + 53, + 24, + 52, + 25, + 64, + 0, + 4, + 42, + 66, + 0, + 2, + 52, + 24, + 137, + 53, + 17, + 53, + 16, + 53, + 15, + 52, + 15, + 50, + 8, + 52, + 16, + 136, + 255, + 212, + 21, + 35, + 18, + 64, + 0, + 113, + 52, + 15, + 52, + 16, + 98, + 53, + 18, + 35, + 53, + 19, + 52, + 19, + 52, + 18, + 21, + 37, + 10, + 12, + 64, + 0, + 25, + 52, + 18, + 21, + 129, + 120, + 12, + 64, + 0, + 2, + 35, + 137, + 52, + 15, + 52, + 16, + 52, + 18, + 52, + 17, + 22, + 80, + 102, + 66, + 0, + 77, + 52, + 18, + 52, + 19, + 37, + 11, + 91, + 53, + 20, + 52, + 20, + 35, + 18, + 64, + 0, + 19, + 52, + 20, + 52, + 17, + 18, + 64, + 0, + 9, + 52, + 19, + 34, + 8, + 53, + 19, + 66, + 255, + 187, + 34, + 137, + 52, + 15, + 52, + 16, + 52, + 18, + 35, + 52, + 19, + 37, + 11, + 82, + 52, + 17, + 22, + 80, + 52, + 18, + 52, + 19, + 37, + 11, + 37, + 8, + 52, + 18, + 21, + 82, + 80, + 102, + 34, + 137, + 52, + 15, + 52, + 16, + 52, + 17, + 22, + 102, + 34, + 137, + 34, + 137, + 53, + 33, + 53, + 32, + 53, + 31, + 52, + 31, + 52, + 32, + 98, + 53, + 34, + 35, + 53, + 35, + 52, + 35, + 52, + 34, + 21, + 37, + 10, + 12, + 65, + 0, + 53, + 52, + 34, + 52, + 35, + 37, + 11, + 91, + 52, + 33, + 18, + 64, + 0, + 9, + 52, + 35, + 34, + 8, + 53, + 35, + 66, + 255, + 223, + 52, + 31, + 52, + 32, + 52, + 34, + 35, + 52, + 35, + 37, + 11, + 82, + 35, + 22, + 80, + 52, + 34, + 52, + 35, + 37, + 11, + 37, + 8, + 52, + 34, + 21, + 82, + 80, + 102, + 34, + 137, + 35, + 137, + 53, + 11, + 53, + 10, + 53, + 9, + 53, + 8, + 35, + 53, + 12, + 52, + 12, + 52, + 10, + 12, + 65, + 0, + 31, + 52, + 8, + 52, + 9, + 52, + 12, + 136, + 254, + 136, + 80, + 52, + 11, + 136, + 254, + 250, + 34, + 18, + 64, + 0, + 9, + 52, + 12, + 34, + 8, + 53, + 12, + 66, + 255, + 219, + 34, + 137, + 35, + 137, + 53, + 29, + 53, + 28, + 53, + 27, + 53, + 26, + 35, + 53, + 30, + 52, + 30, + 52, + 28, + 12, + 65, + 0, + 31, + 52, + 26, + 52, + 27, + 52, + 30, + 136, + 254, + 84, + 80, + 52, + 29, + 136, + 255, + 88, + 34, + 18, + 64, + 0, + 9, + 52, + 30, + 34, + 8, + 53, + 30, + 66, + 255, + 219, + 34, + 137, + 35, + 137, + 164, + 97, + 112, + 101, + 112, + 3, + 164, + 97, + 112, + 108, + 115, + 129, + 163, + 110, + 98, + 115, + 16, + 164, + 97, + 112, + 115, + 117, + 196, + 4, + 6, + 129, + 1, + 67, + 163, + 102, + 101, + 101, + 205, + 3, + 232, + 162, + 102, + 118, + 206, + 1, + 65, + 3, + 233, + 163, + 103, + 101, + 110, + 172, + 116, + 101, + 115, + 116, + 110, + 101, + 116, + 45, + 118, + 49, + 46, + 48, + 162, + 103, + 104, + 196, + 32, + 72, + 99, + 181, + 24, + 164, + 179, + 200, + 78, + 200, + 16, + 242, + 45, + 79, + 16, + 129, + 203, + 15, + 113, + 240, + 89, + 167, + 172, + 32, + 222, + 198, + 47, + 127, + 112, + 229, + 9, + 58, + 34, + 162, + 108, + 118, + 206, + 1, + 65, + 7, + 209, + 164, + 110, + 111, + 116, + 101, + 196, + 21, + 78, + 70, + 68, + 32, + 82, + 101, + 103, + 105, + 115, + 116, + 114, + 121, + 32, + 67, + 111, + 110, + 116, + 114, + 97, + 99, + 116, + 163, + 115, + 110, + 100, + 196, + 32, + 222, + 61, + 163, + 205, + 60, + 182, + 36, + 130, + 40, + 95, + 229, + 201, + 178, + 233, + 37, + 20, + 191, + 255, + 240, + 141, + 216, + 176, + 218, + 30, + 2, + 33, + 80, + 223, + 192, + 56, + 40, + 44, + 164, + 116, + 121, + 112, + 101, + 164, + 97, + 112, + 112, + 108 + ], + "signedBytes": [ + 130, + 163, + 115, + 105, + 103, + 196, + 64, + 18, + 136, + 195, + 154, + 235, + 35, + 125, + 113, + 143, + 63, + 83, + 209, + 85, + 113, + 114, + 50, + 84, + 157, + 30, + 107, + 81, + 172, + 153, + 43, + 46, + 120, + 164, + 12, + 15, + 117, + 28, + 251, + 172, + 139, + 160, + 156, + 93, + 189, + 17, + 7, + 225, + 72, + 180, + 211, + 134, + 72, + 79, + 156, + 136, + 254, + 121, + 51, + 94, + 135, + 109, + 149, + 90, + 158, + 27, + 70, + 94, + 220, + 37, + 5, + 163, + 116, + 120, + 110, + 140, + 164, + 97, + 112, + 97, + 112, + 197, + 4, + 170, + 6, + 32, + 10, + 1, + 0, + 2, + 8, + 4, + 6, + 16, + 10, + 5, + 3, + 38, + 3, + 6, + 105, + 46, + 97, + 112, + 112, + 115, + 8, + 97, + 100, + 100, + 95, + 97, + 100, + 100, + 114, + 0, + 49, + 22, + 36, + 12, + 64, + 2, + 166, + 49, + 22, + 34, + 9, + 53, + 0, + 35, + 64, + 2, + 154, + 49, + 25, + 33, + 8, + 18, + 64, + 2, + 144, + 49, + 25, + 33, + 4, + 18, + 64, + 2, + 130, + 49, + 24, + 35, + 18, + 64, + 2, + 121, + 49, + 25, + 36, + 18, + 64, + 2, + 112, + 49, + 25, + 34, + 18, + 64, + 1, + 191, + 49, + 25, + 35, + 18, + 64, + 0, + 1, + 0, + 54, + 26, + 0, + 128, + 3, + 103, + 97, + 115, + 18, + 64, + 1, + 169, + 50, + 4, + 36, + 15, + 52, + 0, + 56, + 16, + 34, + 18, + 16, + 52, + 0, + 56, + 32, + 50, + 3, + 18, + 16, + 52, + 0, + 56, + 9, + 50, + 3, + 18, + 16, + 52, + 0, + 56, + 8, + 50, + 0, + 15, + 52, + 0, + 56, + 1, + 50, + 0, + 13, + 17, + 16, + 52, + 0, + 136, + 2, + 129, + 34, + 18, + 16, + 64, + 0, + 2, + 35, + 67, + 49, + 27, + 36, + 18, + 54, + 26, + 0, + 41, + 18, + 16, + 49, + 22, + 34, + 9, + 56, + 7, + 49, + 0, + 18, + 16, + 64, + 1, + 75, + 49, + 27, + 36, + 18, + 54, + 26, + 0, + 128, + 11, + 114, + 101, + 109, + 111, + 118, + 101, + 95, + 97, + 100, + 100, + 114, + 18, + 16, + 49, + 22, + 34, + 9, + 56, + 7, + 49, + 0, + 18, + 16, + 64, + 1, + 25, + 50, + 4, + 33, + 4, + 15, + 54, + 26, + 0, + 128, + 4, + 109, + 105, + 110, + 116, + 18, + 16, + 49, + 27, + 33, + 4, + 18, + 16, + 64, + 0, + 1, + 0, + 49, + 22, + 33, + 9, + 9, + 56, + 61, + 53, + 1, + 52, + 1, + 114, + 8, + 53, + 4, + 53, + 3, + 49, + 22, + 34, + 9, + 136, + 2, + 13, + 49, + 22, + 136, + 2, + 8, + 16, + 20, + 64, + 0, + 219, + 49, + 22, + 36, + 9, + 136, + 1, + 252, + 49, + 22, + 36, + 9, + 56, + 8, + 35, + 18, + 16, + 64, + 0, + 194, + 54, + 26, + 1, + 23, + 53, + 2, + 49, + 22, + 36, + 9, + 56, + 7, + 50, + 10, + 18, + 49, + 22, + 36, + 9, + 56, + 8, + 52, + 2, + 18, + 16, + 49, + 22, + 34, + 9, + 56, + 7, + 50, + 10, + 18, + 16, + 49, + 22, + 34, + 9, + 56, + 8, + 129, + 192, + 154, + 12, + 18, + 16, + 49, + 24, + 50, + 8, + 18, + 16, + 49, + 16, + 33, + 5, + 18, + 16, + 20, + 64, + 0, + 129, + 177, + 34, + 178, + 16, + 49, + 22, + 34, + 9, + 56, + 8, + 52, + 2, + 8, + 178, + 8, + 52, + 3, + 178, + 7, + 35, + 178, + 1, + 182, + 33, + 5, + 178, + 16, + 35, + 178, + 25, + 49, + 0, + 178, + 28, + 54, + 48, + 0, + 178, + 48, + 52, + 1, + 178, + 24, + 54, + 26, + 0, + 178, + 26, + 54, + 26, + 2, + 178, + 26, + 54, + 26, + 3, + 178, + 26, + 35, + 178, + 1, + 182, + 33, + 5, + 178, + 16, + 35, + 178, + 25, + 49, + 0, + 178, + 28, + 54, + 48, + 0, + 178, + 48, + 52, + 1, + 178, + 24, + 128, + 14, + 111, + 102, + 102, + 101, + 114, + 95, + 102, + 111, + 114, + 95, + 115, + 97, + 108, + 101, + 178, + 26, + 54, + 26, + 1, + 178, + 26, + 49, + 22, + 33, + 9, + 9, + 57, + 26, + 3, + 178, + 26, + 35, + 178, + 1, + 179, + 184, + 1, + 58, + 0, + 53, + 200, + 34, + 66, + 254, + 182, + 35, + 67, + 35, + 53, + 2, + 66, + 255, + 62, + 35, + 67, + 49, + 0, + 40, + 33, + 6, + 54, + 26, + 1, + 23, + 136, + 2, + 117, + 66, + 254, + 157, + 49, + 0, + 40, + 33, + 6, + 54, + 26, + 1, + 23, + 136, + 2, + 50, + 66, + 254, + 142, + 34, + 67, + 50, + 4, + 36, + 15, + 52, + 0, + 56, + 16, + 34, + 18, + 16, + 52, + 0, + 56, + 32, + 50, + 3, + 18, + 16, + 52, + 0, + 56, + 9, + 50, + 3, + 18, + 16, + 52, + 0, + 56, + 8, + 50, + 0, + 15, + 52, + 0, + 56, + 1, + 50, + 0, + 13, + 17, + 16, + 52, + 0, + 136, + 0, + 214, + 34, + 18, + 16, + 52, + 0, + 56, + 7, + 49, + 0, + 18, + 16, + 64, + 0, + 2, + 35, + 67, + 50, + 4, + 36, + 15, + 49, + 27, + 34, + 18, + 16, + 54, + 26, + 0, + 128, + 6, + 97, + 115, + 115, + 105, + 103, + 110, + 18, + 16, + 64, + 0, + 39, + 49, + 27, + 36, + 18, + 54, + 26, + 0, + 41, + 18, + 16, + 49, + 22, + 34, + 9, + 56, + 7, + 49, + 0, + 18, + 16, + 64, + 0, + 1, + 0, + 49, + 0, + 40, + 33, + 6, + 54, + 26, + 1, + 23, + 136, + 1, + 176, + 66, + 255, + 191, + 49, + 0, + 128, + 7, + 105, + 46, + 97, + 115, + 97, + 105, + 100, + 49, + 22, + 36, + 9, + 59, + 200, + 102, + 49, + 0, + 128, + 7, + 105, + 46, + 97, + 112, + 112, + 105, + 100, + 49, + 22, + 33, + 8, + 9, + 56, + 61, + 22, + 102, + 34, + 66, + 255, + 149, + 34, + 67, + 34, + 67, + 49, + 0, + 50, + 9, + 18, + 67, + 35, + 67, + 35, + 67, + 35, + 53, + 0, + 66, + 253, + 90, + 53, + 14, + 128, + 10, + 48, + 49, + 50, + 51, + 52, + 53, + 54, + 55, + 56, + 57, + 52, + 14, + 34, + 88, + 137, + 53, + 13, + 52, + 13, + 35, + 18, + 64, + 0, + 40, + 52, + 13, + 33, + 7, + 10, + 35, + 13, + 64, + 0, + 13, + 42, + 52, + 13, + 33, + 7, + 24, + 136, + 255, + 209, + 80, + 66, + 0, + 20, + 52, + 13, + 33, + 7, + 10, + 52, + 13, + 76, + 136, + 255, + 213, + 76, + 53, + 13, + 66, + 255, + 227, + 128, + 1, + 48, + 137, + 53, + 5, + 52, + 5, + 56, + 0, + 129, + 184, + 171, + 157, + 40, + 112, + 0, + 53, + 7, + 53, + 6, + 52, + 6, + 34, + 18, + 52, + 5, + 56, + 9, + 50, + 3, + 18, + 16, + 52, + 5, + 56, + 32, + 50, + 3, + 18, + 16, + 137, + 53, + 23, + 53, + 22, + 53, + 21, + 52, + 21, + 52, + 22, + 52, + 23, + 99, + 53, + 25, + 53, + 24, + 52, + 25, + 64, + 0, + 4, + 42, + 66, + 0, + 2, + 52, + 24, + 137, + 53, + 17, + 53, + 16, + 53, + 15, + 52, + 15, + 50, + 8, + 52, + 16, + 136, + 255, + 212, + 21, + 35, + 18, + 64, + 0, + 113, + 52, + 15, + 52, + 16, + 98, + 53, + 18, + 35, + 53, + 19, + 52, + 19, + 52, + 18, + 21, + 37, + 10, + 12, + 64, + 0, + 25, + 52, + 18, + 21, + 129, + 120, + 12, + 64, + 0, + 2, + 35, + 137, + 52, + 15, + 52, + 16, + 52, + 18, + 52, + 17, + 22, + 80, + 102, + 66, + 0, + 77, + 52, + 18, + 52, + 19, + 37, + 11, + 91, + 53, + 20, + 52, + 20, + 35, + 18, + 64, + 0, + 19, + 52, + 20, + 52, + 17, + 18, + 64, + 0, + 9, + 52, + 19, + 34, + 8, + 53, + 19, + 66, + 255, + 187, + 34, + 137, + 52, + 15, + 52, + 16, + 52, + 18, + 35, + 52, + 19, + 37, + 11, + 82, + 52, + 17, + 22, + 80, + 52, + 18, + 52, + 19, + 37, + 11, + 37, + 8, + 52, + 18, + 21, + 82, + 80, + 102, + 34, + 137, + 52, + 15, + 52, + 16, + 52, + 17, + 22, + 102, + 34, + 137, + 34, + 137, + 53, + 33, + 53, + 32, + 53, + 31, + 52, + 31, + 52, + 32, + 98, + 53, + 34, + 35, + 53, + 35, + 52, + 35, + 52, + 34, + 21, + 37, + 10, + 12, + 65, + 0, + 53, + 52, + 34, + 52, + 35, + 37, + 11, + 91, + 52, + 33, + 18, + 64, + 0, + 9, + 52, + 35, + 34, + 8, + 53, + 35, + 66, + 255, + 223, + 52, + 31, + 52, + 32, + 52, + 34, + 35, + 52, + 35, + 37, + 11, + 82, + 35, + 22, + 80, + 52, + 34, + 52, + 35, + 37, + 11, + 37, + 8, + 52, + 34, + 21, + 82, + 80, + 102, + 34, + 137, + 35, + 137, + 53, + 11, + 53, + 10, + 53, + 9, + 53, + 8, + 35, + 53, + 12, + 52, + 12, + 52, + 10, + 12, + 65, + 0, + 31, + 52, + 8, + 52, + 9, + 52, + 12, + 136, + 254, + 136, + 80, + 52, + 11, + 136, + 254, + 250, + 34, + 18, + 64, + 0, + 9, + 52, + 12, + 34, + 8, + 53, + 12, + 66, + 255, + 219, + 34, + 137, + 35, + 137, + 53, + 29, + 53, + 28, + 53, + 27, + 53, + 26, + 35, + 53, + 30, + 52, + 30, + 52, + 28, + 12, + 65, + 0, + 31, + 52, + 26, + 52, + 27, + 52, + 30, + 136, + 254, + 84, + 80, + 52, + 29, + 136, + 255, + 88, + 34, + 18, + 64, + 0, + 9, + 52, + 30, + 34, + 8, + 53, + 30, + 66, + 255, + 219, + 34, + 137, + 35, + 137, + 164, + 97, + 112, + 101, + 112, + 3, + 164, + 97, + 112, + 108, + 115, + 129, + 163, + 110, + 98, + 115, + 16, + 164, + 97, + 112, + 115, + 117, + 196, + 4, + 6, + 129, + 1, + 67, + 163, + 102, + 101, + 101, + 205, + 3, + 232, + 162, + 102, + 118, + 206, + 1, + 65, + 3, + 233, + 163, + 103, + 101, + 110, + 172, + 116, + 101, + 115, + 116, + 110, + 101, + 116, + 45, + 118, + 49, + 46, + 48, + 162, + 103, + 104, + 196, + 32, + 72, + 99, + 181, + 24, + 164, + 179, + 200, + 78, + 200, + 16, + 242, + 45, + 79, + 16, + 129, + 203, + 15, + 113, + 240, + 89, + 167, + 172, + 32, + 222, + 198, + 47, + 127, + 112, + 229, + 9, + 58, + 34, + 162, + 108, + 118, + 206, + 1, + 65, + 7, + 209, + 164, + 110, + 111, + 116, + 101, + 196, + 21, + 78, + 70, + 68, + 32, + 82, + 101, + 103, + 105, + 115, + 116, + 114, + 121, + 32, + 67, + 111, + 110, + 116, + 114, + 97, + 99, + 116, + 163, + 115, + 110, + 100, + 196, + 32, + 222, + 61, + 163, + 205, + 60, + 182, + 36, + 130, + 40, + 95, + 229, + 201, + 178, + 233, + 37, + 20, + 191, + 255, + 240, + 141, + 216, + 176, + 218, + 30, + 2, + 33, + 80, + 223, + 192, + 56, + 40, + 44, + 164, + 116, + 121, + 112, + 101, + 164, + 97, + 112, + 112, + 108 + ], + "signingPrivateKey": [ + 2, + 205, + 103, + 33, + 67, + 14, + 82, + 196, + 115, + 196, + 206, + 254, + 50, + 110, + 63, + 182, + 149, + 229, + 184, + 216, + 93, + 11, + 13, + 99, + 69, + 213, + 218, + 165, + 134, + 118, + 47, + 44 + ], + "transaction": { + "appCall": { + "appId": 0, + "approvalProgram": [ + 6, + 32, + 10, + 1, + 0, + 2, + 8, + 4, + 6, + 16, + 10, + 5, + 3, + 38, + 3, + 6, + 105, + 46, + 97, + 112, + 112, + 115, + 8, + 97, + 100, + 100, + 95, + 97, + 100, + 100, + 114, + 0, + 49, + 22, + 36, + 12, + 64, + 2, + 166, + 49, + 22, + 34, + 9, + 53, + 0, + 35, + 64, + 2, + 154, + 49, + 25, + 33, + 8, + 18, + 64, + 2, + 144, + 49, + 25, + 33, + 4, + 18, + 64, + 2, + 130, + 49, + 24, + 35, + 18, + 64, + 2, + 121, + 49, + 25, + 36, + 18, + 64, + 2, + 112, + 49, + 25, + 34, + 18, + 64, + 1, + 191, + 49, + 25, + 35, + 18, + 64, + 0, + 1, + 0, + 54, + 26, + 0, + 128, + 3, + 103, + 97, + 115, + 18, + 64, + 1, + 169, + 50, + 4, + 36, + 15, + 52, + 0, + 56, + 16, + 34, + 18, + 16, + 52, + 0, + 56, + 32, + 50, + 3, + 18, + 16, + 52, + 0, + 56, + 9, + 50, + 3, + 18, + 16, + 52, + 0, + 56, + 8, + 50, + 0, + 15, + 52, + 0, + 56, + 1, + 50, + 0, + 13, + 17, + 16, + 52, + 0, + 136, + 2, + 129, + 34, + 18, + 16, + 64, + 0, + 2, + 35, + 67, + 49, + 27, + 36, + 18, + 54, + 26, + 0, + 41, + 18, + 16, + 49, + 22, + 34, + 9, + 56, + 7, + 49, + 0, + 18, + 16, + 64, + 1, + 75, + 49, + 27, + 36, + 18, + 54, + 26, + 0, + 128, + 11, + 114, + 101, + 109, + 111, + 118, + 101, + 95, + 97, + 100, + 100, + 114, + 18, + 16, + 49, + 22, + 34, + 9, + 56, + 7, + 49, + 0, + 18, + 16, + 64, + 1, + 25, + 50, + 4, + 33, + 4, + 15, + 54, + 26, + 0, + 128, + 4, + 109, + 105, + 110, + 116, + 18, + 16, + 49, + 27, + 33, + 4, + 18, + 16, + 64, + 0, + 1, + 0, + 49, + 22, + 33, + 9, + 9, + 56, + 61, + 53, + 1, + 52, + 1, + 114, + 8, + 53, + 4, + 53, + 3, + 49, + 22, + 34, + 9, + 136, + 2, + 13, + 49, + 22, + 136, + 2, + 8, + 16, + 20, + 64, + 0, + 219, + 49, + 22, + 36, + 9, + 136, + 1, + 252, + 49, + 22, + 36, + 9, + 56, + 8, + 35, + 18, + 16, + 64, + 0, + 194, + 54, + 26, + 1, + 23, + 53, + 2, + 49, + 22, + 36, + 9, + 56, + 7, + 50, + 10, + 18, + 49, + 22, + 36, + 9, + 56, + 8, + 52, + 2, + 18, + 16, + 49, + 22, + 34, + 9, + 56, + 7, + 50, + 10, + 18, + 16, + 49, + 22, + 34, + 9, + 56, + 8, + 129, + 192, + 154, + 12, + 18, + 16, + 49, + 24, + 50, + 8, + 18, + 16, + 49, + 16, + 33, + 5, + 18, + 16, + 20, + 64, + 0, + 129, + 177, + 34, + 178, + 16, + 49, + 22, + 34, + 9, + 56, + 8, + 52, + 2, + 8, + 178, + 8, + 52, + 3, + 178, + 7, + 35, + 178, + 1, + 182, + 33, + 5, + 178, + 16, + 35, + 178, + 25, + 49, + 0, + 178, + 28, + 54, + 48, + 0, + 178, + 48, + 52, + 1, + 178, + 24, + 54, + 26, + 0, + 178, + 26, + 54, + 26, + 2, + 178, + 26, + 54, + 26, + 3, + 178, + 26, + 35, + 178, + 1, + 182, + 33, + 5, + 178, + 16, + 35, + 178, + 25, + 49, + 0, + 178, + 28, + 54, + 48, + 0, + 178, + 48, + 52, + 1, + 178, + 24, + 128, + 14, + 111, + 102, + 102, + 101, + 114, + 95, + 102, + 111, + 114, + 95, + 115, + 97, + 108, + 101, + 178, + 26, + 54, + 26, + 1, + 178, + 26, + 49, + 22, + 33, + 9, + 9, + 57, + 26, + 3, + 178, + 26, + 35, + 178, + 1, + 179, + 184, + 1, + 58, + 0, + 53, + 200, + 34, + 66, + 254, + 182, + 35, + 67, + 35, + 53, + 2, + 66, + 255, + 62, + 35, + 67, + 49, + 0, + 40, + 33, + 6, + 54, + 26, + 1, + 23, + 136, + 2, + 117, + 66, + 254, + 157, + 49, + 0, + 40, + 33, + 6, + 54, + 26, + 1, + 23, + 136, + 2, + 50, + 66, + 254, + 142, + 34, + 67, + 50, + 4, + 36, + 15, + 52, + 0, + 56, + 16, + 34, + 18, + 16, + 52, + 0, + 56, + 32, + 50, + 3, + 18, + 16, + 52, + 0, + 56, + 9, + 50, + 3, + 18, + 16, + 52, + 0, + 56, + 8, + 50, + 0, + 15, + 52, + 0, + 56, + 1, + 50, + 0, + 13, + 17, + 16, + 52, + 0, + 136, + 0, + 214, + 34, + 18, + 16, + 52, + 0, + 56, + 7, + 49, + 0, + 18, + 16, + 64, + 0, + 2, + 35, + 67, + 50, + 4, + 36, + 15, + 49, + 27, + 34, + 18, + 16, + 54, + 26, + 0, + 128, + 6, + 97, + 115, + 115, + 105, + 103, + 110, + 18, + 16, + 64, + 0, + 39, + 49, + 27, + 36, + 18, + 54, + 26, + 0, + 41, + 18, + 16, + 49, + 22, + 34, + 9, + 56, + 7, + 49, + 0, + 18, + 16, + 64, + 0, + 1, + 0, + 49, + 0, + 40, + 33, + 6, + 54, + 26, + 1, + 23, + 136, + 1, + 176, + 66, + 255, + 191, + 49, + 0, + 128, + 7, + 105, + 46, + 97, + 115, + 97, + 105, + 100, + 49, + 22, + 36, + 9, + 59, + 200, + 102, + 49, + 0, + 128, + 7, + 105, + 46, + 97, + 112, + 112, + 105, + 100, + 49, + 22, + 33, + 8, + 9, + 56, + 61, + 22, + 102, + 34, + 66, + 255, + 149, + 34, + 67, + 34, + 67, + 49, + 0, + 50, + 9, + 18, + 67, + 35, + 67, + 35, + 67, + 35, + 53, + 0, + 66, + 253, + 90, + 53, + 14, + 128, + 10, + 48, + 49, + 50, + 51, + 52, + 53, + 54, + 55, + 56, + 57, + 52, + 14, + 34, + 88, + 137, + 53, + 13, + 52, + 13, + 35, + 18, + 64, + 0, + 40, + 52, + 13, + 33, + 7, + 10, + 35, + 13, + 64, + 0, + 13, + 42, + 52, + 13, + 33, + 7, + 24, + 136, + 255, + 209, + 80, + 66, + 0, + 20, + 52, + 13, + 33, + 7, + 10, + 52, + 13, + 76, + 136, + 255, + 213, + 76, + 53, + 13, + 66, + 255, + 227, + 128, + 1, + 48, + 137, + 53, + 5, + 52, + 5, + 56, + 0, + 129, + 184, + 171, + 157, + 40, + 112, + 0, + 53, + 7, + 53, + 6, + 52, + 6, + 34, + 18, + 52, + 5, + 56, + 9, + 50, + 3, + 18, + 16, + 52, + 5, + 56, + 32, + 50, + 3, + 18, + 16, + 137, + 53, + 23, + 53, + 22, + 53, + 21, + 52, + 21, + 52, + 22, + 52, + 23, + 99, + 53, + 25, + 53, + 24, + 52, + 25, + 64, + 0, + 4, + 42, + 66, + 0, + 2, + 52, + 24, + 137, + 53, + 17, + 53, + 16, + 53, + 15, + 52, + 15, + 50, + 8, + 52, + 16, + 136, + 255, + 212, + 21, + 35, + 18, + 64, + 0, + 113, + 52, + 15, + 52, + 16, + 98, + 53, + 18, + 35, + 53, + 19, + 52, + 19, + 52, + 18, + 21, + 37, + 10, + 12, + 64, + 0, + 25, + 52, + 18, + 21, + 129, + 120, + 12, + 64, + 0, + 2, + 35, + 137, + 52, + 15, + 52, + 16, + 52, + 18, + 52, + 17, + 22, + 80, + 102, + 66, + 0, + 77, + 52, + 18, + 52, + 19, + 37, + 11, + 91, + 53, + 20, + 52, + 20, + 35, + 18, + 64, + 0, + 19, + 52, + 20, + 52, + 17, + 18, + 64, + 0, + 9, + 52, + 19, + 34, + 8, + 53, + 19, + 66, + 255, + 187, + 34, + 137, + 52, + 15, + 52, + 16, + 52, + 18, + 35, + 52, + 19, + 37, + 11, + 82, + 52, + 17, + 22, + 80, + 52, + 18, + 52, + 19, + 37, + 11, + 37, + 8, + 52, + 18, + 21, + 82, + 80, + 102, + 34, + 137, + 52, + 15, + 52, + 16, + 52, + 17, + 22, + 102, + 34, + 137, + 34, + 137, + 53, + 33, + 53, + 32, + 53, + 31, + 52, + 31, + 52, + 32, + 98, + 53, + 34, + 35, + 53, + 35, + 52, + 35, + 52, + 34, + 21, + 37, + 10, + 12, + 65, + 0, + 53, + 52, + 34, + 52, + 35, + 37, + 11, + 91, + 52, + 33, + 18, + 64, + 0, + 9, + 52, + 35, + 34, + 8, + 53, + 35, + 66, + 255, + 223, + 52, + 31, + 52, + 32, + 52, + 34, + 35, + 52, + 35, + 37, + 11, + 82, + 35, + 22, + 80, + 52, + 34, + 52, + 35, + 37, + 11, + 37, + 8, + 52, + 34, + 21, + 82, + 80, + 102, + 34, + 137, + 35, + 137, + 53, + 11, + 53, + 10, + 53, + 9, + 53, + 8, + 35, + 53, + 12, + 52, + 12, + 52, + 10, + 12, + 65, + 0, + 31, + 52, + 8, + 52, + 9, + 52, + 12, + 136, + 254, + 136, + 80, + 52, + 11, + 136, + 254, + 250, + 34, + 18, + 64, + 0, + 9, + 52, + 12, + 34, + 8, + 53, + 12, + 66, + 255, + 219, + 34, + 137, + 35, + 137, + 53, + 29, + 53, + 28, + 53, + 27, + 53, + 26, + 35, + 53, + 30, + 52, + 30, + 52, + 28, + 12, + 65, + 0, + 31, + 52, + 26, + 52, + 27, + 52, + 30, + 136, + 254, + 84, + 80, + 52, + 29, + 136, + 255, + 88, + 34, + 18, + 64, + 0, + 9, + 52, + 30, + 34, + 8, + 53, + 30, + 66, + 255, + 219, + 34, + 137, + 35, + 137 + ], + "clearStateProgram": [ + 6, + 129, + 1, + 67 + ], + "extraProgramPages": 3, + "localStateSchema": { + "numByteSlices": 16, + "numUints": 0 + }, + "onComplete": "NoOp" + }, + "fee": 1000, + "firstValid": 21038057, + "genesisHash": [ + 72, + 99, + 181, + 24, + 164, + 179, + 200, + 78, + 200, + 16, + 242, + 45, + 79, + 16, + 129, + 203, + 15, + 113, + 240, + 89, + 167, + 172, + 32, + 222, + 198, + 47, + 127, + 112, + 229, + 9, + 58, + 34 + ], + "genesisId": "testnet-v1.0", + "lastValid": 21039057, + "note": [ + 78, + 70, + 68, + 32, + 82, + 101, + 103, + 105, + 115, + 116, + 114, + 121, + 32, + 67, + 111, + 110, + 116, + 114, + 97, + 99, + 116 + ], + "sender": "3Y62HTJ4WYSIEKC74XE3F2JFCS7774EN3CYNUHQCEFIN7QBYFAWLKE5MFY", + "transactionType": "AppCall" + }, + "unsignedBytes": [ + 84, + 88, + 140, + 164, + 97, + 112, + 97, + 112, + 197, + 4, + 170, + 6, + 32, + 10, + 1, + 0, + 2, + 8, + 4, + 6, + 16, + 10, + 5, + 3, + 38, + 3, + 6, + 105, + 46, + 97, + 112, + 112, + 115, + 8, + 97, + 100, + 100, + 95, + 97, + 100, + 100, + 114, + 0, + 49, + 22, + 36, + 12, + 64, + 2, + 166, + 49, + 22, + 34, + 9, + 53, + 0, + 35, + 64, + 2, + 154, + 49, + 25, + 33, + 8, + 18, + 64, + 2, + 144, + 49, + 25, + 33, + 4, + 18, + 64, + 2, + 130, + 49, + 24, + 35, + 18, + 64, + 2, + 121, + 49, + 25, + 36, + 18, + 64, + 2, + 112, + 49, + 25, + 34, + 18, + 64, + 1, + 191, + 49, + 25, + 35, + 18, + 64, + 0, + 1, + 0, + 54, + 26, + 0, + 128, + 3, + 103, + 97, + 115, + 18, + 64, + 1, + 169, + 50, + 4, + 36, + 15, + 52, + 0, + 56, + 16, + 34, + 18, + 16, + 52, + 0, + 56, + 32, + 50, + 3, + 18, + 16, + 52, + 0, + 56, + 9, + 50, + 3, + 18, + 16, + 52, + 0, + 56, + 8, + 50, + 0, + 15, + 52, + 0, + 56, + 1, + 50, + 0, + 13, + 17, + 16, + 52, + 0, + 136, + 2, + 129, + 34, + 18, + 16, + 64, + 0, + 2, + 35, + 67, + 49, + 27, + 36, + 18, + 54, + 26, + 0, + 41, + 18, + 16, + 49, + 22, + 34, + 9, + 56, + 7, + 49, + 0, + 18, + 16, + 64, + 1, + 75, + 49, + 27, + 36, + 18, + 54, + 26, + 0, + 128, + 11, + 114, + 101, + 109, + 111, + 118, + 101, + 95, + 97, + 100, + 100, + 114, + 18, + 16, + 49, + 22, + 34, + 9, + 56, + 7, + 49, + 0, + 18, + 16, + 64, + 1, + 25, + 50, + 4, + 33, + 4, + 15, + 54, + 26, + 0, + 128, + 4, + 109, + 105, + 110, + 116, + 18, + 16, + 49, + 27, + 33, + 4, + 18, + 16, + 64, + 0, + 1, + 0, + 49, + 22, + 33, + 9, + 9, + 56, + 61, + 53, + 1, + 52, + 1, + 114, + 8, + 53, + 4, + 53, + 3, + 49, + 22, + 34, + 9, + 136, + 2, + 13, + 49, + 22, + 136, + 2, + 8, + 16, + 20, + 64, + 0, + 219, + 49, + 22, + 36, + 9, + 136, + 1, + 252, + 49, + 22, + 36, + 9, + 56, + 8, + 35, + 18, + 16, + 64, + 0, + 194, + 54, + 26, + 1, + 23, + 53, + 2, + 49, + 22, + 36, + 9, + 56, + 7, + 50, + 10, + 18, + 49, + 22, + 36, + 9, + 56, + 8, + 52, + 2, + 18, + 16, + 49, + 22, + 34, + 9, + 56, + 7, + 50, + 10, + 18, + 16, + 49, + 22, + 34, + 9, + 56, + 8, + 129, + 192, + 154, + 12, + 18, + 16, + 49, + 24, + 50, + 8, + 18, + 16, + 49, + 16, + 33, + 5, + 18, + 16, + 20, + 64, + 0, + 129, + 177, + 34, + 178, + 16, + 49, + 22, + 34, + 9, + 56, + 8, + 52, + 2, + 8, + 178, + 8, + 52, + 3, + 178, + 7, + 35, + 178, + 1, + 182, + 33, + 5, + 178, + 16, + 35, + 178, + 25, + 49, + 0, + 178, + 28, + 54, + 48, + 0, + 178, + 48, + 52, + 1, + 178, + 24, + 54, + 26, + 0, + 178, + 26, + 54, + 26, + 2, + 178, + 26, + 54, + 26, + 3, + 178, + 26, + 35, + 178, + 1, + 182, + 33, + 5, + 178, + 16, + 35, + 178, + 25, + 49, + 0, + 178, + 28, + 54, + 48, + 0, + 178, + 48, + 52, + 1, + 178, + 24, + 128, + 14, + 111, + 102, + 102, + 101, + 114, + 95, + 102, + 111, + 114, + 95, + 115, + 97, + 108, + 101, + 178, + 26, + 54, + 26, + 1, + 178, + 26, + 49, + 22, + 33, + 9, + 9, + 57, + 26, + 3, + 178, + 26, + 35, + 178, + 1, + 179, + 184, + 1, + 58, + 0, + 53, + 200, + 34, + 66, + 254, + 182, + 35, + 67, + 35, + 53, + 2, + 66, + 255, + 62, + 35, + 67, + 49, + 0, + 40, + 33, + 6, + 54, + 26, + 1, + 23, + 136, + 2, + 117, + 66, + 254, + 157, + 49, + 0, + 40, + 33, + 6, + 54, + 26, + 1, + 23, + 136, + 2, + 50, + 66, + 254, + 142, + 34, + 67, + 50, + 4, + 36, + 15, + 52, + 0, + 56, + 16, + 34, + 18, + 16, + 52, + 0, + 56, + 32, + 50, + 3, + 18, + 16, + 52, + 0, + 56, + 9, + 50, + 3, + 18, + 16, + 52, + 0, + 56, + 8, + 50, + 0, + 15, + 52, + 0, + 56, + 1, + 50, + 0, + 13, + 17, + 16, + 52, + 0, + 136, + 0, + 214, + 34, + 18, + 16, + 52, + 0, + 56, + 7, + 49, + 0, + 18, + 16, + 64, + 0, + 2, + 35, + 67, + 50, + 4, + 36, + 15, + 49, + 27, + 34, + 18, + 16, + 54, + 26, + 0, + 128, + 6, + 97, + 115, + 115, + 105, + 103, + 110, + 18, + 16, + 64, + 0, + 39, + 49, + 27, + 36, + 18, + 54, + 26, + 0, + 41, + 18, + 16, + 49, + 22, + 34, + 9, + 56, + 7, + 49, + 0, + 18, + 16, + 64, + 0, + 1, + 0, + 49, + 0, + 40, + 33, + 6, + 54, + 26, + 1, + 23, + 136, + 1, + 176, + 66, + 255, + 191, + 49, + 0, + 128, + 7, + 105, + 46, + 97, + 115, + 97, + 105, + 100, + 49, + 22, + 36, + 9, + 59, + 200, + 102, + 49, + 0, + 128, + 7, + 105, + 46, + 97, + 112, + 112, + 105, + 100, + 49, + 22, + 33, + 8, + 9, + 56, + 61, + 22, + 102, + 34, + 66, + 255, + 149, + 34, + 67, + 34, + 67, + 49, + 0, + 50, + 9, + 18, + 67, + 35, + 67, + 35, + 67, + 35, + 53, + 0, + 66, + 253, + 90, + 53, + 14, + 128, + 10, + 48, + 49, + 50, + 51, + 52, + 53, + 54, + 55, + 56, + 57, + 52, + 14, + 34, + 88, + 137, + 53, + 13, + 52, + 13, + 35, + 18, + 64, + 0, + 40, + 52, + 13, + 33, + 7, + 10, + 35, + 13, + 64, + 0, + 13, + 42, + 52, + 13, + 33, + 7, + 24, + 136, + 255, + 209, + 80, + 66, + 0, + 20, + 52, + 13, + 33, + 7, + 10, + 52, + 13, + 76, + 136, + 255, + 213, + 76, + 53, + 13, + 66, + 255, + 227, + 128, + 1, + 48, + 137, + 53, + 5, + 52, + 5, + 56, + 0, + 129, + 184, + 171, + 157, + 40, + 112, + 0, + 53, + 7, + 53, + 6, + 52, + 6, + 34, + 18, + 52, + 5, + 56, + 9, + 50, + 3, + 18, + 16, + 52, + 5, + 56, + 32, + 50, + 3, + 18, + 16, + 137, + 53, + 23, + 53, + 22, + 53, + 21, + 52, + 21, + 52, + 22, + 52, + 23, + 99, + 53, + 25, + 53, + 24, + 52, + 25, + 64, + 0, + 4, + 42, + 66, + 0, + 2, + 52, + 24, + 137, + 53, + 17, + 53, + 16, + 53, + 15, + 52, + 15, + 50, + 8, + 52, + 16, + 136, + 255, + 212, + 21, + 35, + 18, + 64, + 0, + 113, + 52, + 15, + 52, + 16, + 98, + 53, + 18, + 35, + 53, + 19, + 52, + 19, + 52, + 18, + 21, + 37, + 10, + 12, + 64, + 0, + 25, + 52, + 18, + 21, + 129, + 120, + 12, + 64, + 0, + 2, + 35, + 137, + 52, + 15, + 52, + 16, + 52, + 18, + 52, + 17, + 22, + 80, + 102, + 66, + 0, + 77, + 52, + 18, + 52, + 19, + 37, + 11, + 91, + 53, + 20, + 52, + 20, + 35, + 18, + 64, + 0, + 19, + 52, + 20, + 52, + 17, + 18, + 64, + 0, + 9, + 52, + 19, + 34, + 8, + 53, + 19, + 66, + 255, + 187, + 34, + 137, + 52, + 15, + 52, + 16, + 52, + 18, + 35, + 52, + 19, + 37, + 11, + 82, + 52, + 17, + 22, + 80, + 52, + 18, + 52, + 19, + 37, + 11, + 37, + 8, + 52, + 18, + 21, + 82, + 80, + 102, + 34, + 137, + 52, + 15, + 52, + 16, + 52, + 17, + 22, + 102, + 34, + 137, + 34, + 137, + 53, + 33, + 53, + 32, + 53, + 31, + 52, + 31, + 52, + 32, + 98, + 53, + 34, + 35, + 53, + 35, + 52, + 35, + 52, + 34, + 21, + 37, + 10, + 12, + 65, + 0, + 53, + 52, + 34, + 52, + 35, + 37, + 11, + 91, + 52, + 33, + 18, + 64, + 0, + 9, + 52, + 35, + 34, + 8, + 53, + 35, + 66, + 255, + 223, + 52, + 31, + 52, + 32, + 52, + 34, + 35, + 52, + 35, + 37, + 11, + 82, + 35, + 22, + 80, + 52, + 34, + 52, + 35, + 37, + 11, + 37, + 8, + 52, + 34, + 21, + 82, + 80, + 102, + 34, + 137, + 35, + 137, + 53, + 11, + 53, + 10, + 53, + 9, + 53, + 8, + 35, + 53, + 12, + 52, + 12, + 52, + 10, + 12, + 65, + 0, + 31, + 52, + 8, + 52, + 9, + 52, + 12, + 136, + 254, + 136, + 80, + 52, + 11, + 136, + 254, + 250, + 34, + 18, + 64, + 0, + 9, + 52, + 12, + 34, + 8, + 53, + 12, + 66, + 255, + 219, + 34, + 137, + 35, + 137, + 53, + 29, + 53, + 28, + 53, + 27, + 53, + 26, + 35, + 53, + 30, + 52, + 30, + 52, + 28, + 12, + 65, + 0, + 31, + 52, + 26, + 52, + 27, + 52, + 30, + 136, + 254, + 84, + 80, + 52, + 29, + 136, + 255, + 88, + 34, + 18, + 64, + 0, + 9, + 52, + 30, + 34, + 8, + 53, + 30, + 66, + 255, + 219, + 34, + 137, + 35, + 137, + 164, + 97, + 112, + 101, + 112, + 3, + 164, + 97, + 112, + 108, + 115, + 129, + 163, + 110, + 98, + 115, + 16, + 164, + 97, + 112, + 115, + 117, + 196, + 4, + 6, + 129, + 1, + 67, + 163, + 102, + 101, + 101, + 205, + 3, + 232, + 162, + 102, + 118, + 206, + 1, + 65, + 3, + 233, + 163, + 103, + 101, + 110, + 172, + 116, + 101, + 115, + 116, + 110, + 101, + 116, + 45, + 118, + 49, + 46, + 48, + 162, + 103, + 104, + 196, + 32, + 72, + 99, + 181, + 24, + 164, + 179, + 200, + 78, + 200, + 16, + 242, + 45, + 79, + 16, + 129, + 203, + 15, + 113, + 240, + 89, + 167, + 172, + 32, + 222, + 198, + 47, + 127, + 112, + 229, + 9, + 58, + 34, + 162, + 108, + 118, + 206, + 1, + 65, + 7, + 209, + 164, + 110, + 111, + 116, + 101, + 196, + 21, + 78, + 70, + 68, + 32, + 82, + 101, + 103, + 105, + 115, + 116, + 114, + 121, + 32, + 67, + 111, + 110, + 116, + 114, + 97, + 99, + 116, + 163, + 115, + 110, + 100, + 196, + 32, + 222, + 61, + 163, + 205, + 60, + 182, + 36, + 130, + 40, + 95, + 229, + 201, + 178, + 233, + 37, + 20, + 191, + 255, + 240, + 141, + 216, + 176, + 218, + 30, + 2, + 33, + 80, + 223, + 192, + 56, + 40, + 44, + 164, + 116, + 121, + 112, + 101, + 164, + 97, + 112, + 112, + 108 + ] + }, + "appDelete": { + "id": "XVVC7UDLCPI622KCJZLWK3SEAWWVUEPEXUM5CO3DFLWOBH7NOPDQ", + "idRaw": [ + 189, + 106, + 47, + 208, + 107, + 19, + 209, + 237, + 105, + 66, + 78, + 87, + 101, + 110, + 68, + 5, + 173, + 90, + 17, + 228, + 189, + 25, + 209, + 59, + 99, + 42, + 236, + 224, + 159, + 237, + 115, + 199 + ], + "multisigAddresses": [ + "424ZV7KBBUJ52DUKP2KLQ6I5GBOHKBXOW7Q7UQIOOYNDWYRM4EKOSMVVRI", + "NY6DHEEFW73R2NUWY562U2NNKSKBKVYY5OOQFLD3M2II5RUNKRZDEGUGEA" + ], + "multisigSignedBytes": [ + 130, + 164, + 109, + 115, + 105, + 103, + 131, + 166, + 115, + 117, + 98, + 115, + 105, + 103, + 146, + 130, + 162, + 112, + 107, + 196, + 32, + 230, + 185, + 154, + 253, + 65, + 13, + 19, + 221, + 14, + 138, + 126, + 148, + 184, + 121, + 29, + 48, + 92, + 117, + 6, + 238, + 183, + 225, + 250, + 65, + 14, + 118, + 26, + 59, + 98, + 44, + 225, + 20, + 161, + 115, + 196, + 64, + 189, + 191, + 163, + 64, + 0, + 152, + 34, + 130, + 147, + 145, + 71, + 181, + 64, + 70, + 197, + 223, + 207, + 87, + 199, + 134, + 112, + 68, + 94, + 205, + 33, + 96, + 71, + 37, + 137, + 244, + 10, + 16, + 198, + 150, + 220, + 228, + 165, + 173, + 80, + 238, + 227, + 231, + 118, + 144, + 235, + 35, + 236, + 87, + 238, + 220, + 217, + 34, + 227, + 204, + 64, + 194, + 223, + 144, + 95, + 45, + 249, + 210, + 252, + 9, + 130, + 162, + 112, + 107, + 196, + 32, + 110, + 60, + 51, + 144, + 133, + 183, + 247, + 29, + 54, + 150, + 199, + 125, + 170, + 105, + 173, + 84, + 148, + 21, + 87, + 24, + 235, + 157, + 2, + 172, + 123, + 102, + 144, + 142, + 198, + 141, + 84, + 114, + 161, + 115, + 196, + 64, + 189, + 191, + 163, + 64, + 0, + 152, + 34, + 130, + 147, + 145, + 71, + 181, + 64, + 70, + 197, + 223, + 207, + 87, + 199, + 134, + 112, + 68, + 94, + 205, + 33, + 96, + 71, + 37, + 137, + 244, + 10, + 16, + 198, + 150, + 220, + 228, + 165, + 173, + 80, + 238, + 227, + 231, + 118, + 144, + 235, + 35, + 236, + 87, + 238, + 220, + 217, + 34, + 227, + 204, + 64, + 194, + 223, + 144, + 95, + 45, + 249, + 210, + 252, + 9, + 163, + 116, + 104, + 114, + 2, + 161, + 118, + 1, + 163, + 116, + 120, + 110, + 139, + 164, + 97, + 112, + 97, + 110, + 5, + 164, + 97, + 112, + 97, + 115, + 145, + 206, + 50, + 184, + 18, + 152, + 164, + 97, + 112, + 97, + 116, + 147, + 196, + 32, + 96, + 209, + 85, + 35, + 220, + 102, + 142, + 69, + 10, + 202, + 63, + 228, + 233, + 210, + 228, + 37, + 188, + 166, + 187, + 18, + 3, + 131, + 49, + 206, + 91, + 210, + 169, + 7, + 26, + 147, + 255, + 71, + 196, + 32, + 62, + 221, + 2, + 65, + 8, + 22, + 251, + 28, + 205, + 45, + 167, + 65, + 254, + 174, + 124, + 120, + 167, + 65, + 23, + 117, + 85, + 73, + 9, + 202, + 224, + 75, + 40, + 102, + 206, + 52, + 81, + 20, + 196, + 32, + 96, + 209, + 85, + 35, + 220, + 102, + 142, + 69, + 10, + 202, + 63, + 228, + 233, + 210, + 228, + 37, + 188, + 166, + 187, + 18, + 3, + 131, + 49, + 206, + 91, + 210, + 169, + 7, + 26, + 147, + 255, + 71, + 164, + 97, + 112, + 105, + 100, + 206, + 113, + 42, + 35, + 22, + 163, + 102, + 101, + 101, + 205, + 3, + 232, + 162, + 102, + 118, + 206, + 2, + 94, + 35, + 22, + 163, + 103, + 101, + 110, + 172, + 109, + 97, + 105, + 110, + 110, + 101, + 116, + 45, + 118, + 49, + 46, + 48, + 162, + 103, + 104, + 196, + 32, + 192, + 97, + 196, + 216, + 252, + 29, + 189, + 222, + 210, + 215, + 96, + 75, + 228, + 86, + 142, + 63, + 109, + 4, + 25, + 135, + 172, + 55, + 189, + 228, + 182, + 32, + 181, + 171, + 57, + 36, + 138, + 223, + 162, + 108, + 118, + 206, + 2, + 94, + 38, + 254, + 163, + 115, + 110, + 100, + 196, + 32, + 62, + 221, + 2, + 65, + 8, + 22, + 251, + 28, + 205, + 45, + 167, + 65, + 254, + 174, + 124, + 120, + 167, + 65, + 23, + 117, + 85, + 73, + 9, + 202, + 224, + 75, + 40, + 102, + 206, + 52, + 81, + 20, + 164, + 116, + 121, + 112, + 101, + 164, + 97, + 112, + 112, + 108 + ], + "rekeyedSenderAuthAddress": "BKDYDIDVSZCP75JVCB76P3WBJRY6HWAIFDSEOKYHJY5WMNJ2UWJ65MYETU", + "rekeyedSenderSignedBytes": [ + 131, + 164, + 115, + 103, + 110, + 114, + 196, + 32, + 10, + 135, + 129, + 160, + 117, + 150, + 68, + 255, + 245, + 53, + 16, + 127, + 231, + 238, + 193, + 76, + 113, + 227, + 216, + 8, + 40, + 228, + 71, + 43, + 7, + 78, + 59, + 102, + 53, + 58, + 165, + 147, + 163, + 115, + 105, + 103, + 196, + 64, + 189, + 191, + 163, + 64, + 0, + 152, + 34, + 130, + 147, + 145, + 71, + 181, + 64, + 70, + 197, + 223, + 207, + 87, + 199, + 134, + 112, + 68, + 94, + 205, + 33, + 96, + 71, + 37, + 137, + 244, + 10, + 16, + 198, + 150, + 220, + 228, + 165, + 173, + 80, + 238, + 227, + 231, + 118, + 144, + 235, + 35, + 236, + 87, + 238, + 220, + 217, + 34, + 227, + 204, + 64, + 194, + 223, + 144, + 95, + 45, + 249, + 210, + 252, + 9, + 163, + 116, + 120, + 110, + 139, + 164, + 97, + 112, + 97, + 110, + 5, + 164, + 97, + 112, + 97, + 115, + 145, + 206, + 50, + 184, + 18, + 152, + 164, + 97, + 112, + 97, + 116, + 147, + 196, + 32, + 96, + 209, + 85, + 35, + 220, + 102, + 142, + 69, + 10, + 202, + 63, + 228, + 233, + 210, + 228, + 37, + 188, + 166, + 187, + 18, + 3, + 131, + 49, + 206, + 91, + 210, + 169, + 7, + 26, + 147, + 255, + 71, + 196, + 32, + 62, + 221, + 2, + 65, + 8, + 22, + 251, + 28, + 205, + 45, + 167, + 65, + 254, + 174, + 124, + 120, + 167, + 65, + 23, + 117, + 85, + 73, + 9, + 202, + 224, + 75, + 40, + 102, + 206, + 52, + 81, + 20, + 196, + 32, + 96, + 209, + 85, + 35, + 220, + 102, + 142, + 69, + 10, + 202, + 63, + 228, + 233, + 210, + 228, + 37, + 188, + 166, + 187, + 18, + 3, + 131, + 49, + 206, + 91, + 210, + 169, + 7, + 26, + 147, + 255, + 71, + 164, + 97, + 112, + 105, + 100, + 206, + 113, + 42, + 35, + 22, + 163, + 102, + 101, + 101, + 205, + 3, + 232, + 162, + 102, + 118, + 206, + 2, + 94, + 35, + 22, + 163, + 103, + 101, + 110, + 172, + 109, + 97, + 105, + 110, + 110, + 101, + 116, + 45, + 118, + 49, + 46, + 48, + 162, + 103, + 104, + 196, + 32, + 192, + 97, + 196, + 216, + 252, + 29, + 189, + 222, + 210, + 215, + 96, + 75, + 228, + 86, + 142, + 63, + 109, + 4, + 25, + 135, + 172, + 55, + 189, + 228, + 182, + 32, + 181, + 171, + 57, + 36, + 138, + 223, + 162, + 108, + 118, + 206, + 2, + 94, + 38, + 254, + 163, + 115, + 110, + 100, + 196, + 32, + 62, + 221, + 2, + 65, + 8, + 22, + 251, + 28, + 205, + 45, + 167, + 65, + 254, + 174, + 124, + 120, + 167, + 65, + 23, + 117, + 85, + 73, + 9, + 202, + 224, + 75, + 40, + 102, + 206, + 52, + 81, + 20, + 164, + 116, + 121, + 112, + 101, + 164, + 97, + 112, + 112, + 108 + ], + "signedBytes": [ + 130, + 163, + 115, + 105, + 103, + 196, + 64, + 189, + 191, + 163, + 64, + 0, + 152, + 34, + 130, + 147, + 145, + 71, + 181, + 64, + 70, + 197, + 223, + 207, + 87, + 199, + 134, + 112, + 68, + 94, + 205, + 33, + 96, + 71, + 37, + 137, + 244, + 10, + 16, + 198, + 150, + 220, + 228, + 165, + 173, + 80, + 238, + 227, + 231, + 118, + 144, + 235, + 35, + 236, + 87, + 238, + 220, + 217, + 34, + 227, + 204, + 64, + 194, + 223, + 144, + 95, + 45, + 249, + 210, + 252, + 9, + 163, + 116, + 120, + 110, + 139, + 164, + 97, + 112, + 97, + 110, + 5, + 164, + 97, + 112, + 97, + 115, + 145, + 206, + 50, + 184, + 18, + 152, + 164, + 97, + 112, + 97, + 116, + 147, + 196, + 32, + 96, + 209, + 85, + 35, + 220, + 102, + 142, + 69, + 10, + 202, + 63, + 228, + 233, + 210, + 228, + 37, + 188, + 166, + 187, + 18, + 3, + 131, + 49, + 206, + 91, + 210, + 169, + 7, + 26, + 147, + 255, + 71, + 196, + 32, + 62, + 221, + 2, + 65, + 8, + 22, + 251, + 28, + 205, + 45, + 167, + 65, + 254, + 174, + 124, + 120, + 167, + 65, + 23, + 117, + 85, + 73, + 9, + 202, + 224, + 75, + 40, + 102, + 206, + 52, + 81, + 20, + 196, + 32, + 96, + 209, + 85, + 35, + 220, + 102, + 142, + 69, + 10, + 202, + 63, + 228, + 233, + 210, + 228, + 37, + 188, + 166, + 187, + 18, + 3, + 131, + 49, + 206, + 91, + 210, + 169, + 7, + 26, + 147, + 255, + 71, + 164, + 97, + 112, + 105, + 100, + 206, + 113, + 42, + 35, + 22, + 163, + 102, + 101, + 101, + 205, + 3, + 232, + 162, + 102, + 118, + 206, + 2, + 94, + 35, + 22, + 163, + 103, + 101, + 110, + 172, + 109, + 97, + 105, + 110, + 110, + 101, + 116, + 45, + 118, + 49, + 46, + 48, + 162, + 103, + 104, + 196, + 32, + 192, + 97, + 196, + 216, + 252, + 29, + 189, + 222, + 210, + 215, + 96, + 75, + 228, + 86, + 142, + 63, + 109, + 4, + 25, + 135, + 172, + 55, + 189, + 228, + 182, + 32, + 181, + 171, + 57, + 36, + 138, + 223, + 162, + 108, + 118, + 206, + 2, + 94, + 38, + 254, + 163, + 115, + 110, + 100, + 196, + 32, + 62, + 221, + 2, + 65, + 8, + 22, + 251, + 28, + 205, + 45, + 167, + 65, + 254, + 174, + 124, + 120, + 167, + 65, + 23, + 117, + 85, + 73, + 9, + 202, + 224, + 75, + 40, + 102, + 206, + 52, + 81, + 20, + 164, + 116, + 121, + 112, + 101, + 164, + 97, + 112, + 112, + 108 + ], + "signingPrivateKey": [ + 2, + 205, + 103, + 33, + 67, + 14, + 82, + 196, + 115, + 196, + 206, + 254, + 50, + 110, + 63, + 182, + 149, + 229, + 184, + 216, + 93, + 11, + 13, + 99, + 69, + 213, + 218, + 165, + 134, + 118, + 47, + 44 + ], + "transaction": { + "appCall": { + "accountReferences": [ + "MDIVKI64M2HEKCWKH7SOTUXEEW6KNOYSAOBTDTS32KUQOGUT75D43MSP5M", + "H3OQEQIIC35RZTJNU5A75LT4PCTUCF3VKVEQTSXAJMUGNTRUKEKI4QSRW4", + "MDIVKI64M2HEKCWKH7SOTUXEEW6KNOYSAOBTDTS32KUQOGUT75D43MSP5M" + ], + "appId": 1898586902, + "assetReferences": [ + 850924184 + ], + "onComplete": "DeleteApplication" + }, + "fee": 1000, + "firstValid": 39723798, + "genesisHash": [ + 192, + 97, + 196, + 216, + 252, + 29, + 189, + 222, + 210, + 215, + 96, + 75, + 228, + 86, + 142, + 63, + 109, + 4, + 25, + 135, + 172, + 55, + 189, + 228, + 182, + 32, + 181, + 171, + 57, + 36, + 138, + 223 + ], + "genesisId": "mainnet-v1.0", + "lastValid": 39724798, + "sender": "H3OQEQIIC35RZTJNU5A75LT4PCTUCF3VKVEQTSXAJMUGNTRUKEKI4QSRW4", + "transactionType": "AppCall" + }, + "unsignedBytes": [ + 84, + 88, + 139, + 164, + 97, + 112, + 97, + 110, + 5, + 164, + 97, + 112, + 97, + 115, + 145, + 206, + 50, + 184, + 18, + 152, + 164, + 97, + 112, + 97, + 116, + 147, + 196, + 32, + 96, + 209, + 85, + 35, + 220, + 102, + 142, + 69, + 10, + 202, + 63, + 228, + 233, + 210, + 228, + 37, + 188, + 166, + 187, + 18, + 3, + 131, + 49, + 206, + 91, + 210, + 169, + 7, + 26, + 147, + 255, + 71, + 196, + 32, + 62, + 221, + 2, + 65, + 8, + 22, + 251, + 28, + 205, + 45, + 167, + 65, + 254, + 174, + 124, + 120, + 167, + 65, + 23, + 117, + 85, + 73, + 9, + 202, + 224, + 75, + 40, + 102, + 206, + 52, + 81, + 20, + 196, + 32, + 96, + 209, + 85, + 35, + 220, + 102, + 142, + 69, + 10, + 202, + 63, + 228, + 233, + 210, + 228, + 37, + 188, + 166, + 187, + 18, + 3, + 131, + 49, + 206, + 91, + 210, + 169, + 7, + 26, + 147, + 255, + 71, + 164, + 97, + 112, + 105, + 100, + 206, + 113, + 42, + 35, + 22, + 163, + 102, + 101, + 101, + 205, + 3, + 232, + 162, + 102, + 118, + 206, + 2, + 94, + 35, + 22, + 163, + 103, + 101, + 110, + 172, + 109, + 97, + 105, + 110, + 110, + 101, + 116, + 45, + 118, + 49, + 46, + 48, + 162, + 103, + 104, + 196, + 32, + 192, + 97, + 196, + 216, + 252, + 29, + 189, + 222, + 210, + 215, + 96, + 75, + 228, + 86, + 142, + 63, + 109, + 4, + 25, + 135, + 172, + 55, + 189, + 228, + 182, + 32, + 181, + 171, + 57, + 36, + 138, + 223, + 162, + 108, + 118, + 206, + 2, + 94, + 38, + 254, + 163, + 115, + 110, + 100, + 196, + 32, + 62, + 221, + 2, + 65, + 8, + 22, + 251, + 28, + 205, + 45, + 167, + 65, + 254, + 174, + 124, + 120, + 167, + 65, + 23, + 117, + 85, + 73, + 9, + 202, + 224, + 75, + 40, + 102, + 206, + 52, + 81, + 20, + 164, + 116, + 121, + 112, + 101, + 164, + 97, + 112, + 112, + 108 + ] + }, + "appUpdate": { + "id": "NQVNJ5VWEDX42DMJQIQET4QPNUOW27EYIPKZ4SDWKOOEFJQB7PZA", + "idRaw": [ + 108, + 42, + 212, + 246, + 182, + 32, + 239, + 205, + 13, + 137, + 130, + 32, + 73, + 242, + 15, + 109, + 29, + 109, + 124, + 152, + 67, + 213, + 158, + 72, + 118, + 83, + 156, + 66, + 166, + 1, + 251, + 242 + ], + "multisigAddresses": [ + "424ZV7KBBUJ52DUKP2KLQ6I5GBOHKBXOW7Q7UQIOOYNDWYRM4EKOSMVVRI", + "NY6DHEEFW73R2NUWY562U2NNKSKBKVYY5OOQFLD3M2II5RUNKRZDEGUGEA" + ], + "multisigSignedBytes": [ + 130, + 164, + 109, + 115, + 105, + 103, + 131, + 166, + 115, + 117, + 98, + 115, + 105, + 103, + 146, + 130, + 162, + 112, + 107, + 196, + 32, + 230, + 185, + 154, + 253, + 65, + 13, + 19, + 221, + 14, + 138, + 126, + 148, + 184, + 121, + 29, + 48, + 92, + 117, + 6, + 238, + 183, + 225, + 250, + 65, + 14, + 118, + 26, + 59, + 98, + 44, + 225, + 20, + 161, + 115, + 196, + 64, + 240, + 110, + 158, + 21, + 80, + 135, + 67, + 53, + 228, + 160, + 113, + 219, + 166, + 165, + 149, + 59, + 103, + 53, + 253, + 60, + 147, + 105, + 198, + 194, + 42, + 38, + 39, + 171, + 80, + 144, + 208, + 155, + 90, + 241, + 177, + 22, + 117, + 6, + 218, + 66, + 132, + 154, + 135, + 184, + 94, + 92, + 49, + 172, + 196, + 246, + 47, + 233, + 144, + 234, + 229, + 248, + 138, + 74, + 81, + 191, + 106, + 169, + 199, + 2, + 130, + 162, + 112, + 107, + 196, + 32, + 110, + 60, + 51, + 144, + 133, + 183, + 247, + 29, + 54, + 150, + 199, + 125, + 170, + 105, + 173, + 84, + 148, + 21, + 87, + 24, + 235, + 157, + 2, + 172, + 123, + 102, + 144, + 142, + 198, + 141, + 84, + 114, + 161, + 115, + 196, + 64, + 240, + 110, + 158, + 21, + 80, + 135, + 67, + 53, + 228, + 160, + 113, + 219, + 166, + 165, + 149, + 59, + 103, + 53, + 253, + 60, + 147, + 105, + 198, + 194, + 42, + 38, + 39, + 171, + 80, + 144, + 208, + 155, + 90, + 241, + 177, + 22, + 117, + 6, + 218, + 66, + 132, + 154, + 135, + 184, + 94, + 92, + 49, + 172, + 196, + 246, + 47, + 233, + 144, + 234, + 229, + 248, + 138, + 74, + 81, + 191, + 106, + 169, + 199, + 2, + 163, + 116, + 104, + 114, + 2, + 161, + 118, + 1, + 163, + 116, + 120, + 110, + 141, + 164, + 97, + 112, + 97, + 97, + 145, + 196, + 16, + 116, + 101, + 97, + 108, + 115, + 99, + 114, + 105, + 112, + 116, + 45, + 100, + 117, + 109, + 109, + 121, + 164, + 97, + 112, + 97, + 110, + 4, + 164, + 97, + 112, + 97, + 112, + 197, + 26, + 142, + 10, + 32, + 24, + 0, + 1, + 8, + 6, + 32, + 2, + 5, + 4, + 3, + 16, + 128, + 32, + 160, + 141, + 6, + 10, + 30, + 237, + 2, + 128, + 163, + 5, + 144, + 78, + 27, + 60, + 128, + 212, + 141, + 190, + 202, + 16, + 212, + 222, + 1, + 208, + 134, + 3, + 128, + 1, + 255, + 1, + 38, + 20, + 0, + 4, + 21, + 31, + 124, + 117, + 9, + 105, + 46, + 111, + 119, + 110, + 101, + 114, + 46, + 97, + 7, + 99, + 117, + 114, + 114, + 101, + 110, + 116, + 8, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 13, + 118, + 46, + 99, + 97, + 65, + 108, + 103, + 111, + 46, + 48, + 46, + 97, + 115, + 11, + 99, + 111, + 110, + 116, + 114, + 97, + 99, + 116, + 58, + 65, + 58, + 5, + 105, + 46, + 118, + 101, + 114, + 3, + 10, + 129, + 1, + 1, + 48, + 11, + 99, + 111, + 110, + 116, + 114, + 97, + 99, + 116, + 58, + 67, + 58, + 12, + 117, + 46, + 99, + 97, + 118, + 46, + 97, + 108, + 103, + 111, + 46, + 97, + 16, + 105, + 46, + 101, + 120, + 112, + 105, + 114, + 97, + 116, + 105, + 111, + 110, + 84, + 105, + 109, + 101, + 1, + 0, + 5, + 110, + 97, + 109, + 101, + 47, + 7, + 105, + 46, + 97, + 112, + 112, + 105, + 100, + 6, + 105, + 46, + 97, + 112, + 112, + 115, + 15, + 105, + 46, + 115, + 101, + 103, + 109, + 101, + 110, + 116, + 76, + 111, + 99, + 107, + 101, + 100, + 6, + 105, + 46, + 110, + 97, + 109, + 101, + 7, + 46, + 46, + 46, + 97, + 108, + 103, + 111, + 128, + 8, + 0, + 0, + 0, + 0, + 7, + 1, + 163, + 144, + 23, + 53, + 204, + 128, + 8, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 50, + 23, + 53, + 203, + 128, + 32, + 140, + 192, + 44, + 36, + 6, + 26, + 39, + 87, + 142, + 136, + 93, + 94, + 83, + 159, + 168, + 35, + 71, + 123, + 171, + 202, + 213, + 25, + 64, + 50, + 84, + 80, + 201, + 214, + 220, + 200, + 26, + 116, + 53, + 202, + 128, + 32, + 254, + 115, + 101, + 249, + 131, + 173, + 194, + 235, + 65, + 228, + 41, + 1, + 8, + 109, + 106, + 175, + 251, + 215, + 53, + 172, + 16, + 84, + 237, + 88, + 59, + 48, + 34, + 94, + 151, + 72, + 133, + 83, + 53, + 201, + 128, + 8, + 0, + 0, + 0, + 0, + 5, + 7, + 85, + 184, + 23, + 53, + 200, + 49, + 24, + 20, + 37, + 11, + 49, + 25, + 8, + 141, + 12, + 23, + 240, + 0, + 0, + 0, + 0, + 0, + 0, + 24, + 162, + 0, + 0, + 23, + 226, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 136, + 0, + 2, + 35, + 67, + 138, + 0, + 0, + 49, + 0, + 54, + 50, + 0, + 114, + 7, + 72, + 18, + 68, + 137, + 138, + 0, + 0, + 40, + 49, + 25, + 33, + 7, + 18, + 65, + 0, + 4, + 136, + 255, + 227, + 137, + 49, + 32, + 50, + 3, + 18, + 68, + 54, + 26, + 0, + 128, + 3, + 103, + 97, + 115, + 18, + 65, + 0, + 1, + 137, + 49, + 27, + 33, + 8, + 18, + 73, + 65, + 0, + 25, + 54, + 26, + 0, + 128, + 18, + 105, + 115, + 95, + 118, + 97, + 108, + 105, + 100, + 95, + 110, + 102, + 100, + 95, + 97, + 112, + 112, + 105, + 100, + 18, + 16, + 65, + 0, + 21, + 54, + 26, + 2, + 23, + 54, + 26, + 1, + 136, + 9, + 251, + 65, + 0, + 4, + 35, + 66, + 0, + 1, + 34, + 22, + 176, + 137, + 49, + 27, + 33, + 7, + 18, + 73, + 65, + 0, + 22, + 54, + 26, + 0, + 128, + 15, + 118, + 101, + 114, + 105, + 102, + 121, + 95, + 110, + 102, + 100, + 95, + 97, + 100, + 100, + 114, + 18, + 16, + 65, + 0, + 14, + 54, + 26, + 3, + 54, + 26, + 2, + 23, + 54, + 26, + 1, + 136, + 6, + 230, + 137, + 49, + 27, + 33, + 7, + 18, + 73, + 65, + 0, + 22, + 54, + 26, + 0, + 128, + 15, + 117, + 110, + 108, + 105, + 110, + 107, + 95, + 110, + 102, + 100, + 95, + 97, + 100, + 100, + 114, + 18, + 16, + 65, + 0, + 14, + 54, + 26, + 3, + 54, + 26, + 2, + 23, + 54, + 26, + 1, + 136, + 7, + 42, + 137, + 49, + 27, + 33, + 7, + 18, + 73, + 65, + 0, + 27, + 54, + 26, + 0, + 128, + 20, + 115, + 101, + 116, + 95, + 97, + 100, + 100, + 114, + 95, + 112, + 114, + 105, + 109, + 97, + 114, + 121, + 95, + 110, + 102, + 100, + 18, + 16, + 65, + 0, + 14, + 54, + 26, + 3, + 54, + 26, + 2, + 23, + 54, + 26, + 1, + 136, + 8, + 56, + 137, + 49, + 27, + 33, + 5, + 18, + 73, + 65, + 0, + 21, + 54, + 26, + 0, + 128, + 14, + 103, + 101, + 116, + 95, + 110, + 97, + 109, + 101, + 95, + 97, + 112, + 112, + 105, + 100, + 18, + 16, + 65, + 0, + 4, + 136, + 13, + 183, + 137, + 49, + 27, + 33, + 8, + 18, + 73, + 65, + 0, + 25, + 54, + 26, + 0, + 128, + 18, + 103, + 101, + 116, + 95, + 97, + 100, + 100, + 114, + 101, + 115, + 115, + 95, + 97, + 112, + 112, + 105, + 100, + 115, + 18, + 16, + 65, + 0, + 4, + 136, + 13, + 154, + 137, + 50, + 4, + 33, + 5, + 15, + 65, + 0, + 134, + 49, + 22, + 35, + 9, + 140, + 0, + 139, + 0, + 56, + 16, + 35, + 18, + 73, + 65, + 0, + 8, + 139, + 0, + 56, + 32, + 50, + 3, + 18, + 16, + 73, + 65, + 0, + 8, + 139, + 0, + 56, + 9, + 50, + 3, + 18, + 16, + 73, + 65, + 0, + 20, + 139, + 0, + 56, + 8, + 50, + 0, + 15, + 73, + 64, + 0, + 8, + 139, + 0, + 56, + 1, + 50, + 0, + 13, + 17, + 16, + 73, + 65, + 0, + 6, + 139, + 0, + 136, + 10, + 195, + 16, + 65, + 0, + 61, + 49, + 27, + 33, + 5, + 18, + 73, + 65, + 0, + 18, + 54, + 26, + 0, + 128, + 11, + 114, + 101, + 109, + 111, + 118, + 101, + 95, + 97, + 100, + 100, + 114, + 18, + 16, + 73, + 65, + 0, + 10, + 49, + 22, + 35, + 9, + 56, + 7, + 49, + 0, + 18, + 16, + 65, + 0, + 16, + 54, + 26, + 1, + 23, + 33, + 9, + 39, + 16, + 49, + 0, + 136, + 15, + 123, + 66, + 0, + 1, + 0, + 49, + 22, + 136, + 10, + 125, + 65, + 0, + 113, + 49, + 27, + 33, + 8, + 18, + 73, + 65, + 0, + 19, + 54, + 26, + 0, + 128, + 12, + 109, + 105, + 103, + 114, + 97, + 116, + 101, + 95, + 110, + 97, + 109, + 101, + 18, + 16, + 65, + 0, + 4, + 136, + 12, + 255, + 137, + 49, + 27, + 33, + 8, + 18, + 73, + 65, + 0, + 22, + 54, + 26, + 0, + 128, + 15, + 109, + 105, + 103, + 114, + 97, + 116, + 101, + 95, + 97, + 100, + 100, + 114, + 101, + 115, + 115, + 18, + 16, + 65, + 0, + 10, + 54, + 26, + 2, + 54, + 26, + 1, + 136, + 13, + 7, + 137, + 49, + 27, + 33, + 5, + 18, + 73, + 65, + 0, + 17, + 54, + 26, + 0, + 128, + 10, + 115, + 119, + 101, + 101, + 112, + 95, + 100, + 117, + 115, + 116, + 18, + 16, + 65, + 0, + 4, + 136, + 15, + 50, + 137, + 0, + 0, + 137, + 136, + 0, + 2, + 35, + 67, + 138, + 0, + 0, + 137, + 41, + 54, + 26, + 2, + 73, + 21, + 33, + 4, + 18, + 68, + 54, + 26, + 1, + 87, + 2, + 0, + 136, + 0, + 4, + 80, + 176, + 35, + 67, + 138, + 2, + 1, + 139, + 254, + 139, + 255, + 136, + 15, + 65, + 139, + 255, + 136, + 16, + 239, + 137, + 41, + 136, + 0, + 4, + 80, + 176, + 35, + 67, + 138, + 0, + 1, + 40, + 50, + 7, + 129, + 244, + 3, + 136, + 18, + 190, + 140, + 0, + 139, + 0, + 22, + 139, + 0, + 136, + 9, + 14, + 22, + 80, + 128, + 8, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 20, + 80, + 52, + 201, + 80, + 128, + 8, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 28, + 80, + 128, + 8, + 0, + 0, + 0, + 0, + 0, + 152, + 150, + 128, + 80, + 128, + 60, + 48, + 48, + 48, + 48, + 48, + 48, + 48, + 48, + 48, + 48, + 48, + 48, + 48, + 48, + 48, + 48, + 48, + 48, + 48, + 48, + 48, + 48, + 48, + 48, + 48, + 48, + 48, + 46, + 48, + 48, + 48, + 48, + 48, + 48, + 48, + 48, + 48, + 48, + 48, + 48, + 48, + 48, + 48, + 48, + 48, + 48, + 48, + 48, + 48, + 48, + 48, + 48, + 48, + 48, + 48, + 46, + 97, + 108, + 103, + 111, + 136, + 0, + 20, + 22, + 80, + 140, + 0, + 137, + 41, + 54, + 26, + 1, + 87, + 2, + 0, + 136, + 0, + 5, + 22, + 80, + 176, + 35, + 67, + 138, + 1, + 1, + 40, + 73, + 33, + 13, + 34, + 71, + 3, + 33, + 8, + 35, + 136, + 18, + 132, + 33, + 11, + 9, + 140, + 0, + 129, + 89, + 139, + 255, + 21, + 8, + 33, + 5, + 136, + 18, + 199, + 140, + 1, + 139, + 0, + 139, + 1, + 8, + 136, + 9, + 59, + 8, + 140, + 0, + 70, + 1, + 137, + 41, + 54, + 26, + 1, + 73, + 21, + 33, + 4, + 18, + 68, + 136, + 0, + 4, + 80, + 176, + 35, + 67, + 138, + 1, + 1, + 39, + 5, + 21, + 33, + 4, + 8, + 35, + 136, + 18, + 153, + 22, + 139, + 255, + 136, + 8, + 196, + 22, + 80, + 137, + 41, + 54, + 26, + 3, + 73, + 21, + 35, + 18, + 68, + 34, + 83, + 54, + 26, + 2, + 73, + 21, + 33, + 4, + 18, + 68, + 54, + 26, + 1, + 87, + 2, + 0, + 49, + 22, + 35, + 9, + 73, + 56, + 16, + 35, + 18, + 68, + 136, + 0, + 5, + 22, + 80, + 176, + 35, + 67, + 138, + 4, + 1, + 40, + 71, + 17, + 139, + 255, + 56, + 7, + 50, + 10, + 18, + 68, + 33, + 4, + 73, + 18, + 68, + 139, + 253, + 50, + 3, + 19, + 68, + 177, + 37, + 178, + 16, + 34, + 178, + 1, + 39, + 8, + 73, + 178, + 30, + 178, + 31, + 33, + 6, + 178, + 25, + 179, + 139, + 254, + 136, + 13, + 238, + 140, + 0, + 34, + 140, + 1, + 50, + 3, + 140, + 2, + 139, + 0, + 53, + 255, + 52, + 255, + 34, + 83, + 65, + 0, + 81, + 177, + 37, + 178, + 16, + 34, + 178, + 1, + 39, + 8, + 73, + 178, + 30, + 178, + 31, + 33, + 6, + 178, + 25, + 179, + 139, + 0, + 139, + 254, + 136, + 15, + 48, + 136, + 14, + 254, + 140, + 1, + 139, + 1, + 34, + 19, + 68, + 39, + 17, + 139, + 1, + 136, + 15, + 51, + 39, + 9, + 18, + 65, + 0, + 21, + 139, + 1, + 128, + 10, + 105, + 46, + 115, + 101, + 108, + 108, + 101, + 114, + 46, + 97, + 101, + 68, + 140, + 2, + 66, + 0, + 11, + 139, + 255, + 56, + 0, + 139, + 1, + 42, + 101, + 68, + 18, + 68, + 49, + 0, + 139, + 0, + 139, + 254, + 136, + 15, + 51, + 53, + 255, + 52, + 255, + 87, + 0, + 8, + 23, + 140, + 3, + 139, + 3, + 34, + 13, + 68, + 139, + 254, + 136, + 254, + 202, + 140, + 4, + 34, + 140, + 5, + 139, + 252, + 65, + 0, + 39, + 49, + 0, + 136, + 254, + 252, + 140, + 6, + 139, + 6, + 87, + 0, + 8, + 23, + 140, + 5, + 139, + 4, + 139, + 6, + 87, + 0, + 8, + 23, + 139, + 6, + 87, + 8, + 8, + 23, + 8, + 8, + 140, + 4, + 49, + 0, + 139, + 253, + 18, + 68, + 33, + 14, + 139, + 255, + 56, + 8, + 139, + 4, + 9, + 11, + 139, + 3, + 10, + 33, + 13, + 15, + 68, + 43, + 190, + 68, + 140, + 7, + 39, + 6, + 43, + 190, + 68, + 80, + 140, + 8, + 39, + 10, + 139, + 7, + 80, + 190, + 68, + 140, + 9, + 139, + 8, + 189, + 68, + 140, + 10, + 50, + 12, + 129, + 200, + 1, + 12, + 65, + 0, + 19, + 177, + 37, + 178, + 16, + 34, + 178, + 1, + 39, + 8, + 73, + 178, + 30, + 178, + 31, + 33, + 6, + 178, + 25, + 179, + 129, + 20, + 50, + 7, + 139, + 255, + 56, + 8, + 139, + 4, + 9, + 139, + 3, + 136, + 18, + 166, + 140, + 11, + 177, + 37, + 178, + 16, + 34, + 178, + 25, + 139, + 8, + 34, + 33, + 10, + 186, + 178, + 64, + 139, + 8, + 33, + 10, + 139, + 10, + 33, + 10, + 9, + 186, + 178, + 64, + 139, + 9, + 178, + 31, + 34, + 178, + 52, + 33, + 13, + 178, + 53, + 33, + 8, + 178, + 56, + 128, + 4, + 13, + 202, + 82, + 193, + 178, + 26, + 139, + 254, + 73, + 21, + 22, + 87, + 6, + 2, + 76, + 80, + 178, + 26, + 52, + 201, + 178, + 26, + 139, + 253, + 178, + 26, + 139, + 255, + 56, + 8, + 139, + 4, + 9, + 22, + 178, + 26, + 139, + 11, + 22, + 178, + 26, + 52, + 202, + 178, + 26, + 52, + 203, + 22, + 178, + 26, + 50, + 3, + 178, + 26, + 39, + 4, + 178, + 26, + 139, + 1, + 22, + 178, + 26, + 139, + 2, + 178, + 26, + 34, + 178, + 1, + 179, + 180, + 61, + 140, + 12, + 180, + 61, + 114, + 8, + 72, + 140, + 13, + 136, + 7, + 34, + 140, + 14, + 177, + 35, + 178, + 16, + 139, + 255, + 56, + 8, + 139, + 4, + 9, + 139, + 14, + 8, + 139, + 5, + 8, + 178, + 8, + 139, + 13, + 178, + 7, + 34, + 178, + 1, + 179, + 177, + 37, + 178, + 16, + 128, + 4, + 6, + 223, + 46, + 91, + 178, + 26, + 139, + 12, + 178, + 24, + 139, + 254, + 136, + 16, + 131, + 73, + 21, + 22, + 87, + 6, + 2, + 76, + 80, + 178, + 26, + 128, + 62, + 0, + 60, + 116, + 101, + 109, + 112, + 108, + 97, + 116, + 101, + 45, + 105, + 112, + 102, + 115, + 58, + 47, + 47, + 123, + 105, + 112, + 102, + 115, + 99, + 105, + 100, + 58, + 49, + 58, + 100, + 97, + 103, + 45, + 112, + 98, + 58, + 114, + 101, + 115, + 101, + 114, + 118, + 101, + 58, + 115, + 104, + 97, + 50, + 45, + 50, + 53, + 54, + 125, + 47, + 110, + 102, + 100, + 46, + 106, + 115, + 111, + 110, + 178, + 26, + 34, + 178, + 1, + 179, + 180, + 62, + 23, + 140, + 15, + 34, + 139, + 12, + 139, + 15, + 139, + 254, + 136, + 9, + 182, + 139, + 1, + 34, + 19, + 65, + 0, + 110, + 139, + 1, + 136, + 17, + 181, + 65, + 0, + 65, + 139, + 1, + 39, + 7, + 101, + 68, + 128, + 4, + 50, + 46, + 49, + 50, + 18, + 68, + 177, + 37, + 178, + 16, + 34, + 178, + 25, + 139, + 1, + 178, + 24, + 128, + 20, + 117, + 112, + 100, + 97, + 116, + 101, + 95, + 115, + 101, + 103, + 109, + 101, + 110, + 116, + 95, + 99, + 111, + 117, + 110, + 116, + 178, + 26, + 139, + 254, + 178, + 26, + 139, + 12, + 22, + 178, + 26, + 34, + 178, + 1, + 179, + 66, + 0, + 37, + 177, + 37, + 178, + 16, + 128, + 4, + 13, + 38, + 197, + 145, + 178, + 26, + 139, + 1, + 178, + 24, + 139, + 254, + 73, + 21, + 22, + 87, + 6, + 2, + 76, + 80, + 178, + 26, + 139, + 12, + 22, + 178, + 26, + 34, + 178, + 1, + 179, + 136, + 252, + 35, + 140, + 16, + 177, + 37, + 178, + 16, + 128, + 4, + 254, + 57, + 209, + 27, + 178, + 26, + 139, + 12, + 178, + 24, + 139, + 16, + 87, + 8, + 8, + 23, + 22, + 178, + 26, + 34, + 178, + 1, + 179, + 180, + 59, + 35, + 9, + 197, + 58, + 87, + 4, + 0, + 140, + 17, + 128, + 4, + 53, + 197, + 148, + 24, + 40, + 40, + 128, + 2, + 0, + 226, + 139, + 12, + 22, + 136, + 18, + 71, + 139, + 254, + 73, + 21, + 22, + 87, + 6, + 2, + 76, + 80, + 136, + 18, + 71, + 139, + 3, + 22, + 136, + 18, + 52, + 139, + 255, + 56, + 8, + 139, + 4, + 9, + 22, + 136, + 18, + 41, + 139, + 4, + 22, + 136, + 18, + 35, + 52, + 201, + 136, + 18, + 30, + 139, + 255, + 56, + 0, + 136, + 18, + 23, + 139, + 253, + 136, + 18, + 18, + 139, + 11, + 22, + 136, + 18, + 12, + 139, + 17, + 87, + 0, + 8, + 23, + 22, + 136, + 18, + 2, + 139, + 17, + 87, + 8, + 32, + 136, + 17, + 250, + 139, + 17, + 87, + 40, + 8, + 23, + 22, + 136, + 17, + 240, + 139, + 17, + 87, + 48, + 32, + 136, + 17, + 232, + 139, + 17, + 87, + 80, + 8, + 23, + 22, + 136, + 17, + 222, + 72, + 80, + 80, + 176, + 139, + 252, + 65, + 0, + 71, + 177, + 37, + 178, + 16, + 128, + 4, + 120, + 244, + 39, + 17, + 178, + 26, + 139, + 12, + 178, + 24, + 40, + 40, + 128, + 2, + 0, + 4, + 39, + 11, + 73, + 21, + 22, + 87, + 6, + 2, + 76, + 80, + 136, + 17, + 191, + 49, + 0, + 73, + 21, + 22, + 87, + 6, + 2, + 76, + 80, + 136, + 17, + 178, + 72, + 80, + 128, + 2, + 0, + 2, + 76, + 80, + 178, + 26, + 34, + 178, + 1, + 179, + 49, + 0, + 139, + 12, + 139, + 254, + 136, + 0, + 31, + 139, + 12, + 140, + 0, + 70, + 17, + 137, + 54, + 26, + 3, + 73, + 21, + 33, + 4, + 18, + 68, + 54, + 26, + 2, + 23, + 54, + 26, + 1, + 87, + 2, + 0, + 136, + 0, + 2, + 35, + 67, + 138, + 3, + 0, + 40, + 73, + 139, + 253, + 136, + 15, + 127, + 140, + 0, + 139, + 254, + 42, + 101, + 68, + 140, + 1, + 139, + 254, + 139, + 255, + 136, + 15, + 145, + 68, + 139, + 254, + 114, + 8, + 72, + 139, + 253, + 18, + 65, + 0, + 9, + 49, + 0, + 139, + 1, + 18, + 68, + 66, + 0, + 6, + 49, + 0, + 139, + 253, + 18, + 68, + 139, + 253, + 39, + 11, + 139, + 254, + 136, + 4, + 212, + 68, + 139, + 254, + 139, + 0, + 136, + 5, + 56, + 20, + 65, + 0, + 8, + 139, + 254, + 139, + 0, + 136, + 5, + 131, + 68, + 39, + 5, + 39, + 11, + 139, + 254, + 136, + 5, + 253, + 137, + 54, + 26, + 3, + 73, + 21, + 33, + 4, + 18, + 68, + 54, + 26, + 2, + 23, + 54, + 26, + 1, + 87, + 2, + 0, + 136, + 0, + 2, + 35, + 67, + 138, + 3, + 0, + 40, + 73, + 139, + 254, + 42, + 101, + 68, + 140, + 0, + 139, + 254, + 139, + 255, + 136, + 15, + 36, + 68, + 39, + 12, + 139, + 254, + 136, + 11, + 78, + 136, + 6, + 183, + 20, + 65, + 0, + 16, + 49, + 0, + 139, + 0, + 18, + 73, + 64, + 0, + 6, + 49, + 0, + 139, + 253, + 18, + 17, + 68, + 139, + 253, + 39, + 5, + 139, + 254, + 136, + 4, + 99, + 68, + 139, + 253, + 136, + 14, + 212, + 140, + 1, + 139, + 254, + 139, + 1, + 136, + 8, + 68, + 68, + 139, + 1, + 189, + 76, + 72, + 20, + 65, + 0, + 36, + 177, + 35, + 178, + 16, + 139, + 1, + 21, + 36, + 8, + 35, + 136, + 13, + 178, + 178, + 8, + 49, + 0, + 178, + 7, + 128, + 9, + 98, + 111, + 120, + 82, + 101, + 102, + 117, + 110, + 100, + 178, + 5, + 34, + 178, + 1, + 179, + 49, + 0, + 139, + 253, + 39, + 5, + 139, + 254, + 136, + 5, + 218, + 137, + 54, + 26, + 2, + 23, + 54, + 26, + 1, + 87, + 2, + 0, + 136, + 0, + 2, + 35, + 67, + 138, + 2, + 0, + 40, + 139, + 254, + 139, + 255, + 136, + 1, + 201, + 68, + 139, + 254, + 139, + 254, + 42, + 101, + 68, + 136, + 14, + 128, + 140, + 0, + 139, + 0, + 189, + 76, + 72, + 20, + 68, + 139, + 0, + 139, + 255, + 191, + 137, + 54, + 26, + 4, + 73, + 21, + 33, + 4, + 18, + 68, + 54, + 26, + 3, + 73, + 21, + 33, + 4, + 18, + 68, + 54, + 26, + 2, + 23, + 54, + 26, + 1, + 87, + 2, + 0, + 136, + 0, + 2, + 35, + 67, + 138, + 4, + 0, + 40, + 73, + 139, + 253, + 139, + 252, + 18, + 65, + 0, + 1, + 137, + 139, + 254, + 139, + 255, + 136, + 14, + 73, + 68, + 139, + 254, + 39, + 7, + 101, + 68, + 128, + 3, + 51, + 46, + 51, + 18, + 65, + 0, + 9, + 49, + 22, + 136, + 3, + 103, + 68, + 66, + 0, + 9, + 49, + 0, + 139, + 254, + 114, + 8, + 72, + 18, + 68, + 139, + 254, + 139, + 253, + 136, + 14, + 18, + 140, + 0, + 139, + 254, + 139, + 252, + 136, + 14, + 9, + 140, + 1, + 139, + 0, + 188, + 139, + 1, + 139, + 255, + 191, + 137, + 54, + 26, + 3, + 73, + 21, + 33, + 4, + 18, + 68, + 54, + 26, + 2, + 23, + 54, + 26, + 1, + 87, + 2, + 0, + 136, + 0, + 2, + 35, + 67, + 138, + 3, + 0, + 40, + 139, + 254, + 139, + 255, + 136, + 13, + 233, + 68, + 139, + 254, + 42, + 101, + 68, + 140, + 0, + 139, + 254, + 114, + 8, + 72, + 139, + 253, + 18, + 65, + 0, + 9, + 49, + 0, + 139, + 0, + 18, + 68, + 66, + 0, + 6, + 49, + 0, + 139, + 253, + 18, + 68, + 139, + 254, + 54, + 26, + 3, + 136, + 13, + 157, + 136, + 6, + 148, + 128, + 4, + 81, + 114, + 207, + 1, + 40, + 40, + 128, + 2, + 0, + 42, + 139, + 254, + 22, + 136, + 15, + 110, + 139, + 255, + 73, + 21, + 22, + 87, + 6, + 2, + 76, + 80, + 136, + 15, + 110, + 139, + 253, + 136, + 15, + 92, + 72, + 80, + 80, + 176, + 137, + 41, + 54, + 26, + 1, + 87, + 2, + 0, + 136, + 0, + 12, + 73, + 21, + 22, + 87, + 6, + 2, + 76, + 80, + 80, + 176, + 35, + 67, + 138, + 1, + 1, + 40, + 71, + 5, + 139, + 255, + 136, + 0, + 217, + 140, + 0, + 139, + 0, + 42, + 101, + 68, + 140, + 1, + 139, + 0, + 39, + 18, + 101, + 68, + 139, + 255, + 18, + 68, + 49, + 0, + 139, + 1, + 18, + 68, + 139, + 0, + 39, + 12, + 101, + 76, + 72, + 68, + 43, + 190, + 68, + 140, + 2, + 139, + 0, + 39, + 7, + 101, + 68, + 139, + 2, + 19, + 68, + 39, + 6, + 43, + 190, + 68, + 80, + 140, + 3, + 39, + 10, + 139, + 2, + 80, + 190, + 68, + 140, + 4, + 139, + 3, + 189, + 68, + 140, + 5, + 177, + 37, + 178, + 16, + 128, + 4, + 23, + 71, + 64, + 91, + 178, + 26, + 33, + 7, + 178, + 25, + 139, + 0, + 178, + 24, + 139, + 2, + 73, + 21, + 22, + 87, + 6, + 2, + 76, + 80, + 178, + 26, + 139, + 3, + 34, + 33, + 10, + 186, + 178, + 64, + 139, + 3, + 33, + 10, + 139, + 5, + 33, + 10, + 9, + 186, + 178, + 64, + 139, + 4, + 178, + 31, + 34, + 178, + 1, + 179, + 139, + 2, + 140, + 0, + 70, + 5, + 137, + 41, + 54, + 26, + 2, + 23, + 54, + 26, + 1, + 87, + 2, + 0, + 136, + 0, + 10, + 39, + 13, + 34, + 79, + 2, + 84, + 80, + 176, + 35, + 67, + 138, + 2, + 1, + 40, + 139, + 255, + 136, + 12, + 155, + 140, + 0, + 139, + 0, + 189, + 76, + 72, + 20, + 65, + 0, + 10, + 139, + 254, + 139, + 255, + 136, + 12, + 100, + 66, + 0, + 7, + 139, + 254, + 139, + 255, + 136, + 12, + 171, + 140, + 0, + 137, + 41, + 54, + 26, + 1, + 87, + 2, + 0, + 136, + 0, + 5, + 22, + 80, + 176, + 35, + 67, + 138, + 1, + 1, + 40, + 73, + 139, + 255, + 136, + 12, + 99, + 140, + 0, + 139, + 0, + 189, + 76, + 72, + 20, + 65, + 0, + 4, + 34, + 66, + 0, + 17, + 139, + 0, + 190, + 68, + 140, + 1, + 139, + 1, + 21, + 33, + 9, + 18, + 68, + 139, + 1, + 36, + 91, + 140, + 0, + 70, + 1, + 137, + 41, + 54, + 26, + 1, + 73, + 21, + 33, + 4, + 18, + 68, + 136, + 0, + 14, + 73, + 21, + 36, + 10, + 22, + 87, + 6, + 2, + 76, + 80, + 80, + 176, + 35, + 67, + 138, + 1, + 1, + 40, + 71, + 4, + 40, + 140, + 0, + 139, + 255, + 136, + 12, + 31, + 140, + 1, + 139, + 1, + 189, + 76, + 72, + 20, + 65, + 0, + 5, + 139, + 0, + 66, + 0, + 53, + 139, + 1, + 190, + 68, + 140, + 2, + 34, + 140, + 3, + 139, + 3, + 139, + 2, + 21, + 12, + 65, + 0, + 33, + 139, + 2, + 139, + 3, + 36, + 88, + 23, + 140, + 4, + 139, + 4, + 34, + 19, + 65, + 0, + 8, + 139, + 0, + 139, + 4, + 22, + 80, + 140, + 0, + 139, + 3, + 36, + 8, + 140, + 3, + 66, + 255, + 214, + 139, + 0, + 140, + 0, + 70, + 4, + 137, + 54, + 26, + 3, + 87, + 2, + 0, + 54, + 26, + 2, + 23, + 54, + 26, + 1, + 87, + 2, + 0, + 136, + 0, + 2, + 35, + 67, + 138, + 3, + 0, + 49, + 22, + 136, + 1, + 13, + 68, + 39, + 6, + 139, + 255, + 80, + 139, + 254, + 185, + 72, + 39, + 10, + 139, + 255, + 80, + 139, + 253, + 191, + 137, + 54, + 26, + 3, + 87, + 2, + 0, + 54, + 26, + 2, + 23, + 54, + 26, + 1, + 87, + 2, + 0, + 136, + 0, + 2, + 35, + 67, + 138, + 3, + 0, + 49, + 22, + 136, + 0, + 221, + 68, + 39, + 6, + 139, + 255, + 80, + 139, + 254, + 139, + 253, + 187, + 137, + 54, + 26, + 1, + 87, + 2, + 0, + 136, + 0, + 2, + 35, + 67, + 138, + 1, + 0, + 49, + 22, + 136, + 0, + 190, + 68, + 43, + 139, + 255, + 191, + 137, + 41, + 54, + 26, + 1, + 23, + 136, + 0, + 5, + 22, + 80, + 176, + 35, + 67, + 138, + 1, + 1, + 40, + 71, + 2, + 52, + 204, + 128, + 2, + 116, + 115, + 101, + 68, + 140, + 0, + 52, + 204, + 128, + 8, + 100, + 101, + 99, + 105, + 109, + 97, + 108, + 115, + 101, + 68, + 140, + 1, + 52, + 204, + 128, + 5, + 112, + 114, + 105, + 99, + 101, + 101, + 68, + 140, + 2, + 50, + 7, + 139, + 0, + 9, + 33, + 15, + 13, + 65, + 0, + 34, + 33, + 5, + 140, + 1, + 129, + 33, + 140, + 2, + 128, + 23, + 111, + 114, + 97, + 99, + 108, + 101, + 32, + 62, + 50, + 52, + 104, + 114, + 32, + 117, + 115, + 105, + 110, + 103, + 32, + 46, + 51, + 51, + 99, + 176, + 139, + 255, + 33, + 16, + 11, + 139, + 1, + 136, + 9, + 136, + 11, + 139, + 2, + 10, + 33, + 16, + 10, + 33, + 16, + 11, + 140, + 0, + 70, + 2, + 137, + 41, + 54, + 26, + 1, + 73, + 21, + 33, + 4, + 18, + 68, + 136, + 0, + 5, + 22, + 80, + 176, + 35, + 67, + 138, + 1, + 1, + 40, + 139, + 255, + 136, + 10, + 200, + 140, + 0, + 139, + 0, + 189, + 76, + 72, + 20, + 65, + 0, + 12, + 139, + 0, + 21, + 36, + 8, + 35, + 136, + 9, + 178, + 66, + 0, + 3, + 129, + 128, + 25, + 140, + 0, + 137, + 138, + 1, + 1, + 139, + 255, + 56, + 0, + 52, + 200, + 112, + 0, + 72, + 35, + 18, + 73, + 65, + 0, + 8, + 139, + 255, + 56, + 9, + 50, + 3, + 18, + 16, + 73, + 65, + 0, + 8, + 139, + 255, + 56, + 32, + 50, + 3, + 18, + 16, + 137, + 138, + 0, + 1, + 34, + 71, + 3, + 35, + 34, + 73, + 136, + 9, + 35, + 137, + 138, + 3, + 1, + 139, + 255, + 136, + 11, + 27, + 65, + 0, + 49, + 177, + 37, + 178, + 16, + 139, + 255, + 178, + 24, + 128, + 19, + 105, + 115, + 95, + 97, + 100, + 100, + 114, + 101, + 115, + 115, + 95, + 105, + 110, + 95, + 102, + 105, + 101, + 108, + 100, + 178, + 26, + 139, + 254, + 178, + 26, + 139, + 253, + 178, + 26, + 34, + 178, + 1, + 179, + 180, + 62, + 23, + 35, + 18, + 137, + 177, + 37, + 178, + 16, + 128, + 4, + 212, + 67, + 149, + 42, + 178, + 26, + 139, + 255, + 178, + 24, + 139, + 254, + 73, + 21, + 22, + 87, + 6, + 2, + 76, + 80, + 178, + 26, + 139, + 253, + 178, + 26, + 34, + 178, + 1, + 179, + 180, + 59, + 35, + 9, + 197, + 58, + 87, + 4, + 0, + 34, + 83, + 137, + 138, + 2, + 1, + 40, + 71, + 3, + 139, + 254, + 34, + 19, + 68, + 139, + 255, + 189, + 76, + 72, + 20, + 65, + 0, + 4, + 34, + 66, + 0, + 57, + 139, + 255, + 190, + 68, + 140, + 0, + 139, + 0, + 140, + 1, + 139, + 0, + 21, + 36, + 10, + 140, + 2, + 34, + 140, + 3, + 139, + 3, + 139, + 2, + 12, + 65, + 0, + 28, + 139, + 1, + 139, + 3, + 36, + 11, + 36, + 88, + 23, + 139, + 254, + 18, + 65, + 0, + 4, + 35, + 66, + 0, + 10, + 139, + 3, + 35, + 8, + 140, + 3, + 66, + 255, + 220, + 34, + 140, + 0, + 70, + 3, + 137, + 138, + 2, + 1, + 40, + 71, + 3, + 139, + 255, + 189, + 76, + 72, + 20, + 65, + 0, + 10, + 139, + 255, + 139, + 254, + 22, + 191, + 35, + 66, + 0, + 102, + 139, + 255, + 190, + 68, + 140, + 0, + 139, + 0, + 21, + 36, + 10, + 140, + 1, + 34, + 140, + 2, + 139, + 2, + 139, + 1, + 12, + 65, + 0, + 51, + 139, + 0, + 139, + 2, + 36, + 11, + 91, + 140, + 3, + 139, + 3, + 34, + 18, + 65, + 0, + 14, + 139, + 255, + 139, + 2, + 36, + 11, + 139, + 254, + 22, + 187, + 35, + 66, + 0, + 48, + 139, + 3, + 139, + 254, + 18, + 65, + 0, + 4, + 35, + 66, + 0, + 36, + 139, + 2, + 35, + 8, + 140, + 2, + 66, + 255, + 197, + 139, + 0, + 21, + 129, + 240, + 7, + 12, + 65, + 0, + 16, + 139, + 255, + 188, + 139, + 255, + 139, + 0, + 139, + 254, + 22, + 80, + 191, + 35, + 66, + 0, + 1, + 34, + 140, + 0, + 70, + 3, + 137, + 138, + 3, + 1, + 139, + 255, + 136, + 9, + 213, + 65, + 0, + 54, + 177, + 37, + 178, + 16, + 139, + 255, + 178, + 24, + 128, + 24, + 114, + 101, + 103, + 95, + 97, + 100, + 100, + 95, + 118, + 101, + 114, + 105, + 102, + 105, + 101, + 100, + 95, + 97, + 100, + 100, + 114, + 101, + 115, + 115, + 178, + 26, + 139, + 254, + 178, + 26, + 139, + 253, + 178, + 26, + 34, + 178, + 1, + 179, + 180, + 62, + 23, + 35, + 18, + 137, + 177, + 37, + 178, + 16, + 128, + 4, + 133, + 204, + 237, + 87, + 178, + 26, + 139, + 255, + 178, + 24, + 139, + 254, + 73, + 21, + 22, + 87, + 6, + 2, + 76, + 80, + 178, + 26, + 139, + 253, + 73, + 21, + 22, + 87, + 6, + 2, + 76, + 80, + 178, + 26, + 34, + 178, + 1, + 179, + 180, + 59, + 35, + 9, + 197, + 58, + 87, + 4, + 0, + 34, + 83, + 137, + 138, + 4, + 1, + 139, + 255, + 136, + 9, + 92, + 65, + 0, + 57, + 177, + 37, + 178, + 16, + 139, + 255, + 178, + 24, + 128, + 27, + 114, + 101, + 103, + 95, + 114, + 101, + 109, + 111, + 118, + 101, + 95, + 118, + 101, + 114, + 105, + 102, + 105, + 101, + 100, + 95, + 97, + 100, + 100, + 114, + 101, + 115, + 115, + 178, + 26, + 139, + 254, + 178, + 26, + 139, + 253, + 178, + 26, + 34, + 178, + 1, + 179, + 180, + 62, + 23, + 35, + 18, + 137, + 177, + 37, + 178, + 16, + 128, + 4, + 177, + 137, + 10, + 117, + 178, + 26, + 139, + 255, + 178, + 24, + 139, + 254, + 73, + 21, + 22, + 87, + 6, + 2, + 76, + 80, + 178, + 26, + 139, + 253, + 178, + 26, + 139, + 252, + 178, + 26, + 34, + 178, + 1, + 179, + 180, + 59, + 35, + 9, + 197, + 58, + 87, + 4, + 0, + 34, + 83, + 137, + 138, + 1, + 1, + 139, + 255, + 34, + 18, + 65, + 0, + 2, + 34, + 137, + 50, + 7, + 139, + 255, + 13, + 137, + 138, + 0, + 0, + 54, + 26, + 1, + 136, + 251, + 174, + 22, + 176, + 137, + 138, + 0, + 0, + 40, + 54, + 26, + 1, + 136, + 8, + 24, + 140, + 0, + 139, + 0, + 189, + 76, + 72, + 20, + 65, + 0, + 3, + 40, + 176, + 137, + 139, + 0, + 190, + 68, + 176, + 137, + 138, + 0, + 0, + 40, + 54, + 26, + 2, + 23, + 54, + 26, + 1, + 136, + 7, + 199, + 68, + 54, + 26, + 2, + 23, + 128, + 7, + 105, + 46, + 97, + 115, + 97, + 105, + 100, + 101, + 68, + 140, + 0, + 139, + 0, + 40, + 19, + 68, + 35, + 54, + 26, + 2, + 23, + 139, + 0, + 23, + 54, + 26, + 1, + 136, + 0, + 114, + 137, + 138, + 2, + 0, + 40, + 71, + 3, + 139, + 255, + 136, + 7, + 197, + 189, + 76, + 72, + 65, + 0, + 1, + 137, + 128, + 8, + 97, + 100, + 100, + 114, + 101, + 115, + 115, + 47, + 139, + 254, + 80, + 136, + 7, + 32, + 140, + 0, + 40, + 140, + 1, + 34, + 140, + 2, + 139, + 2, + 33, + 9, + 12, + 65, + 0, + 62, + 39, + 16, + 139, + 2, + 136, + 9, + 80, + 80, + 140, + 3, + 139, + 0, + 54, + 50, + 0, + 139, + 3, + 99, + 76, + 72, + 65, + 0, + 13, + 139, + 1, + 139, + 0, + 139, + 3, + 98, + 80, + 140, + 1, + 66, + 0, + 17, + 139, + 1, + 21, + 34, + 13, + 65, + 0, + 8, + 139, + 255, + 136, + 7, + 109, + 139, + 1, + 191, + 137, + 139, + 2, + 35, + 8, + 140, + 2, + 66, + 255, + 186, + 137, + 138, + 4, + 0, + 40, + 139, + 252, + 20, + 65, + 0, + 7, + 139, + 255, + 136, + 0, + 33, + 20, + 68, + 139, + 255, + 136, + 7, + 63, + 140, + 0, + 139, + 254, + 68, + 139, + 253, + 68, + 139, + 0, + 189, + 76, + 72, + 20, + 68, + 139, + 0, + 139, + 254, + 22, + 139, + 253, + 22, + 80, + 191, + 137, + 138, + 1, + 1, + 40, + 39, + 14, + 139, + 255, + 80, + 136, + 6, + 149, + 140, + 0, + 139, + 0, + 54, + 50, + 0, + 97, + 20, + 65, + 0, + 4, + 34, + 66, + 0, + 10, + 139, + 0, + 54, + 50, + 0, + 39, + 15, + 99, + 76, + 72, + 140, + 0, + 137, + 138, + 2, + 1, + 40, + 71, + 4, + 139, + 255, + 190, + 68, + 140, + 0, + 139, + 254, + 34, + 19, + 68, + 139, + 0, + 21, + 33, + 9, + 15, + 68, + 139, + 0, + 34, + 91, + 139, + 254, + 18, + 65, + 0, + 4, + 35, + 66, + 0, + 84, + 139, + 0, + 21, + 36, + 10, + 140, + 1, + 34, + 140, + 2, + 34, + 140, + 3, + 139, + 3, + 139, + 1, + 12, + 65, + 0, + 29, + 139, + 0, + 139, + 3, + 36, + 11, + 91, + 139, + 254, + 18, + 65, + 0, + 7, + 139, + 3, + 140, + 2, + 66, + 0, + 9, + 139, + 3, + 35, + 8, + 140, + 3, + 66, + 255, + 219, + 139, + 2, + 34, + 19, + 68, + 139, + 0, + 34, + 91, + 140, + 4, + 139, + 0, + 34, + 139, + 254, + 22, + 93, + 140, + 0, + 139, + 255, + 139, + 0, + 139, + 2, + 36, + 11, + 139, + 4, + 22, + 93, + 191, + 35, + 140, + 0, + 70, + 4, + 137, + 138, + 2, + 1, + 40, + 71, + 2, + 139, + 255, + 190, + 68, + 140, + 0, + 139, + 0, + 21, + 36, + 10, + 140, + 1, + 34, + 140, + 2, + 139, + 2, + 139, + 1, + 12, + 65, + 0, + 70, + 139, + 0, + 139, + 2, + 36, + 11, + 91, + 139, + 254, + 18, + 65, + 0, + 48, + 139, + 2, + 139, + 1, + 35, + 9, + 18, + 65, + 0, + 25, + 139, + 255, + 188, + 139, + 2, + 34, + 13, + 65, + 0, + 11, + 139, + 255, + 139, + 0, + 34, + 139, + 2, + 36, + 11, + 88, + 191, + 35, + 66, + 0, + 23, + 139, + 255, + 139, + 2, + 36, + 11, + 39, + 4, + 187, + 35, + 66, + 0, + 10, + 139, + 2, + 35, + 8, + 140, + 2, + 66, + 255, + 178, + 34, + 140, + 0, + 70, + 2, + 137, + 138, + 3, + 1, + 139, + 254, + 34, + 139, + 253, + 82, + 139, + 255, + 22, + 80, + 139, + 254, + 139, + 253, + 36, + 8, + 139, + 254, + 21, + 82, + 80, + 137, + 138, + 3, + 1, + 40, + 71, + 2, + 139, + 255, + 139, + 254, + 98, + 140, + 0, + 139, + 0, + 21, + 36, + 10, + 140, + 1, + 34, + 140, + 2, + 139, + 2, + 139, + 1, + 12, + 65, + 0, + 41, + 139, + 0, + 139, + 2, + 36, + 11, + 91, + 139, + 253, + 18, + 65, + 0, + 19, + 139, + 255, + 139, + 254, + 139, + 2, + 36, + 11, + 139, + 0, + 34, + 136, + 255, + 173, + 102, + 35, + 66, + 0, + 10, + 139, + 2, + 35, + 8, + 140, + 2, + 66, + 255, + 207, + 34, + 140, + 0, + 70, + 2, + 137, + 138, + 4, + 1, + 40, + 34, + 140, + 0, + 139, + 0, + 139, + 253, + 12, + 65, + 0, + 31, + 139, + 252, + 139, + 254, + 139, + 0, + 136, + 7, + 87, + 80, + 139, + 255, + 136, + 255, + 148, + 65, + 0, + 4, + 35, + 66, + 0, + 10, + 139, + 0, + 35, + 8, + 140, + 0, + 66, + 255, + 217, + 34, + 140, + 0, + 137, + 138, + 0, + 0, + 40, + 73, + 50, + 10, + 115, + 0, + 72, + 140, + 0, + 50, + 10, + 115, + 1, + 72, + 140, + 1, + 139, + 0, + 139, + 1, + 13, + 65, + 0, + 33, + 177, + 35, + 178, + 16, + 139, + 0, + 139, + 1, + 9, + 178, + 8, + 54, + 26, + 1, + 178, + 7, + 128, + 9, + 115, + 119, + 101, + 101, + 112, + 68, + 117, + 115, + 116, + 178, + 5, + 34, + 178, + 1, + 179, + 137, + 138, + 1, + 1, + 40, + 71, + 6, + 139, + 255, + 21, + 140, + 0, + 139, + 0, + 37, + 15, + 68, + 139, + 255, + 139, + 0, + 33, + 6, + 9, + 33, + 6, + 88, + 128, + 5, + 46, + 97, + 108, + 103, + 111, + 18, + 68, + 39, + 13, + 34, + 73, + 84, + 39, + 4, + 80, + 39, + 4, + 80, + 140, + 1, + 34, + 140, + 2, + 34, + 140, + 3, + 34, + 140, + 4, + 34, + 140, + 5, + 139, + 5, + 139, + 0, + 33, + 7, + 9, + 12, + 65, + 0, + 153, + 139, + 255, + 139, + 5, + 85, + 140, + 6, + 139, + 6, + 129, + 46, + 18, + 65, + 0, + 81, + 139, + 2, + 35, + 8, + 140, + 2, + 139, + 2, + 35, + 18, + 65, + 0, + 25, + 139, + 5, + 140, + 4, + 139, + 3, + 35, + 15, + 73, + 65, + 0, + 6, + 139, + 3, + 33, + 17, + 14, + 16, + 68, + 34, + 140, + 3, + 66, + 0, + 40, + 139, + 2, + 33, + 5, + 18, + 65, + 0, + 31, + 139, + 3, + 35, + 15, + 73, + 65, + 0, + 6, + 139, + 3, + 33, + 17, + 14, + 16, + 73, + 65, + 0, + 9, + 139, + 5, + 139, + 0, + 33, + 6, + 9, + 18, + 16, + 68, + 66, + 0, + 1, + 0, + 66, + 0, + 48, + 139, + 6, + 129, + 97, + 15, + 73, + 65, + 0, + 6, + 139, + 6, + 129, + 122, + 14, + 16, + 73, + 64, + 0, + 16, + 139, + 6, + 129, + 48, + 15, + 73, + 65, + 0, + 6, + 139, + 6, + 129, + 57, + 14, + 16, + 17, + 65, + 0, + 9, + 139, + 3, + 35, + 8, + 140, + 3, + 66, + 0, + 1, + 0, + 139, + 5, + 35, + 8, + 140, + 5, + 66, + 255, + 92, + 139, + 2, + 35, + 18, + 65, + 0, + 39, + 139, + 1, + 53, + 255, + 52, + 255, + 34, + 73, + 84, + 140, + 1, + 139, + 1, + 53, + 255, + 52, + 255, + 35, + 139, + 4, + 22, + 93, + 140, + 1, + 139, + 1, + 53, + 255, + 52, + 255, + 39, + 4, + 92, + 9, + 140, + 1, + 66, + 0, + 44, + 139, + 1, + 53, + 255, + 52, + 255, + 34, + 35, + 84, + 140, + 1, + 139, + 1, + 53, + 255, + 52, + 255, + 35, + 139, + 3, + 22, + 93, + 140, + 1, + 139, + 1, + 53, + 255, + 52, + 255, + 129, + 9, + 139, + 0, + 33, + 6, + 9, + 139, + 3, + 9, + 22, + 93, + 140, + 1, + 139, + 1, + 140, + 0, + 70, + 6, + 137, + 138, + 1, + 1, + 40, + 73, + 139, + 255, + 136, + 3, + 242, + 140, + 0, + 139, + 0, + 189, + 76, + 72, + 20, + 65, + 0, + 4, + 34, + 66, + 0, + 17, + 139, + 0, + 190, + 68, + 140, + 1, + 139, + 1, + 21, + 33, + 9, + 18, + 68, + 139, + 1, + 36, + 91, + 140, + 0, + 70, + 1, + 137, + 138, + 2, + 1, + 139, + 255, + 139, + 254, + 53, + 255, + 52, + 255, + 87, + 9, + 8, + 23, + 139, + 255, + 21, + 82, + 137, + 138, + 2, + 1, + 139, + 255, + 139, + 254, + 101, + 76, + 72, + 20, + 65, + 0, + 2, + 40, + 137, + 139, + 255, + 139, + 254, + 101, + 68, + 137, + 138, + 2, + 1, + 139, + 255, + 139, + 254, + 101, + 76, + 72, + 20, + 65, + 0, + 2, + 34, + 137, + 139, + 255, + 139, + 254, + 101, + 68, + 23, + 137, + 138, + 3, + 1, + 40, + 71, + 19, + 136, + 239, + 17, + 140, + 0, + 139, + 254, + 53, + 255, + 52, + 255, + 34, + 83, + 65, + 0, + 110, + 139, + 254, + 139, + 255, + 136, + 255, + 160, + 136, + 255, + 110, + 140, + 2, + 139, + 2, + 34, + 19, + 68, + 34, + 140, + 3, + 39, + 17, + 139, + 2, + 136, + 255, + 160, + 39, + 9, + 18, + 65, + 0, + 49, + 128, + 17, + 105, + 46, + 115, + 101, + 103, + 109, + 101, + 110, + 116, + 80, + 114, + 105, + 99, + 101, + 85, + 115, + 100, + 139, + 2, + 136, + 255, + 153, + 140, + 3, + 139, + 3, + 139, + 0, + 87, + 0, + 8, + 23, + 12, + 65, + 0, + 8, + 139, + 0, + 87, + 0, + 8, + 23, + 140, + 3, + 66, + 0, + 8, + 139, + 0, + 87, + 0, + 8, + 23, + 140, + 3, + 139, + 3, + 139, + 0, + 87, + 0, + 8, + 23, + 15, + 68, + 139, + 3, + 136, + 247, + 191, + 140, + 1, + 66, + 0, + 112, + 139, + 254, + 53, + 255, + 52, + 255, + 87, + 1, + 8, + 23, + 140, + 4, + 34, + 140, + 5, + 139, + 4, + 33, + 6, + 15, + 65, + 0, + 8, + 129, + 216, + 4, + 140, + 5, + 66, + 0, + 65, + 139, + 4, + 33, + 7, + 18, + 65, + 0, + 8, + 129, + 176, + 9, + 140, + 5, + 66, + 0, + 49, + 139, + 4, + 33, + 8, + 18, + 65, + 0, + 8, + 129, + 184, + 23, + 140, + 5, + 66, + 0, + 33, + 139, + 4, + 33, + 5, + 18, + 65, + 0, + 8, + 129, + 168, + 70, + 140, + 5, + 66, + 0, + 17, + 139, + 4, + 35, + 18, + 65, + 0, + 9, + 129, + 140, + 246, + 1, + 140, + 5, + 66, + 0, + 1, + 0, + 50, + 7, + 139, + 5, + 136, + 0, + 249, + 140, + 6, + 139, + 6, + 136, + 247, + 76, + 140, + 1, + 139, + 255, + 136, + 246, + 36, + 140, + 7, + 34, + 140, + 8, + 34, + 140, + 9, + 139, + 7, + 34, + 19, + 65, + 0, + 151, + 139, + 253, + 139, + 7, + 42, + 101, + 68, + 18, + 140, + 10, + 39, + 12, + 139, + 7, + 136, + 254, + 207, + 140, + 11, + 139, + 11, + 136, + 250, + 52, + 73, + 65, + 0, + 4, + 139, + 10, + 20, + 16, + 65, + 0, + 116, + 35, + 140, + 8, + 35, + 140, + 9, + 139, + 0, + 87, + 64, + 8, + 23, + 136, + 247, + 4, + 140, + 12, + 139, + 1, + 140, + 13, + 50, + 7, + 140, + 14, + 139, + 11, + 139, + 0, + 87, + 56, + 8, + 23, + 33, + 18, + 11, + 33, + 18, + 11, + 129, + 24, + 11, + 8, + 140, + 15, + 139, + 14, + 139, + 11, + 13, + 68, + 139, + 14, + 139, + 15, + 15, + 65, + 0, + 7, + 139, + 13, + 140, + 1, + 66, + 0, + 50, + 139, + 14, + 139, + 11, + 9, + 140, + 16, + 139, + 15, + 139, + 11, + 9, + 140, + 17, + 139, + 12, + 139, + 13, + 9, + 140, + 18, + 139, + 18, + 139, + 16, + 11, + 139, + 17, + 10, + 140, + 19, + 139, + 12, + 139, + 19, + 9, + 140, + 1, + 139, + 1, + 139, + 13, + 12, + 65, + 0, + 4, + 139, + 13, + 140, + 1, + 139, + 1, + 129, + 192, + 132, + 61, + 15, + 68, + 139, + 1, + 22, + 139, + 7, + 34, + 18, + 65, + 0, + 8, + 139, + 255, + 136, + 237, + 245, + 66, + 0, + 1, + 34, + 22, + 80, + 39, + 13, + 34, + 139, + 7, + 34, + 19, + 84, + 35, + 139, + 9, + 84, + 33, + 5, + 139, + 8, + 84, + 80, + 140, + 0, + 70, + 19, + 137, + 41, + 54, + 26, + 2, + 23, + 54, + 26, + 1, + 23, + 136, + 0, + 5, + 22, + 80, + 176, + 35, + 67, + 138, + 2, + 1, + 40, + 71, + 3, + 139, + 254, + 33, + 19, + 12, + 65, + 0, + 5, + 139, + 255, + 66, + 0, + 46, + 139, + 254, + 33, + 19, + 9, + 140, + 0, + 139, + 0, + 129, + 128, + 231, + 132, + 15, + 10, + 140, + 1, + 139, + 1, + 34, + 18, + 65, + 0, + 5, + 139, + 255, + 66, + 0, + 17, + 129, + 102, + 139, + 1, + 149, + 140, + 2, + 140, + 3, + 139, + 255, + 139, + 2, + 11, + 129, + 100, + 10, + 140, + 0, + 70, + 3, + 137, + 138, + 1, + 1, + 40, + 73, + 33, + 12, + 139, + 255, + 149, + 140, + 0, + 140, + 1, + 139, + 0, + 140, + 0, + 70, + 1, + 137, + 138, + 7, + 1, + 40, + 33, + 11, + 140, + 0, + 139, + 0, + 139, + 255, + 33, + 11, + 11, + 8, + 140, + 0, + 139, + 0, + 139, + 254, + 33, + 11, + 11, + 8, + 140, + 0, + 139, + 0, + 139, + 253, + 33, + 11, + 11, + 8, + 140, + 0, + 139, + 0, + 139, + 252, + 33, + 20, + 11, + 8, + 140, + 0, + 139, + 0, + 139, + 250, + 33, + 20, + 11, + 8, + 140, + 0, + 139, + 0, + 139, + 251, + 33, + 21, + 11, + 8, + 140, + 0, + 139, + 0, + 139, + 249, + 33, + 21, + 11, + 8, + 140, + 0, + 139, + 0, + 140, + 0, + 137, + 138, + 2, + 1, + 129, + 196, + 19, + 139, + 255, + 11, + 139, + 254, + 129, + 144, + 3, + 11, + 8, + 137, + 138, + 1, + 1, + 139, + 255, + 21, + 33, + 4, + 14, + 65, + 0, + 3, + 139, + 255, + 137, + 139, + 255, + 34, + 33, + 4, + 39, + 19, + 21, + 9, + 82, + 39, + 19, + 80, + 137, + 138, + 2, + 1, + 40, + 139, + 254, + 140, + 0, + 139, + 255, + 33, + 22, + 15, + 65, + 0, + 25, + 139, + 255, + 33, + 23, + 26, + 33, + 22, + 25, + 22, + 87, + 7, + 1, + 139, + 255, + 129, + 7, + 145, + 136, + 255, + 220, + 140, + 0, + 66, + 0, + 11, + 139, + 255, + 33, + 23, + 26, + 22, + 87, + 7, + 1, + 140, + 0, + 139, + 254, + 139, + 0, + 80, + 140, + 0, + 137, + 138, + 1, + 1, + 40, + 139, + 255, + 136, + 255, + 187, + 137, + 138, + 1, + 1, + 40, + 128, + 47, + 5, + 32, + 1, + 1, + 128, + 8, + 1, + 2, + 3, + 4, + 5, + 6, + 7, + 8, + 23, + 53, + 0, + 49, + 24, + 52, + 0, + 18, + 49, + 16, + 129, + 6, + 18, + 16, + 49, + 25, + 34, + 18, + 49, + 25, + 129, + 0, + 18, + 17, + 16, + 64, + 0, + 1, + 0, + 34, + 67, + 38, + 1, + 140, + 0, + 139, + 0, + 37, + 54, + 50, + 0, + 22, + 93, + 140, + 0, + 139, + 0, + 139, + 255, + 21, + 136, + 255, + 173, + 80, + 139, + 255, + 80, + 140, + 0, + 128, + 7, + 80, + 114, + 111, + 103, + 114, + 97, + 109, + 139, + 0, + 80, + 3, + 140, + 0, + 137, + 138, + 2, + 1, + 40, + 39, + 14, + 139, + 255, + 80, + 136, + 255, + 149, + 140, + 0, + 139, + 0, + 54, + 50, + 0, + 39, + 15, + 99, + 76, + 72, + 68, + 139, + 0, + 39, + 15, + 98, + 139, + 254, + 22, + 18, + 140, + 0, + 137, + 138, + 1, + 1, + 39, + 14, + 139, + 255, + 80, + 1, + 137, + 138, + 1, + 1, + 128, + 10, + 97, + 100, + 100, + 114, + 47, + 97, + 108, + 103, + 111, + 47, + 139, + 255, + 80, + 1, + 137, + 138, + 2, + 1, + 128, + 1, + 79, + 139, + 255, + 139, + 254, + 22, + 80, + 80, + 137, + 138, + 2, + 1, + 40, + 71, + 2, + 139, + 255, + 136, + 255, + 201, + 140, + 0, + 139, + 0, + 190, + 68, + 140, + 1, + 139, + 0, + 189, + 68, + 140, + 2, + 139, + 0, + 189, + 76, + 72, + 20, + 65, + 0, + 4, + 34, + 66, + 0, + 48, + 139, + 2, + 33, + 9, + 19, + 65, + 0, + 4, + 34, + 66, + 0, + 36, + 139, + 255, + 21, + 33, + 6, + 12, + 65, + 0, + 4, + 34, + 66, + 0, + 23, + 139, + 254, + 39, + 18, + 101, + 68, + 139, + 255, + 19, + 65, + 0, + 4, + 34, + 66, + 0, + 7, + 139, + 1, + 36, + 91, + 139, + 254, + 18, + 140, + 0, + 70, + 2, + 137, + 138, + 4, + 1, + 40, + 73, + 33, + 14, + 139, + 254, + 11, + 139, + 255, + 10, + 140, + 0, + 139, + 253, + 139, + 0, + 33, + 15, + 11, + 8, + 140, + 1, + 139, + 1, + 50, + 7, + 33, + 14, + 139, + 252, + 11, + 33, + 15, + 11, + 8, + 14, + 68, + 139, + 1, + 140, + 0, + 70, + 1, + 137, + 138, + 1, + 1, + 40, + 139, + 255, + 39, + 7, + 101, + 68, + 87, + 0, + 2, + 140, + 0, + 139, + 0, + 128, + 2, + 49, + 46, + 18, + 73, + 64, + 0, + 8, + 139, + 0, + 128, + 2, + 50, + 46, + 18, + 17, + 140, + 0, + 137, + 35, + 67, + 128, + 4, + 184, + 68, + 123, + 54, + 54, + 26, + 0, + 142, + 1, + 255, + 241, + 0, + 128, + 4, + 49, + 114, + 202, + 157, + 128, + 4, + 255, + 194, + 48, + 60, + 128, + 4, + 112, + 59, + 140, + 231, + 128, + 4, + 32, + 224, + 46, + 119, + 128, + 4, + 126, + 20, + 182, + 211, + 128, + 4, + 62, + 142, + 75, + 118, + 128, + 4, + 148, + 15, + 164, + 113, + 128, + 4, + 149, + 216, + 245, + 204, + 128, + 4, + 210, + 89, + 143, + 2, + 128, + 4, + 242, + 44, + 87, + 242, + 128, + 4, + 214, + 113, + 21, + 91, + 128, + 4, + 22, + 237, + 106, + 94, + 128, + 4, + 75, + 226, + 47, + 198, + 128, + 4, + 237, + 131, + 21, + 67, + 128, + 4, + 255, + 235, + 149, + 85, + 128, + 4, + 44, + 77, + 200, + 176, + 128, + 4, + 243, + 137, + 168, + 204, + 128, + 4, + 47, + 48, + 180, + 133, + 128, + 4, + 161, + 104, + 8, + 1, + 128, + 4, + 79, + 99, + 255, + 246, + 128, + 4, + 140, + 200, + 93, + 173, + 54, + 26, + 0, + 142, + 21, + 233, + 192, + 233, + 201, + 233, + 240, + 234, + 122, + 234, + 185, + 234, + 224, + 238, + 209, + 239, + 69, + 239, + 225, + 240, + 21, + 240, + 136, + 241, + 1, + 241, + 172, + 241, + 236, + 242, + 42, + 242, + 157, + 242, + 205, + 242, + 246, + 243, + 15, + 243, + 143, + 252, + 177, + 136, + 231, + 116, + 35, + 67, + 128, + 4, + 70, + 247, + 101, + 51, + 54, + 26, + 0, + 142, + 1, + 231, + 82, + 136, + 231, + 98, + 35, + 67, + 138, + 1, + 1, + 128, + 10, + 48, + 49, + 50, + 51, + 52, + 53, + 54, + 55, + 56, + 57, + 139, + 255, + 35, + 88, + 137, + 138, + 1, + 1, + 139, + 255, + 34, + 18, + 65, + 0, + 3, + 39, + 9, + 137, + 139, + 255, + 33, + 12, + 10, + 34, + 13, + 65, + 0, + 11, + 139, + 255, + 33, + 12, + 10, + 136, + 255, + 225, + 66, + 0, + 1, + 40, + 139, + 255, + 33, + 12, + 24, + 136, + 255, + 193, + 80, + 137, + 138, + 4, + 3, + 139, + 252, + 139, + 255, + 80, + 139, + 253, + 139, + 254, + 137, + 138, + 4, + 3, + 139, + 252, + 139, + 254, + 80, + 140, + 252, + 139, + 255, + 73, + 21, + 139, + 254, + 23, + 8, + 22, + 87, + 6, + 2, + 140, + 254, + 139, + 253, + 76, + 80, + 140, + 253, + 139, + 252, + 139, + 253, + 139, + 254, + 137, + 164, + 97, + 112, + 105, + 100, + 206, + 5, + 7, + 85, + 233, + 164, + 97, + 112, + 115, + 117, + 196, + 1, + 10, + 163, + 102, + 101, + 101, + 205, + 3, + 232, + 162, + 102, + 118, + 206, + 2, + 154, + 128, + 107, + 163, + 103, + 101, + 110, + 172, + 116, + 101, + 115, + 116, + 110, + 101, + 116, + 45, + 118, + 49, + 46, + 48, + 162, + 103, + 104, + 196, + 32, + 72, + 99, + 181, + 24, + 164, + 179, + 200, + 78, + 200, + 16, + 242, + 45, + 79, + 16, + 129, + 203, + 15, + 113, + 240, + 89, + 167, + 172, + 32, + 222, + 198, + 47, + 127, + 112, + 229, + 9, + 58, + 34, + 162, + 108, + 118, + 206, + 2, + 154, + 128, + 207, + 164, + 110, + 111, + 116, + 101, + 196, + 80, + 78, + 70, + 68, + 32, + 82, + 101, + 103, + 105, + 115, + 116, + 114, + 121, + 32, + 67, + 111, + 110, + 116, + 114, + 97, + 99, + 116, + 58, + 87, + 83, + 79, + 84, + 82, + 74, + 88, + 76, + 89, + 66, + 81, + 89, + 86, + 77, + 70, + 76, + 79, + 73, + 76, + 89, + 86, + 85, + 83, + 78, + 73, + 87, + 75, + 66, + 87, + 85, + 66, + 87, + 51, + 71, + 78, + 85, + 87, + 65, + 70, + 75, + 71, + 75, + 72, + 78, + 75, + 78, + 82, + 88, + 54, + 54, + 78, + 69, + 90, + 73, + 84, + 85, + 76, + 77, + 163, + 115, + 110, + 100, + 196, + 32, + 222, + 61, + 163, + 205, + 60, + 182, + 36, + 130, + 40, + 95, + 229, + 201, + 178, + 233, + 37, + 20, + 191, + 255, + 240, + 141, + 216, + 176, + 218, + 30, + 2, + 33, + 80, + 223, + 192, + 56, + 40, + 44, + 164, + 116, + 121, + 112, + 101, + 164, + 97, + 112, + 112, + 108 + ], + "rekeyedSenderAuthAddress": "BKDYDIDVSZCP75JVCB76P3WBJRY6HWAIFDSEOKYHJY5WMNJ2UWJ65MYETU", + "rekeyedSenderSignedBytes": [ + 131, + 164, + 115, + 103, + 110, + 114, + 196, + 32, + 10, + 135, + 129, + 160, + 117, + 150, + 68, + 255, + 245, + 53, + 16, + 127, + 231, + 238, + 193, + 76, + 113, + 227, + 216, + 8, + 40, + 228, + 71, + 43, + 7, + 78, + 59, + 102, + 53, + 58, + 165, + 147, + 163, + 115, + 105, + 103, + 196, + 64, + 240, + 110, + 158, + 21, + 80, + 135, + 67, + 53, + 228, + 160, + 113, + 219, + 166, + 165, + 149, + 59, + 103, + 53, + 253, + 60, + 147, + 105, + 198, + 194, + 42, + 38, + 39, + 171, + 80, + 144, + 208, + 155, + 90, + 241, + 177, + 22, + 117, + 6, + 218, + 66, + 132, + 154, + 135, + 184, + 94, + 92, + 49, + 172, + 196, + 246, + 47, + 233, + 144, + 234, + 229, + 248, + 138, + 74, + 81, + 191, + 106, + 169, + 199, + 2, + 163, + 116, + 120, + 110, + 141, + 164, + 97, + 112, + 97, + 97, + 145, + 196, + 16, + 116, + 101, + 97, + 108, + 115, + 99, + 114, + 105, + 112, + 116, + 45, + 100, + 117, + 109, + 109, + 121, + 164, + 97, + 112, + 97, + 110, + 4, + 164, + 97, + 112, + 97, + 112, + 197, + 26, + 142, + 10, + 32, + 24, + 0, + 1, + 8, + 6, + 32, + 2, + 5, + 4, + 3, + 16, + 128, + 32, + 160, + 141, + 6, + 10, + 30, + 237, + 2, + 128, + 163, + 5, + 144, + 78, + 27, + 60, + 128, + 212, + 141, + 190, + 202, + 16, + 212, + 222, + 1, + 208, + 134, + 3, + 128, + 1, + 255, + 1, + 38, + 20, + 0, + 4, + 21, + 31, + 124, + 117, + 9, + 105, + 46, + 111, + 119, + 110, + 101, + 114, + 46, + 97, + 7, + 99, + 117, + 114, + 114, + 101, + 110, + 116, + 8, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 13, + 118, + 46, + 99, + 97, + 65, + 108, + 103, + 111, + 46, + 48, + 46, + 97, + 115, + 11, + 99, + 111, + 110, + 116, + 114, + 97, + 99, + 116, + 58, + 65, + 58, + 5, + 105, + 46, + 118, + 101, + 114, + 3, + 10, + 129, + 1, + 1, + 48, + 11, + 99, + 111, + 110, + 116, + 114, + 97, + 99, + 116, + 58, + 67, + 58, + 12, + 117, + 46, + 99, + 97, + 118, + 46, + 97, + 108, + 103, + 111, + 46, + 97, + 16, + 105, + 46, + 101, + 120, + 112, + 105, + 114, + 97, + 116, + 105, + 111, + 110, + 84, + 105, + 109, + 101, + 1, + 0, + 5, + 110, + 97, + 109, + 101, + 47, + 7, + 105, + 46, + 97, + 112, + 112, + 105, + 100, + 6, + 105, + 46, + 97, + 112, + 112, + 115, + 15, + 105, + 46, + 115, + 101, + 103, + 109, + 101, + 110, + 116, + 76, + 111, + 99, + 107, + 101, + 100, + 6, + 105, + 46, + 110, + 97, + 109, + 101, + 7, + 46, + 46, + 46, + 97, + 108, + 103, + 111, + 128, + 8, + 0, + 0, + 0, + 0, + 7, + 1, + 163, + 144, + 23, + 53, + 204, + 128, + 8, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 50, + 23, + 53, + 203, + 128, + 32, + 140, + 192, + 44, + 36, + 6, + 26, + 39, + 87, + 142, + 136, + 93, + 94, + 83, + 159, + 168, + 35, + 71, + 123, + 171, + 202, + 213, + 25, + 64, + 50, + 84, + 80, + 201, + 214, + 220, + 200, + 26, + 116, + 53, + 202, + 128, + 32, + 254, + 115, + 101, + 249, + 131, + 173, + 194, + 235, + 65, + 228, + 41, + 1, + 8, + 109, + 106, + 175, + 251, + 215, + 53, + 172, + 16, + 84, + 237, + 88, + 59, + 48, + 34, + 94, + 151, + 72, + 133, + 83, + 53, + 201, + 128, + 8, + 0, + 0, + 0, + 0, + 5, + 7, + 85, + 184, + 23, + 53, + 200, + 49, + 24, + 20, + 37, + 11, + 49, + 25, + 8, + 141, + 12, + 23, + 240, + 0, + 0, + 0, + 0, + 0, + 0, + 24, + 162, + 0, + 0, + 23, + 226, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 136, + 0, + 2, + 35, + 67, + 138, + 0, + 0, + 49, + 0, + 54, + 50, + 0, + 114, + 7, + 72, + 18, + 68, + 137, + 138, + 0, + 0, + 40, + 49, + 25, + 33, + 7, + 18, + 65, + 0, + 4, + 136, + 255, + 227, + 137, + 49, + 32, + 50, + 3, + 18, + 68, + 54, + 26, + 0, + 128, + 3, + 103, + 97, + 115, + 18, + 65, + 0, + 1, + 137, + 49, + 27, + 33, + 8, + 18, + 73, + 65, + 0, + 25, + 54, + 26, + 0, + 128, + 18, + 105, + 115, + 95, + 118, + 97, + 108, + 105, + 100, + 95, + 110, + 102, + 100, + 95, + 97, + 112, + 112, + 105, + 100, + 18, + 16, + 65, + 0, + 21, + 54, + 26, + 2, + 23, + 54, + 26, + 1, + 136, + 9, + 251, + 65, + 0, + 4, + 35, + 66, + 0, + 1, + 34, + 22, + 176, + 137, + 49, + 27, + 33, + 7, + 18, + 73, + 65, + 0, + 22, + 54, + 26, + 0, + 128, + 15, + 118, + 101, + 114, + 105, + 102, + 121, + 95, + 110, + 102, + 100, + 95, + 97, + 100, + 100, + 114, + 18, + 16, + 65, + 0, + 14, + 54, + 26, + 3, + 54, + 26, + 2, + 23, + 54, + 26, + 1, + 136, + 6, + 230, + 137, + 49, + 27, + 33, + 7, + 18, + 73, + 65, + 0, + 22, + 54, + 26, + 0, + 128, + 15, + 117, + 110, + 108, + 105, + 110, + 107, + 95, + 110, + 102, + 100, + 95, + 97, + 100, + 100, + 114, + 18, + 16, + 65, + 0, + 14, + 54, + 26, + 3, + 54, + 26, + 2, + 23, + 54, + 26, + 1, + 136, + 7, + 42, + 137, + 49, + 27, + 33, + 7, + 18, + 73, + 65, + 0, + 27, + 54, + 26, + 0, + 128, + 20, + 115, + 101, + 116, + 95, + 97, + 100, + 100, + 114, + 95, + 112, + 114, + 105, + 109, + 97, + 114, + 121, + 95, + 110, + 102, + 100, + 18, + 16, + 65, + 0, + 14, + 54, + 26, + 3, + 54, + 26, + 2, + 23, + 54, + 26, + 1, + 136, + 8, + 56, + 137, + 49, + 27, + 33, + 5, + 18, + 73, + 65, + 0, + 21, + 54, + 26, + 0, + 128, + 14, + 103, + 101, + 116, + 95, + 110, + 97, + 109, + 101, + 95, + 97, + 112, + 112, + 105, + 100, + 18, + 16, + 65, + 0, + 4, + 136, + 13, + 183, + 137, + 49, + 27, + 33, + 8, + 18, + 73, + 65, + 0, + 25, + 54, + 26, + 0, + 128, + 18, + 103, + 101, + 116, + 95, + 97, + 100, + 100, + 114, + 101, + 115, + 115, + 95, + 97, + 112, + 112, + 105, + 100, + 115, + 18, + 16, + 65, + 0, + 4, + 136, + 13, + 154, + 137, + 50, + 4, + 33, + 5, + 15, + 65, + 0, + 134, + 49, + 22, + 35, + 9, + 140, + 0, + 139, + 0, + 56, + 16, + 35, + 18, + 73, + 65, + 0, + 8, + 139, + 0, + 56, + 32, + 50, + 3, + 18, + 16, + 73, + 65, + 0, + 8, + 139, + 0, + 56, + 9, + 50, + 3, + 18, + 16, + 73, + 65, + 0, + 20, + 139, + 0, + 56, + 8, + 50, + 0, + 15, + 73, + 64, + 0, + 8, + 139, + 0, + 56, + 1, + 50, + 0, + 13, + 17, + 16, + 73, + 65, + 0, + 6, + 139, + 0, + 136, + 10, + 195, + 16, + 65, + 0, + 61, + 49, + 27, + 33, + 5, + 18, + 73, + 65, + 0, + 18, + 54, + 26, + 0, + 128, + 11, + 114, + 101, + 109, + 111, + 118, + 101, + 95, + 97, + 100, + 100, + 114, + 18, + 16, + 73, + 65, + 0, + 10, + 49, + 22, + 35, + 9, + 56, + 7, + 49, + 0, + 18, + 16, + 65, + 0, + 16, + 54, + 26, + 1, + 23, + 33, + 9, + 39, + 16, + 49, + 0, + 136, + 15, + 123, + 66, + 0, + 1, + 0, + 49, + 22, + 136, + 10, + 125, + 65, + 0, + 113, + 49, + 27, + 33, + 8, + 18, + 73, + 65, + 0, + 19, + 54, + 26, + 0, + 128, + 12, + 109, + 105, + 103, + 114, + 97, + 116, + 101, + 95, + 110, + 97, + 109, + 101, + 18, + 16, + 65, + 0, + 4, + 136, + 12, + 255, + 137, + 49, + 27, + 33, + 8, + 18, + 73, + 65, + 0, + 22, + 54, + 26, + 0, + 128, + 15, + 109, + 105, + 103, + 114, + 97, + 116, + 101, + 95, + 97, + 100, + 100, + 114, + 101, + 115, + 115, + 18, + 16, + 65, + 0, + 10, + 54, + 26, + 2, + 54, + 26, + 1, + 136, + 13, + 7, + 137, + 49, + 27, + 33, + 5, + 18, + 73, + 65, + 0, + 17, + 54, + 26, + 0, + 128, + 10, + 115, + 119, + 101, + 101, + 112, + 95, + 100, + 117, + 115, + 116, + 18, + 16, + 65, + 0, + 4, + 136, + 15, + 50, + 137, + 0, + 0, + 137, + 136, + 0, + 2, + 35, + 67, + 138, + 0, + 0, + 137, + 41, + 54, + 26, + 2, + 73, + 21, + 33, + 4, + 18, + 68, + 54, + 26, + 1, + 87, + 2, + 0, + 136, + 0, + 4, + 80, + 176, + 35, + 67, + 138, + 2, + 1, + 139, + 254, + 139, + 255, + 136, + 15, + 65, + 139, + 255, + 136, + 16, + 239, + 137, + 41, + 136, + 0, + 4, + 80, + 176, + 35, + 67, + 138, + 0, + 1, + 40, + 50, + 7, + 129, + 244, + 3, + 136, + 18, + 190, + 140, + 0, + 139, + 0, + 22, + 139, + 0, + 136, + 9, + 14, + 22, + 80, + 128, + 8, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 20, + 80, + 52, + 201, + 80, + 128, + 8, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 28, + 80, + 128, + 8, + 0, + 0, + 0, + 0, + 0, + 152, + 150, + 128, + 80, + 128, + 60, + 48, + 48, + 48, + 48, + 48, + 48, + 48, + 48, + 48, + 48, + 48, + 48, + 48, + 48, + 48, + 48, + 48, + 48, + 48, + 48, + 48, + 48, + 48, + 48, + 48, + 48, + 48, + 46, + 48, + 48, + 48, + 48, + 48, + 48, + 48, + 48, + 48, + 48, + 48, + 48, + 48, + 48, + 48, + 48, + 48, + 48, + 48, + 48, + 48, + 48, + 48, + 48, + 48, + 48, + 48, + 46, + 97, + 108, + 103, + 111, + 136, + 0, + 20, + 22, + 80, + 140, + 0, + 137, + 41, + 54, + 26, + 1, + 87, + 2, + 0, + 136, + 0, + 5, + 22, + 80, + 176, + 35, + 67, + 138, + 1, + 1, + 40, + 73, + 33, + 13, + 34, + 71, + 3, + 33, + 8, + 35, + 136, + 18, + 132, + 33, + 11, + 9, + 140, + 0, + 129, + 89, + 139, + 255, + 21, + 8, + 33, + 5, + 136, + 18, + 199, + 140, + 1, + 139, + 0, + 139, + 1, + 8, + 136, + 9, + 59, + 8, + 140, + 0, + 70, + 1, + 137, + 41, + 54, + 26, + 1, + 73, + 21, + 33, + 4, + 18, + 68, + 136, + 0, + 4, + 80, + 176, + 35, + 67, + 138, + 1, + 1, + 39, + 5, + 21, + 33, + 4, + 8, + 35, + 136, + 18, + 153, + 22, + 139, + 255, + 136, + 8, + 196, + 22, + 80, + 137, + 41, + 54, + 26, + 3, + 73, + 21, + 35, + 18, + 68, + 34, + 83, + 54, + 26, + 2, + 73, + 21, + 33, + 4, + 18, + 68, + 54, + 26, + 1, + 87, + 2, + 0, + 49, + 22, + 35, + 9, + 73, + 56, + 16, + 35, + 18, + 68, + 136, + 0, + 5, + 22, + 80, + 176, + 35, + 67, + 138, + 4, + 1, + 40, + 71, + 17, + 139, + 255, + 56, + 7, + 50, + 10, + 18, + 68, + 33, + 4, + 73, + 18, + 68, + 139, + 253, + 50, + 3, + 19, + 68, + 177, + 37, + 178, + 16, + 34, + 178, + 1, + 39, + 8, + 73, + 178, + 30, + 178, + 31, + 33, + 6, + 178, + 25, + 179, + 139, + 254, + 136, + 13, + 238, + 140, + 0, + 34, + 140, + 1, + 50, + 3, + 140, + 2, + 139, + 0, + 53, + 255, + 52, + 255, + 34, + 83, + 65, + 0, + 81, + 177, + 37, + 178, + 16, + 34, + 178, + 1, + 39, + 8, + 73, + 178, + 30, + 178, + 31, + 33, + 6, + 178, + 25, + 179, + 139, + 0, + 139, + 254, + 136, + 15, + 48, + 136, + 14, + 254, + 140, + 1, + 139, + 1, + 34, + 19, + 68, + 39, + 17, + 139, + 1, + 136, + 15, + 51, + 39, + 9, + 18, + 65, + 0, + 21, + 139, + 1, + 128, + 10, + 105, + 46, + 115, + 101, + 108, + 108, + 101, + 114, + 46, + 97, + 101, + 68, + 140, + 2, + 66, + 0, + 11, + 139, + 255, + 56, + 0, + 139, + 1, + 42, + 101, + 68, + 18, + 68, + 49, + 0, + 139, + 0, + 139, + 254, + 136, + 15, + 51, + 53, + 255, + 52, + 255, + 87, + 0, + 8, + 23, + 140, + 3, + 139, + 3, + 34, + 13, + 68, + 139, + 254, + 136, + 254, + 202, + 140, + 4, + 34, + 140, + 5, + 139, + 252, + 65, + 0, + 39, + 49, + 0, + 136, + 254, + 252, + 140, + 6, + 139, + 6, + 87, + 0, + 8, + 23, + 140, + 5, + 139, + 4, + 139, + 6, + 87, + 0, + 8, + 23, + 139, + 6, + 87, + 8, + 8, + 23, + 8, + 8, + 140, + 4, + 49, + 0, + 139, + 253, + 18, + 68, + 33, + 14, + 139, + 255, + 56, + 8, + 139, + 4, + 9, + 11, + 139, + 3, + 10, + 33, + 13, + 15, + 68, + 43, + 190, + 68, + 140, + 7, + 39, + 6, + 43, + 190, + 68, + 80, + 140, + 8, + 39, + 10, + 139, + 7, + 80, + 190, + 68, + 140, + 9, + 139, + 8, + 189, + 68, + 140, + 10, + 50, + 12, + 129, + 200, + 1, + 12, + 65, + 0, + 19, + 177, + 37, + 178, + 16, + 34, + 178, + 1, + 39, + 8, + 73, + 178, + 30, + 178, + 31, + 33, + 6, + 178, + 25, + 179, + 129, + 20, + 50, + 7, + 139, + 255, + 56, + 8, + 139, + 4, + 9, + 139, + 3, + 136, + 18, + 166, + 140, + 11, + 177, + 37, + 178, + 16, + 34, + 178, + 25, + 139, + 8, + 34, + 33, + 10, + 186, + 178, + 64, + 139, + 8, + 33, + 10, + 139, + 10, + 33, + 10, + 9, + 186, + 178, + 64, + 139, + 9, + 178, + 31, + 34, + 178, + 52, + 33, + 13, + 178, + 53, + 33, + 8, + 178, + 56, + 128, + 4, + 13, + 202, + 82, + 193, + 178, + 26, + 139, + 254, + 73, + 21, + 22, + 87, + 6, + 2, + 76, + 80, + 178, + 26, + 52, + 201, + 178, + 26, + 139, + 253, + 178, + 26, + 139, + 255, + 56, + 8, + 139, + 4, + 9, + 22, + 178, + 26, + 139, + 11, + 22, + 178, + 26, + 52, + 202, + 178, + 26, + 52, + 203, + 22, + 178, + 26, + 50, + 3, + 178, + 26, + 39, + 4, + 178, + 26, + 139, + 1, + 22, + 178, + 26, + 139, + 2, + 178, + 26, + 34, + 178, + 1, + 179, + 180, + 61, + 140, + 12, + 180, + 61, + 114, + 8, + 72, + 140, + 13, + 136, + 7, + 34, + 140, + 14, + 177, + 35, + 178, + 16, + 139, + 255, + 56, + 8, + 139, + 4, + 9, + 139, + 14, + 8, + 139, + 5, + 8, + 178, + 8, + 139, + 13, + 178, + 7, + 34, + 178, + 1, + 179, + 177, + 37, + 178, + 16, + 128, + 4, + 6, + 223, + 46, + 91, + 178, + 26, + 139, + 12, + 178, + 24, + 139, + 254, + 136, + 16, + 131, + 73, + 21, + 22, + 87, + 6, + 2, + 76, + 80, + 178, + 26, + 128, + 62, + 0, + 60, + 116, + 101, + 109, + 112, + 108, + 97, + 116, + 101, + 45, + 105, + 112, + 102, + 115, + 58, + 47, + 47, + 123, + 105, + 112, + 102, + 115, + 99, + 105, + 100, + 58, + 49, + 58, + 100, + 97, + 103, + 45, + 112, + 98, + 58, + 114, + 101, + 115, + 101, + 114, + 118, + 101, + 58, + 115, + 104, + 97, + 50, + 45, + 50, + 53, + 54, + 125, + 47, + 110, + 102, + 100, + 46, + 106, + 115, + 111, + 110, + 178, + 26, + 34, + 178, + 1, + 179, + 180, + 62, + 23, + 140, + 15, + 34, + 139, + 12, + 139, + 15, + 139, + 254, + 136, + 9, + 182, + 139, + 1, + 34, + 19, + 65, + 0, + 110, + 139, + 1, + 136, + 17, + 181, + 65, + 0, + 65, + 139, + 1, + 39, + 7, + 101, + 68, + 128, + 4, + 50, + 46, + 49, + 50, + 18, + 68, + 177, + 37, + 178, + 16, + 34, + 178, + 25, + 139, + 1, + 178, + 24, + 128, + 20, + 117, + 112, + 100, + 97, + 116, + 101, + 95, + 115, + 101, + 103, + 109, + 101, + 110, + 116, + 95, + 99, + 111, + 117, + 110, + 116, + 178, + 26, + 139, + 254, + 178, + 26, + 139, + 12, + 22, + 178, + 26, + 34, + 178, + 1, + 179, + 66, + 0, + 37, + 177, + 37, + 178, + 16, + 128, + 4, + 13, + 38, + 197, + 145, + 178, + 26, + 139, + 1, + 178, + 24, + 139, + 254, + 73, + 21, + 22, + 87, + 6, + 2, + 76, + 80, + 178, + 26, + 139, + 12, + 22, + 178, + 26, + 34, + 178, + 1, + 179, + 136, + 252, + 35, + 140, + 16, + 177, + 37, + 178, + 16, + 128, + 4, + 254, + 57, + 209, + 27, + 178, + 26, + 139, + 12, + 178, + 24, + 139, + 16, + 87, + 8, + 8, + 23, + 22, + 178, + 26, + 34, + 178, + 1, + 179, + 180, + 59, + 35, + 9, + 197, + 58, + 87, + 4, + 0, + 140, + 17, + 128, + 4, + 53, + 197, + 148, + 24, + 40, + 40, + 128, + 2, + 0, + 226, + 139, + 12, + 22, + 136, + 18, + 71, + 139, + 254, + 73, + 21, + 22, + 87, + 6, + 2, + 76, + 80, + 136, + 18, + 71, + 139, + 3, + 22, + 136, + 18, + 52, + 139, + 255, + 56, + 8, + 139, + 4, + 9, + 22, + 136, + 18, + 41, + 139, + 4, + 22, + 136, + 18, + 35, + 52, + 201, + 136, + 18, + 30, + 139, + 255, + 56, + 0, + 136, + 18, + 23, + 139, + 253, + 136, + 18, + 18, + 139, + 11, + 22, + 136, + 18, + 12, + 139, + 17, + 87, + 0, + 8, + 23, + 22, + 136, + 18, + 2, + 139, + 17, + 87, + 8, + 32, + 136, + 17, + 250, + 139, + 17, + 87, + 40, + 8, + 23, + 22, + 136, + 17, + 240, + 139, + 17, + 87, + 48, + 32, + 136, + 17, + 232, + 139, + 17, + 87, + 80, + 8, + 23, + 22, + 136, + 17, + 222, + 72, + 80, + 80, + 176, + 139, + 252, + 65, + 0, + 71, + 177, + 37, + 178, + 16, + 128, + 4, + 120, + 244, + 39, + 17, + 178, + 26, + 139, + 12, + 178, + 24, + 40, + 40, + 128, + 2, + 0, + 4, + 39, + 11, + 73, + 21, + 22, + 87, + 6, + 2, + 76, + 80, + 136, + 17, + 191, + 49, + 0, + 73, + 21, + 22, + 87, + 6, + 2, + 76, + 80, + 136, + 17, + 178, + 72, + 80, + 128, + 2, + 0, + 2, + 76, + 80, + 178, + 26, + 34, + 178, + 1, + 179, + 49, + 0, + 139, + 12, + 139, + 254, + 136, + 0, + 31, + 139, + 12, + 140, + 0, + 70, + 17, + 137, + 54, + 26, + 3, + 73, + 21, + 33, + 4, + 18, + 68, + 54, + 26, + 2, + 23, + 54, + 26, + 1, + 87, + 2, + 0, + 136, + 0, + 2, + 35, + 67, + 138, + 3, + 0, + 40, + 73, + 139, + 253, + 136, + 15, + 127, + 140, + 0, + 139, + 254, + 42, + 101, + 68, + 140, + 1, + 139, + 254, + 139, + 255, + 136, + 15, + 145, + 68, + 139, + 254, + 114, + 8, + 72, + 139, + 253, + 18, + 65, + 0, + 9, + 49, + 0, + 139, + 1, + 18, + 68, + 66, + 0, + 6, + 49, + 0, + 139, + 253, + 18, + 68, + 139, + 253, + 39, + 11, + 139, + 254, + 136, + 4, + 212, + 68, + 139, + 254, + 139, + 0, + 136, + 5, + 56, + 20, + 65, + 0, + 8, + 139, + 254, + 139, + 0, + 136, + 5, + 131, + 68, + 39, + 5, + 39, + 11, + 139, + 254, + 136, + 5, + 253, + 137, + 54, + 26, + 3, + 73, + 21, + 33, + 4, + 18, + 68, + 54, + 26, + 2, + 23, + 54, + 26, + 1, + 87, + 2, + 0, + 136, + 0, + 2, + 35, + 67, + 138, + 3, + 0, + 40, + 73, + 139, + 254, + 42, + 101, + 68, + 140, + 0, + 139, + 254, + 139, + 255, + 136, + 15, + 36, + 68, + 39, + 12, + 139, + 254, + 136, + 11, + 78, + 136, + 6, + 183, + 20, + 65, + 0, + 16, + 49, + 0, + 139, + 0, + 18, + 73, + 64, + 0, + 6, + 49, + 0, + 139, + 253, + 18, + 17, + 68, + 139, + 253, + 39, + 5, + 139, + 254, + 136, + 4, + 99, + 68, + 139, + 253, + 136, + 14, + 212, + 140, + 1, + 139, + 254, + 139, + 1, + 136, + 8, + 68, + 68, + 139, + 1, + 189, + 76, + 72, + 20, + 65, + 0, + 36, + 177, + 35, + 178, + 16, + 139, + 1, + 21, + 36, + 8, + 35, + 136, + 13, + 178, + 178, + 8, + 49, + 0, + 178, + 7, + 128, + 9, + 98, + 111, + 120, + 82, + 101, + 102, + 117, + 110, + 100, + 178, + 5, + 34, + 178, + 1, + 179, + 49, + 0, + 139, + 253, + 39, + 5, + 139, + 254, + 136, + 5, + 218, + 137, + 54, + 26, + 2, + 23, + 54, + 26, + 1, + 87, + 2, + 0, + 136, + 0, + 2, + 35, + 67, + 138, + 2, + 0, + 40, + 139, + 254, + 139, + 255, + 136, + 1, + 201, + 68, + 139, + 254, + 139, + 254, + 42, + 101, + 68, + 136, + 14, + 128, + 140, + 0, + 139, + 0, + 189, + 76, + 72, + 20, + 68, + 139, + 0, + 139, + 255, + 191, + 137, + 54, + 26, + 4, + 73, + 21, + 33, + 4, + 18, + 68, + 54, + 26, + 3, + 73, + 21, + 33, + 4, + 18, + 68, + 54, + 26, + 2, + 23, + 54, + 26, + 1, + 87, + 2, + 0, + 136, + 0, + 2, + 35, + 67, + 138, + 4, + 0, + 40, + 73, + 139, + 253, + 139, + 252, + 18, + 65, + 0, + 1, + 137, + 139, + 254, + 139, + 255, + 136, + 14, + 73, + 68, + 139, + 254, + 39, + 7, + 101, + 68, + 128, + 3, + 51, + 46, + 51, + 18, + 65, + 0, + 9, + 49, + 22, + 136, + 3, + 103, + 68, + 66, + 0, + 9, + 49, + 0, + 139, + 254, + 114, + 8, + 72, + 18, + 68, + 139, + 254, + 139, + 253, + 136, + 14, + 18, + 140, + 0, + 139, + 254, + 139, + 252, + 136, + 14, + 9, + 140, + 1, + 139, + 0, + 188, + 139, + 1, + 139, + 255, + 191, + 137, + 54, + 26, + 3, + 73, + 21, + 33, + 4, + 18, + 68, + 54, + 26, + 2, + 23, + 54, + 26, + 1, + 87, + 2, + 0, + 136, + 0, + 2, + 35, + 67, + 138, + 3, + 0, + 40, + 139, + 254, + 139, + 255, + 136, + 13, + 233, + 68, + 139, + 254, + 42, + 101, + 68, + 140, + 0, + 139, + 254, + 114, + 8, + 72, + 139, + 253, + 18, + 65, + 0, + 9, + 49, + 0, + 139, + 0, + 18, + 68, + 66, + 0, + 6, + 49, + 0, + 139, + 253, + 18, + 68, + 139, + 254, + 54, + 26, + 3, + 136, + 13, + 157, + 136, + 6, + 148, + 128, + 4, + 81, + 114, + 207, + 1, + 40, + 40, + 128, + 2, + 0, + 42, + 139, + 254, + 22, + 136, + 15, + 110, + 139, + 255, + 73, + 21, + 22, + 87, + 6, + 2, + 76, + 80, + 136, + 15, + 110, + 139, + 253, + 136, + 15, + 92, + 72, + 80, + 80, + 176, + 137, + 41, + 54, + 26, + 1, + 87, + 2, + 0, + 136, + 0, + 12, + 73, + 21, + 22, + 87, + 6, + 2, + 76, + 80, + 80, + 176, + 35, + 67, + 138, + 1, + 1, + 40, + 71, + 5, + 139, + 255, + 136, + 0, + 217, + 140, + 0, + 139, + 0, + 42, + 101, + 68, + 140, + 1, + 139, + 0, + 39, + 18, + 101, + 68, + 139, + 255, + 18, + 68, + 49, + 0, + 139, + 1, + 18, + 68, + 139, + 0, + 39, + 12, + 101, + 76, + 72, + 68, + 43, + 190, + 68, + 140, + 2, + 139, + 0, + 39, + 7, + 101, + 68, + 139, + 2, + 19, + 68, + 39, + 6, + 43, + 190, + 68, + 80, + 140, + 3, + 39, + 10, + 139, + 2, + 80, + 190, + 68, + 140, + 4, + 139, + 3, + 189, + 68, + 140, + 5, + 177, + 37, + 178, + 16, + 128, + 4, + 23, + 71, + 64, + 91, + 178, + 26, + 33, + 7, + 178, + 25, + 139, + 0, + 178, + 24, + 139, + 2, + 73, + 21, + 22, + 87, + 6, + 2, + 76, + 80, + 178, + 26, + 139, + 3, + 34, + 33, + 10, + 186, + 178, + 64, + 139, + 3, + 33, + 10, + 139, + 5, + 33, + 10, + 9, + 186, + 178, + 64, + 139, + 4, + 178, + 31, + 34, + 178, + 1, + 179, + 139, + 2, + 140, + 0, + 70, + 5, + 137, + 41, + 54, + 26, + 2, + 23, + 54, + 26, + 1, + 87, + 2, + 0, + 136, + 0, + 10, + 39, + 13, + 34, + 79, + 2, + 84, + 80, + 176, + 35, + 67, + 138, + 2, + 1, + 40, + 139, + 255, + 136, + 12, + 155, + 140, + 0, + 139, + 0, + 189, + 76, + 72, + 20, + 65, + 0, + 10, + 139, + 254, + 139, + 255, + 136, + 12, + 100, + 66, + 0, + 7, + 139, + 254, + 139, + 255, + 136, + 12, + 171, + 140, + 0, + 137, + 41, + 54, + 26, + 1, + 87, + 2, + 0, + 136, + 0, + 5, + 22, + 80, + 176, + 35, + 67, + 138, + 1, + 1, + 40, + 73, + 139, + 255, + 136, + 12, + 99, + 140, + 0, + 139, + 0, + 189, + 76, + 72, + 20, + 65, + 0, + 4, + 34, + 66, + 0, + 17, + 139, + 0, + 190, + 68, + 140, + 1, + 139, + 1, + 21, + 33, + 9, + 18, + 68, + 139, + 1, + 36, + 91, + 140, + 0, + 70, + 1, + 137, + 41, + 54, + 26, + 1, + 73, + 21, + 33, + 4, + 18, + 68, + 136, + 0, + 14, + 73, + 21, + 36, + 10, + 22, + 87, + 6, + 2, + 76, + 80, + 80, + 176, + 35, + 67, + 138, + 1, + 1, + 40, + 71, + 4, + 40, + 140, + 0, + 139, + 255, + 136, + 12, + 31, + 140, + 1, + 139, + 1, + 189, + 76, + 72, + 20, + 65, + 0, + 5, + 139, + 0, + 66, + 0, + 53, + 139, + 1, + 190, + 68, + 140, + 2, + 34, + 140, + 3, + 139, + 3, + 139, + 2, + 21, + 12, + 65, + 0, + 33, + 139, + 2, + 139, + 3, + 36, + 88, + 23, + 140, + 4, + 139, + 4, + 34, + 19, + 65, + 0, + 8, + 139, + 0, + 139, + 4, + 22, + 80, + 140, + 0, + 139, + 3, + 36, + 8, + 140, + 3, + 66, + 255, + 214, + 139, + 0, + 140, + 0, + 70, + 4, + 137, + 54, + 26, + 3, + 87, + 2, + 0, + 54, + 26, + 2, + 23, + 54, + 26, + 1, + 87, + 2, + 0, + 136, + 0, + 2, + 35, + 67, + 138, + 3, + 0, + 49, + 22, + 136, + 1, + 13, + 68, + 39, + 6, + 139, + 255, + 80, + 139, + 254, + 185, + 72, + 39, + 10, + 139, + 255, + 80, + 139, + 253, + 191, + 137, + 54, + 26, + 3, + 87, + 2, + 0, + 54, + 26, + 2, + 23, + 54, + 26, + 1, + 87, + 2, + 0, + 136, + 0, + 2, + 35, + 67, + 138, + 3, + 0, + 49, + 22, + 136, + 0, + 221, + 68, + 39, + 6, + 139, + 255, + 80, + 139, + 254, + 139, + 253, + 187, + 137, + 54, + 26, + 1, + 87, + 2, + 0, + 136, + 0, + 2, + 35, + 67, + 138, + 1, + 0, + 49, + 22, + 136, + 0, + 190, + 68, + 43, + 139, + 255, + 191, + 137, + 41, + 54, + 26, + 1, + 23, + 136, + 0, + 5, + 22, + 80, + 176, + 35, + 67, + 138, + 1, + 1, + 40, + 71, + 2, + 52, + 204, + 128, + 2, + 116, + 115, + 101, + 68, + 140, + 0, + 52, + 204, + 128, + 8, + 100, + 101, + 99, + 105, + 109, + 97, + 108, + 115, + 101, + 68, + 140, + 1, + 52, + 204, + 128, + 5, + 112, + 114, + 105, + 99, + 101, + 101, + 68, + 140, + 2, + 50, + 7, + 139, + 0, + 9, + 33, + 15, + 13, + 65, + 0, + 34, + 33, + 5, + 140, + 1, + 129, + 33, + 140, + 2, + 128, + 23, + 111, + 114, + 97, + 99, + 108, + 101, + 32, + 62, + 50, + 52, + 104, + 114, + 32, + 117, + 115, + 105, + 110, + 103, + 32, + 46, + 51, + 51, + 99, + 176, + 139, + 255, + 33, + 16, + 11, + 139, + 1, + 136, + 9, + 136, + 11, + 139, + 2, + 10, + 33, + 16, + 10, + 33, + 16, + 11, + 140, + 0, + 70, + 2, + 137, + 41, + 54, + 26, + 1, + 73, + 21, + 33, + 4, + 18, + 68, + 136, + 0, + 5, + 22, + 80, + 176, + 35, + 67, + 138, + 1, + 1, + 40, + 139, + 255, + 136, + 10, + 200, + 140, + 0, + 139, + 0, + 189, + 76, + 72, + 20, + 65, + 0, + 12, + 139, + 0, + 21, + 36, + 8, + 35, + 136, + 9, + 178, + 66, + 0, + 3, + 129, + 128, + 25, + 140, + 0, + 137, + 138, + 1, + 1, + 139, + 255, + 56, + 0, + 52, + 200, + 112, + 0, + 72, + 35, + 18, + 73, + 65, + 0, + 8, + 139, + 255, + 56, + 9, + 50, + 3, + 18, + 16, + 73, + 65, + 0, + 8, + 139, + 255, + 56, + 32, + 50, + 3, + 18, + 16, + 137, + 138, + 0, + 1, + 34, + 71, + 3, + 35, + 34, + 73, + 136, + 9, + 35, + 137, + 138, + 3, + 1, + 139, + 255, + 136, + 11, + 27, + 65, + 0, + 49, + 177, + 37, + 178, + 16, + 139, + 255, + 178, + 24, + 128, + 19, + 105, + 115, + 95, + 97, + 100, + 100, + 114, + 101, + 115, + 115, + 95, + 105, + 110, + 95, + 102, + 105, + 101, + 108, + 100, + 178, + 26, + 139, + 254, + 178, + 26, + 139, + 253, + 178, + 26, + 34, + 178, + 1, + 179, + 180, + 62, + 23, + 35, + 18, + 137, + 177, + 37, + 178, + 16, + 128, + 4, + 212, + 67, + 149, + 42, + 178, + 26, + 139, + 255, + 178, + 24, + 139, + 254, + 73, + 21, + 22, + 87, + 6, + 2, + 76, + 80, + 178, + 26, + 139, + 253, + 178, + 26, + 34, + 178, + 1, + 179, + 180, + 59, + 35, + 9, + 197, + 58, + 87, + 4, + 0, + 34, + 83, + 137, + 138, + 2, + 1, + 40, + 71, + 3, + 139, + 254, + 34, + 19, + 68, + 139, + 255, + 189, + 76, + 72, + 20, + 65, + 0, + 4, + 34, + 66, + 0, + 57, + 139, + 255, + 190, + 68, + 140, + 0, + 139, + 0, + 140, + 1, + 139, + 0, + 21, + 36, + 10, + 140, + 2, + 34, + 140, + 3, + 139, + 3, + 139, + 2, + 12, + 65, + 0, + 28, + 139, + 1, + 139, + 3, + 36, + 11, + 36, + 88, + 23, + 139, + 254, + 18, + 65, + 0, + 4, + 35, + 66, + 0, + 10, + 139, + 3, + 35, + 8, + 140, + 3, + 66, + 255, + 220, + 34, + 140, + 0, + 70, + 3, + 137, + 138, + 2, + 1, + 40, + 71, + 3, + 139, + 255, + 189, + 76, + 72, + 20, + 65, + 0, + 10, + 139, + 255, + 139, + 254, + 22, + 191, + 35, + 66, + 0, + 102, + 139, + 255, + 190, + 68, + 140, + 0, + 139, + 0, + 21, + 36, + 10, + 140, + 1, + 34, + 140, + 2, + 139, + 2, + 139, + 1, + 12, + 65, + 0, + 51, + 139, + 0, + 139, + 2, + 36, + 11, + 91, + 140, + 3, + 139, + 3, + 34, + 18, + 65, + 0, + 14, + 139, + 255, + 139, + 2, + 36, + 11, + 139, + 254, + 22, + 187, + 35, + 66, + 0, + 48, + 139, + 3, + 139, + 254, + 18, + 65, + 0, + 4, + 35, + 66, + 0, + 36, + 139, + 2, + 35, + 8, + 140, + 2, + 66, + 255, + 197, + 139, + 0, + 21, + 129, + 240, + 7, + 12, + 65, + 0, + 16, + 139, + 255, + 188, + 139, + 255, + 139, + 0, + 139, + 254, + 22, + 80, + 191, + 35, + 66, + 0, + 1, + 34, + 140, + 0, + 70, + 3, + 137, + 138, + 3, + 1, + 139, + 255, + 136, + 9, + 213, + 65, + 0, + 54, + 177, + 37, + 178, + 16, + 139, + 255, + 178, + 24, + 128, + 24, + 114, + 101, + 103, + 95, + 97, + 100, + 100, + 95, + 118, + 101, + 114, + 105, + 102, + 105, + 101, + 100, + 95, + 97, + 100, + 100, + 114, + 101, + 115, + 115, + 178, + 26, + 139, + 254, + 178, + 26, + 139, + 253, + 178, + 26, + 34, + 178, + 1, + 179, + 180, + 62, + 23, + 35, + 18, + 137, + 177, + 37, + 178, + 16, + 128, + 4, + 133, + 204, + 237, + 87, + 178, + 26, + 139, + 255, + 178, + 24, + 139, + 254, + 73, + 21, + 22, + 87, + 6, + 2, + 76, + 80, + 178, + 26, + 139, + 253, + 73, + 21, + 22, + 87, + 6, + 2, + 76, + 80, + 178, + 26, + 34, + 178, + 1, + 179, + 180, + 59, + 35, + 9, + 197, + 58, + 87, + 4, + 0, + 34, + 83, + 137, + 138, + 4, + 1, + 139, + 255, + 136, + 9, + 92, + 65, + 0, + 57, + 177, + 37, + 178, + 16, + 139, + 255, + 178, + 24, + 128, + 27, + 114, + 101, + 103, + 95, + 114, + 101, + 109, + 111, + 118, + 101, + 95, + 118, + 101, + 114, + 105, + 102, + 105, + 101, + 100, + 95, + 97, + 100, + 100, + 114, + 101, + 115, + 115, + 178, + 26, + 139, + 254, + 178, + 26, + 139, + 253, + 178, + 26, + 34, + 178, + 1, + 179, + 180, + 62, + 23, + 35, + 18, + 137, + 177, + 37, + 178, + 16, + 128, + 4, + 177, + 137, + 10, + 117, + 178, + 26, + 139, + 255, + 178, + 24, + 139, + 254, + 73, + 21, + 22, + 87, + 6, + 2, + 76, + 80, + 178, + 26, + 139, + 253, + 178, + 26, + 139, + 252, + 178, + 26, + 34, + 178, + 1, + 179, + 180, + 59, + 35, + 9, + 197, + 58, + 87, + 4, + 0, + 34, + 83, + 137, + 138, + 1, + 1, + 139, + 255, + 34, + 18, + 65, + 0, + 2, + 34, + 137, + 50, + 7, + 139, + 255, + 13, + 137, + 138, + 0, + 0, + 54, + 26, + 1, + 136, + 251, + 174, + 22, + 176, + 137, + 138, + 0, + 0, + 40, + 54, + 26, + 1, + 136, + 8, + 24, + 140, + 0, + 139, + 0, + 189, + 76, + 72, + 20, + 65, + 0, + 3, + 40, + 176, + 137, + 139, + 0, + 190, + 68, + 176, + 137, + 138, + 0, + 0, + 40, + 54, + 26, + 2, + 23, + 54, + 26, + 1, + 136, + 7, + 199, + 68, + 54, + 26, + 2, + 23, + 128, + 7, + 105, + 46, + 97, + 115, + 97, + 105, + 100, + 101, + 68, + 140, + 0, + 139, + 0, + 40, + 19, + 68, + 35, + 54, + 26, + 2, + 23, + 139, + 0, + 23, + 54, + 26, + 1, + 136, + 0, + 114, + 137, + 138, + 2, + 0, + 40, + 71, + 3, + 139, + 255, + 136, + 7, + 197, + 189, + 76, + 72, + 65, + 0, + 1, + 137, + 128, + 8, + 97, + 100, + 100, + 114, + 101, + 115, + 115, + 47, + 139, + 254, + 80, + 136, + 7, + 32, + 140, + 0, + 40, + 140, + 1, + 34, + 140, + 2, + 139, + 2, + 33, + 9, + 12, + 65, + 0, + 62, + 39, + 16, + 139, + 2, + 136, + 9, + 80, + 80, + 140, + 3, + 139, + 0, + 54, + 50, + 0, + 139, + 3, + 99, + 76, + 72, + 65, + 0, + 13, + 139, + 1, + 139, + 0, + 139, + 3, + 98, + 80, + 140, + 1, + 66, + 0, + 17, + 139, + 1, + 21, + 34, + 13, + 65, + 0, + 8, + 139, + 255, + 136, + 7, + 109, + 139, + 1, + 191, + 137, + 139, + 2, + 35, + 8, + 140, + 2, + 66, + 255, + 186, + 137, + 138, + 4, + 0, + 40, + 139, + 252, + 20, + 65, + 0, + 7, + 139, + 255, + 136, + 0, + 33, + 20, + 68, + 139, + 255, + 136, + 7, + 63, + 140, + 0, + 139, + 254, + 68, + 139, + 253, + 68, + 139, + 0, + 189, + 76, + 72, + 20, + 68, + 139, + 0, + 139, + 254, + 22, + 139, + 253, + 22, + 80, + 191, + 137, + 138, + 1, + 1, + 40, + 39, + 14, + 139, + 255, + 80, + 136, + 6, + 149, + 140, + 0, + 139, + 0, + 54, + 50, + 0, + 97, + 20, + 65, + 0, + 4, + 34, + 66, + 0, + 10, + 139, + 0, + 54, + 50, + 0, + 39, + 15, + 99, + 76, + 72, + 140, + 0, + 137, + 138, + 2, + 1, + 40, + 71, + 4, + 139, + 255, + 190, + 68, + 140, + 0, + 139, + 254, + 34, + 19, + 68, + 139, + 0, + 21, + 33, + 9, + 15, + 68, + 139, + 0, + 34, + 91, + 139, + 254, + 18, + 65, + 0, + 4, + 35, + 66, + 0, + 84, + 139, + 0, + 21, + 36, + 10, + 140, + 1, + 34, + 140, + 2, + 34, + 140, + 3, + 139, + 3, + 139, + 1, + 12, + 65, + 0, + 29, + 139, + 0, + 139, + 3, + 36, + 11, + 91, + 139, + 254, + 18, + 65, + 0, + 7, + 139, + 3, + 140, + 2, + 66, + 0, + 9, + 139, + 3, + 35, + 8, + 140, + 3, + 66, + 255, + 219, + 139, + 2, + 34, + 19, + 68, + 139, + 0, + 34, + 91, + 140, + 4, + 139, + 0, + 34, + 139, + 254, + 22, + 93, + 140, + 0, + 139, + 255, + 139, + 0, + 139, + 2, + 36, + 11, + 139, + 4, + 22, + 93, + 191, + 35, + 140, + 0, + 70, + 4, + 137, + 138, + 2, + 1, + 40, + 71, + 2, + 139, + 255, + 190, + 68, + 140, + 0, + 139, + 0, + 21, + 36, + 10, + 140, + 1, + 34, + 140, + 2, + 139, + 2, + 139, + 1, + 12, + 65, + 0, + 70, + 139, + 0, + 139, + 2, + 36, + 11, + 91, + 139, + 254, + 18, + 65, + 0, + 48, + 139, + 2, + 139, + 1, + 35, + 9, + 18, + 65, + 0, + 25, + 139, + 255, + 188, + 139, + 2, + 34, + 13, + 65, + 0, + 11, + 139, + 255, + 139, + 0, + 34, + 139, + 2, + 36, + 11, + 88, + 191, + 35, + 66, + 0, + 23, + 139, + 255, + 139, + 2, + 36, + 11, + 39, + 4, + 187, + 35, + 66, + 0, + 10, + 139, + 2, + 35, + 8, + 140, + 2, + 66, + 255, + 178, + 34, + 140, + 0, + 70, + 2, + 137, + 138, + 3, + 1, + 139, + 254, + 34, + 139, + 253, + 82, + 139, + 255, + 22, + 80, + 139, + 254, + 139, + 253, + 36, + 8, + 139, + 254, + 21, + 82, + 80, + 137, + 138, + 3, + 1, + 40, + 71, + 2, + 139, + 255, + 139, + 254, + 98, + 140, + 0, + 139, + 0, + 21, + 36, + 10, + 140, + 1, + 34, + 140, + 2, + 139, + 2, + 139, + 1, + 12, + 65, + 0, + 41, + 139, + 0, + 139, + 2, + 36, + 11, + 91, + 139, + 253, + 18, + 65, + 0, + 19, + 139, + 255, + 139, + 254, + 139, + 2, + 36, + 11, + 139, + 0, + 34, + 136, + 255, + 173, + 102, + 35, + 66, + 0, + 10, + 139, + 2, + 35, + 8, + 140, + 2, + 66, + 255, + 207, + 34, + 140, + 0, + 70, + 2, + 137, + 138, + 4, + 1, + 40, + 34, + 140, + 0, + 139, + 0, + 139, + 253, + 12, + 65, + 0, + 31, + 139, + 252, + 139, + 254, + 139, + 0, + 136, + 7, + 87, + 80, + 139, + 255, + 136, + 255, + 148, + 65, + 0, + 4, + 35, + 66, + 0, + 10, + 139, + 0, + 35, + 8, + 140, + 0, + 66, + 255, + 217, + 34, + 140, + 0, + 137, + 138, + 0, + 0, + 40, + 73, + 50, + 10, + 115, + 0, + 72, + 140, + 0, + 50, + 10, + 115, + 1, + 72, + 140, + 1, + 139, + 0, + 139, + 1, + 13, + 65, + 0, + 33, + 177, + 35, + 178, + 16, + 139, + 0, + 139, + 1, + 9, + 178, + 8, + 54, + 26, + 1, + 178, + 7, + 128, + 9, + 115, + 119, + 101, + 101, + 112, + 68, + 117, + 115, + 116, + 178, + 5, + 34, + 178, + 1, + 179, + 137, + 138, + 1, + 1, + 40, + 71, + 6, + 139, + 255, + 21, + 140, + 0, + 139, + 0, + 37, + 15, + 68, + 139, + 255, + 139, + 0, + 33, + 6, + 9, + 33, + 6, + 88, + 128, + 5, + 46, + 97, + 108, + 103, + 111, + 18, + 68, + 39, + 13, + 34, + 73, + 84, + 39, + 4, + 80, + 39, + 4, + 80, + 140, + 1, + 34, + 140, + 2, + 34, + 140, + 3, + 34, + 140, + 4, + 34, + 140, + 5, + 139, + 5, + 139, + 0, + 33, + 7, + 9, + 12, + 65, + 0, + 153, + 139, + 255, + 139, + 5, + 85, + 140, + 6, + 139, + 6, + 129, + 46, + 18, + 65, + 0, + 81, + 139, + 2, + 35, + 8, + 140, + 2, + 139, + 2, + 35, + 18, + 65, + 0, + 25, + 139, + 5, + 140, + 4, + 139, + 3, + 35, + 15, + 73, + 65, + 0, + 6, + 139, + 3, + 33, + 17, + 14, + 16, + 68, + 34, + 140, + 3, + 66, + 0, + 40, + 139, + 2, + 33, + 5, + 18, + 65, + 0, + 31, + 139, + 3, + 35, + 15, + 73, + 65, + 0, + 6, + 139, + 3, + 33, + 17, + 14, + 16, + 73, + 65, + 0, + 9, + 139, + 5, + 139, + 0, + 33, + 6, + 9, + 18, + 16, + 68, + 66, + 0, + 1, + 0, + 66, + 0, + 48, + 139, + 6, + 129, + 97, + 15, + 73, + 65, + 0, + 6, + 139, + 6, + 129, + 122, + 14, + 16, + 73, + 64, + 0, + 16, + 139, + 6, + 129, + 48, + 15, + 73, + 65, + 0, + 6, + 139, + 6, + 129, + 57, + 14, + 16, + 17, + 65, + 0, + 9, + 139, + 3, + 35, + 8, + 140, + 3, + 66, + 0, + 1, + 0, + 139, + 5, + 35, + 8, + 140, + 5, + 66, + 255, + 92, + 139, + 2, + 35, + 18, + 65, + 0, + 39, + 139, + 1, + 53, + 255, + 52, + 255, + 34, + 73, + 84, + 140, + 1, + 139, + 1, + 53, + 255, + 52, + 255, + 35, + 139, + 4, + 22, + 93, + 140, + 1, + 139, + 1, + 53, + 255, + 52, + 255, + 39, + 4, + 92, + 9, + 140, + 1, + 66, + 0, + 44, + 139, + 1, + 53, + 255, + 52, + 255, + 34, + 35, + 84, + 140, + 1, + 139, + 1, + 53, + 255, + 52, + 255, + 35, + 139, + 3, + 22, + 93, + 140, + 1, + 139, + 1, + 53, + 255, + 52, + 255, + 129, + 9, + 139, + 0, + 33, + 6, + 9, + 139, + 3, + 9, + 22, + 93, + 140, + 1, + 139, + 1, + 140, + 0, + 70, + 6, + 137, + 138, + 1, + 1, + 40, + 73, + 139, + 255, + 136, + 3, + 242, + 140, + 0, + 139, + 0, + 189, + 76, + 72, + 20, + 65, + 0, + 4, + 34, + 66, + 0, + 17, + 139, + 0, + 190, + 68, + 140, + 1, + 139, + 1, + 21, + 33, + 9, + 18, + 68, + 139, + 1, + 36, + 91, + 140, + 0, + 70, + 1, + 137, + 138, + 2, + 1, + 139, + 255, + 139, + 254, + 53, + 255, + 52, + 255, + 87, + 9, + 8, + 23, + 139, + 255, + 21, + 82, + 137, + 138, + 2, + 1, + 139, + 255, + 139, + 254, + 101, + 76, + 72, + 20, + 65, + 0, + 2, + 40, + 137, + 139, + 255, + 139, + 254, + 101, + 68, + 137, + 138, + 2, + 1, + 139, + 255, + 139, + 254, + 101, + 76, + 72, + 20, + 65, + 0, + 2, + 34, + 137, + 139, + 255, + 139, + 254, + 101, + 68, + 23, + 137, + 138, + 3, + 1, + 40, + 71, + 19, + 136, + 239, + 17, + 140, + 0, + 139, + 254, + 53, + 255, + 52, + 255, + 34, + 83, + 65, + 0, + 110, + 139, + 254, + 139, + 255, + 136, + 255, + 160, + 136, + 255, + 110, + 140, + 2, + 139, + 2, + 34, + 19, + 68, + 34, + 140, + 3, + 39, + 17, + 139, + 2, + 136, + 255, + 160, + 39, + 9, + 18, + 65, + 0, + 49, + 128, + 17, + 105, + 46, + 115, + 101, + 103, + 109, + 101, + 110, + 116, + 80, + 114, + 105, + 99, + 101, + 85, + 115, + 100, + 139, + 2, + 136, + 255, + 153, + 140, + 3, + 139, + 3, + 139, + 0, + 87, + 0, + 8, + 23, + 12, + 65, + 0, + 8, + 139, + 0, + 87, + 0, + 8, + 23, + 140, + 3, + 66, + 0, + 8, + 139, + 0, + 87, + 0, + 8, + 23, + 140, + 3, + 139, + 3, + 139, + 0, + 87, + 0, + 8, + 23, + 15, + 68, + 139, + 3, + 136, + 247, + 191, + 140, + 1, + 66, + 0, + 112, + 139, + 254, + 53, + 255, + 52, + 255, + 87, + 1, + 8, + 23, + 140, + 4, + 34, + 140, + 5, + 139, + 4, + 33, + 6, + 15, + 65, + 0, + 8, + 129, + 216, + 4, + 140, + 5, + 66, + 0, + 65, + 139, + 4, + 33, + 7, + 18, + 65, + 0, + 8, + 129, + 176, + 9, + 140, + 5, + 66, + 0, + 49, + 139, + 4, + 33, + 8, + 18, + 65, + 0, + 8, + 129, + 184, + 23, + 140, + 5, + 66, + 0, + 33, + 139, + 4, + 33, + 5, + 18, + 65, + 0, + 8, + 129, + 168, + 70, + 140, + 5, + 66, + 0, + 17, + 139, + 4, + 35, + 18, + 65, + 0, + 9, + 129, + 140, + 246, + 1, + 140, + 5, + 66, + 0, + 1, + 0, + 50, + 7, + 139, + 5, + 136, + 0, + 249, + 140, + 6, + 139, + 6, + 136, + 247, + 76, + 140, + 1, + 139, + 255, + 136, + 246, + 36, + 140, + 7, + 34, + 140, + 8, + 34, + 140, + 9, + 139, + 7, + 34, + 19, + 65, + 0, + 151, + 139, + 253, + 139, + 7, + 42, + 101, + 68, + 18, + 140, + 10, + 39, + 12, + 139, + 7, + 136, + 254, + 207, + 140, + 11, + 139, + 11, + 136, + 250, + 52, + 73, + 65, + 0, + 4, + 139, + 10, + 20, + 16, + 65, + 0, + 116, + 35, + 140, + 8, + 35, + 140, + 9, + 139, + 0, + 87, + 64, + 8, + 23, + 136, + 247, + 4, + 140, + 12, + 139, + 1, + 140, + 13, + 50, + 7, + 140, + 14, + 139, + 11, + 139, + 0, + 87, + 56, + 8, + 23, + 33, + 18, + 11, + 33, + 18, + 11, + 129, + 24, + 11, + 8, + 140, + 15, + 139, + 14, + 139, + 11, + 13, + 68, + 139, + 14, + 139, + 15, + 15, + 65, + 0, + 7, + 139, + 13, + 140, + 1, + 66, + 0, + 50, + 139, + 14, + 139, + 11, + 9, + 140, + 16, + 139, + 15, + 139, + 11, + 9, + 140, + 17, + 139, + 12, + 139, + 13, + 9, + 140, + 18, + 139, + 18, + 139, + 16, + 11, + 139, + 17, + 10, + 140, + 19, + 139, + 12, + 139, + 19, + 9, + 140, + 1, + 139, + 1, + 139, + 13, + 12, + 65, + 0, + 4, + 139, + 13, + 140, + 1, + 139, + 1, + 129, + 192, + 132, + 61, + 15, + 68, + 139, + 1, + 22, + 139, + 7, + 34, + 18, + 65, + 0, + 8, + 139, + 255, + 136, + 237, + 245, + 66, + 0, + 1, + 34, + 22, + 80, + 39, + 13, + 34, + 139, + 7, + 34, + 19, + 84, + 35, + 139, + 9, + 84, + 33, + 5, + 139, + 8, + 84, + 80, + 140, + 0, + 70, + 19, + 137, + 41, + 54, + 26, + 2, + 23, + 54, + 26, + 1, + 23, + 136, + 0, + 5, + 22, + 80, + 176, + 35, + 67, + 138, + 2, + 1, + 40, + 71, + 3, + 139, + 254, + 33, + 19, + 12, + 65, + 0, + 5, + 139, + 255, + 66, + 0, + 46, + 139, + 254, + 33, + 19, + 9, + 140, + 0, + 139, + 0, + 129, + 128, + 231, + 132, + 15, + 10, + 140, + 1, + 139, + 1, + 34, + 18, + 65, + 0, + 5, + 139, + 255, + 66, + 0, + 17, + 129, + 102, + 139, + 1, + 149, + 140, + 2, + 140, + 3, + 139, + 255, + 139, + 2, + 11, + 129, + 100, + 10, + 140, + 0, + 70, + 3, + 137, + 138, + 1, + 1, + 40, + 73, + 33, + 12, + 139, + 255, + 149, + 140, + 0, + 140, + 1, + 139, + 0, + 140, + 0, + 70, + 1, + 137, + 138, + 7, + 1, + 40, + 33, + 11, + 140, + 0, + 139, + 0, + 139, + 255, + 33, + 11, + 11, + 8, + 140, + 0, + 139, + 0, + 139, + 254, + 33, + 11, + 11, + 8, + 140, + 0, + 139, + 0, + 139, + 253, + 33, + 11, + 11, + 8, + 140, + 0, + 139, + 0, + 139, + 252, + 33, + 20, + 11, + 8, + 140, + 0, + 139, + 0, + 139, + 250, + 33, + 20, + 11, + 8, + 140, + 0, + 139, + 0, + 139, + 251, + 33, + 21, + 11, + 8, + 140, + 0, + 139, + 0, + 139, + 249, + 33, + 21, + 11, + 8, + 140, + 0, + 139, + 0, + 140, + 0, + 137, + 138, + 2, + 1, + 129, + 196, + 19, + 139, + 255, + 11, + 139, + 254, + 129, + 144, + 3, + 11, + 8, + 137, + 138, + 1, + 1, + 139, + 255, + 21, + 33, + 4, + 14, + 65, + 0, + 3, + 139, + 255, + 137, + 139, + 255, + 34, + 33, + 4, + 39, + 19, + 21, + 9, + 82, + 39, + 19, + 80, + 137, + 138, + 2, + 1, + 40, + 139, + 254, + 140, + 0, + 139, + 255, + 33, + 22, + 15, + 65, + 0, + 25, + 139, + 255, + 33, + 23, + 26, + 33, + 22, + 25, + 22, + 87, + 7, + 1, + 139, + 255, + 129, + 7, + 145, + 136, + 255, + 220, + 140, + 0, + 66, + 0, + 11, + 139, + 255, + 33, + 23, + 26, + 22, + 87, + 7, + 1, + 140, + 0, + 139, + 254, + 139, + 0, + 80, + 140, + 0, + 137, + 138, + 1, + 1, + 40, + 139, + 255, + 136, + 255, + 187, + 137, + 138, + 1, + 1, + 40, + 128, + 47, + 5, + 32, + 1, + 1, + 128, + 8, + 1, + 2, + 3, + 4, + 5, + 6, + 7, + 8, + 23, + 53, + 0, + 49, + 24, + 52, + 0, + 18, + 49, + 16, + 129, + 6, + 18, + 16, + 49, + 25, + 34, + 18, + 49, + 25, + 129, + 0, + 18, + 17, + 16, + 64, + 0, + 1, + 0, + 34, + 67, + 38, + 1, + 140, + 0, + 139, + 0, + 37, + 54, + 50, + 0, + 22, + 93, + 140, + 0, + 139, + 0, + 139, + 255, + 21, + 136, + 255, + 173, + 80, + 139, + 255, + 80, + 140, + 0, + 128, + 7, + 80, + 114, + 111, + 103, + 114, + 97, + 109, + 139, + 0, + 80, + 3, + 140, + 0, + 137, + 138, + 2, + 1, + 40, + 39, + 14, + 139, + 255, + 80, + 136, + 255, + 149, + 140, + 0, + 139, + 0, + 54, + 50, + 0, + 39, + 15, + 99, + 76, + 72, + 68, + 139, + 0, + 39, + 15, + 98, + 139, + 254, + 22, + 18, + 140, + 0, + 137, + 138, + 1, + 1, + 39, + 14, + 139, + 255, + 80, + 1, + 137, + 138, + 1, + 1, + 128, + 10, + 97, + 100, + 100, + 114, + 47, + 97, + 108, + 103, + 111, + 47, + 139, + 255, + 80, + 1, + 137, + 138, + 2, + 1, + 128, + 1, + 79, + 139, + 255, + 139, + 254, + 22, + 80, + 80, + 137, + 138, + 2, + 1, + 40, + 71, + 2, + 139, + 255, + 136, + 255, + 201, + 140, + 0, + 139, + 0, + 190, + 68, + 140, + 1, + 139, + 0, + 189, + 68, + 140, + 2, + 139, + 0, + 189, + 76, + 72, + 20, + 65, + 0, + 4, + 34, + 66, + 0, + 48, + 139, + 2, + 33, + 9, + 19, + 65, + 0, + 4, + 34, + 66, + 0, + 36, + 139, + 255, + 21, + 33, + 6, + 12, + 65, + 0, + 4, + 34, + 66, + 0, + 23, + 139, + 254, + 39, + 18, + 101, + 68, + 139, + 255, + 19, + 65, + 0, + 4, + 34, + 66, + 0, + 7, + 139, + 1, + 36, + 91, + 139, + 254, + 18, + 140, + 0, + 70, + 2, + 137, + 138, + 4, + 1, + 40, + 73, + 33, + 14, + 139, + 254, + 11, + 139, + 255, + 10, + 140, + 0, + 139, + 253, + 139, + 0, + 33, + 15, + 11, + 8, + 140, + 1, + 139, + 1, + 50, + 7, + 33, + 14, + 139, + 252, + 11, + 33, + 15, + 11, + 8, + 14, + 68, + 139, + 1, + 140, + 0, + 70, + 1, + 137, + 138, + 1, + 1, + 40, + 139, + 255, + 39, + 7, + 101, + 68, + 87, + 0, + 2, + 140, + 0, + 139, + 0, + 128, + 2, + 49, + 46, + 18, + 73, + 64, + 0, + 8, + 139, + 0, + 128, + 2, + 50, + 46, + 18, + 17, + 140, + 0, + 137, + 35, + 67, + 128, + 4, + 184, + 68, + 123, + 54, + 54, + 26, + 0, + 142, + 1, + 255, + 241, + 0, + 128, + 4, + 49, + 114, + 202, + 157, + 128, + 4, + 255, + 194, + 48, + 60, + 128, + 4, + 112, + 59, + 140, + 231, + 128, + 4, + 32, + 224, + 46, + 119, + 128, + 4, + 126, + 20, + 182, + 211, + 128, + 4, + 62, + 142, + 75, + 118, + 128, + 4, + 148, + 15, + 164, + 113, + 128, + 4, + 149, + 216, + 245, + 204, + 128, + 4, + 210, + 89, + 143, + 2, + 128, + 4, + 242, + 44, + 87, + 242, + 128, + 4, + 214, + 113, + 21, + 91, + 128, + 4, + 22, + 237, + 106, + 94, + 128, + 4, + 75, + 226, + 47, + 198, + 128, + 4, + 237, + 131, + 21, + 67, + 128, + 4, + 255, + 235, + 149, + 85, + 128, + 4, + 44, + 77, + 200, + 176, + 128, + 4, + 243, + 137, + 168, + 204, + 128, + 4, + 47, + 48, + 180, + 133, + 128, + 4, + 161, + 104, + 8, + 1, + 128, + 4, + 79, + 99, + 255, + 246, + 128, + 4, + 140, + 200, + 93, + 173, + 54, + 26, + 0, + 142, + 21, + 233, + 192, + 233, + 201, + 233, + 240, + 234, + 122, + 234, + 185, + 234, + 224, + 238, + 209, + 239, + 69, + 239, + 225, + 240, + 21, + 240, + 136, + 241, + 1, + 241, + 172, + 241, + 236, + 242, + 42, + 242, + 157, + 242, + 205, + 242, + 246, + 243, + 15, + 243, + 143, + 252, + 177, + 136, + 231, + 116, + 35, + 67, + 128, + 4, + 70, + 247, + 101, + 51, + 54, + 26, + 0, + 142, + 1, + 231, + 82, + 136, + 231, + 98, + 35, + 67, + 138, + 1, + 1, + 128, + 10, + 48, + 49, + 50, + 51, + 52, + 53, + 54, + 55, + 56, + 57, + 139, + 255, + 35, + 88, + 137, + 138, + 1, + 1, + 139, + 255, + 34, + 18, + 65, + 0, + 3, + 39, + 9, + 137, + 139, + 255, + 33, + 12, + 10, + 34, + 13, + 65, + 0, + 11, + 139, + 255, + 33, + 12, + 10, + 136, + 255, + 225, + 66, + 0, + 1, + 40, + 139, + 255, + 33, + 12, + 24, + 136, + 255, + 193, + 80, + 137, + 138, + 4, + 3, + 139, + 252, + 139, + 255, + 80, + 139, + 253, + 139, + 254, + 137, + 138, + 4, + 3, + 139, + 252, + 139, + 254, + 80, + 140, + 252, + 139, + 255, + 73, + 21, + 139, + 254, + 23, + 8, + 22, + 87, + 6, + 2, + 140, + 254, + 139, + 253, + 76, + 80, + 140, + 253, + 139, + 252, + 139, + 253, + 139, + 254, + 137, + 164, + 97, + 112, + 105, + 100, + 206, + 5, + 7, + 85, + 233, + 164, + 97, + 112, + 115, + 117, + 196, + 1, + 10, + 163, + 102, + 101, + 101, + 205, + 3, + 232, + 162, + 102, + 118, + 206, + 2, + 154, + 128, + 107, + 163, + 103, + 101, + 110, + 172, + 116, + 101, + 115, + 116, + 110, + 101, + 116, + 45, + 118, + 49, + 46, + 48, + 162, + 103, + 104, + 196, + 32, + 72, + 99, + 181, + 24, + 164, + 179, + 200, + 78, + 200, + 16, + 242, + 45, + 79, + 16, + 129, + 203, + 15, + 113, + 240, + 89, + 167, + 172, + 32, + 222, + 198, + 47, + 127, + 112, + 229, + 9, + 58, + 34, + 162, + 108, + 118, + 206, + 2, + 154, + 128, + 207, + 164, + 110, + 111, + 116, + 101, + 196, + 80, + 78, + 70, + 68, + 32, + 82, + 101, + 103, + 105, + 115, + 116, + 114, + 121, + 32, + 67, + 111, + 110, + 116, + 114, + 97, + 99, + 116, + 58, + 87, + 83, + 79, + 84, + 82, + 74, + 88, + 76, + 89, + 66, + 81, + 89, + 86, + 77, + 70, + 76, + 79, + 73, + 76, + 89, + 86, + 85, + 83, + 78, + 73, + 87, + 75, + 66, + 87, + 85, + 66, + 87, + 51, + 71, + 78, + 85, + 87, + 65, + 70, + 75, + 71, + 75, + 72, + 78, + 75, + 78, + 82, + 88, + 54, + 54, + 78, + 69, + 90, + 73, + 84, + 85, + 76, + 77, + 163, + 115, + 110, + 100, + 196, + 32, + 222, + 61, + 163, + 205, + 60, + 182, + 36, + 130, + 40, + 95, + 229, + 201, + 178, + 233, + 37, + 20, + 191, + 255, + 240, + 141, + 216, + 176, + 218, + 30, + 2, + 33, + 80, + 223, + 192, + 56, + 40, + 44, + 164, + 116, + 121, + 112, + 101, + 164, + 97, + 112, + 112, + 108 + ], + "signedBytes": [ + 130, + 163, + 115, + 105, + 103, + 196, + 64, + 240, + 110, + 158, + 21, + 80, + 135, + 67, + 53, + 228, + 160, + 113, + 219, + 166, + 165, + 149, + 59, + 103, + 53, + 253, + 60, + 147, + 105, + 198, + 194, + 42, + 38, + 39, + 171, + 80, + 144, + 208, + 155, + 90, + 241, + 177, + 22, + 117, + 6, + 218, + 66, + 132, + 154, + 135, + 184, + 94, + 92, + 49, + 172, + 196, + 246, + 47, + 233, + 144, + 234, + 229, + 248, + 138, + 74, + 81, + 191, + 106, + 169, + 199, + 2, + 163, + 116, + 120, + 110, + 141, + 164, + 97, + 112, + 97, + 97, + 145, + 196, + 16, + 116, + 101, + 97, + 108, + 115, + 99, + 114, + 105, + 112, + 116, + 45, + 100, + 117, + 109, + 109, + 121, + 164, + 97, + 112, + 97, + 110, + 4, + 164, + 97, + 112, + 97, + 112, + 197, + 26, + 142, + 10, + 32, + 24, + 0, + 1, + 8, + 6, + 32, + 2, + 5, + 4, + 3, + 16, + 128, + 32, + 160, + 141, + 6, + 10, + 30, + 237, + 2, + 128, + 163, + 5, + 144, + 78, + 27, + 60, + 128, + 212, + 141, + 190, + 202, + 16, + 212, + 222, + 1, + 208, + 134, + 3, + 128, + 1, + 255, + 1, + 38, + 20, + 0, + 4, + 21, + 31, + 124, + 117, + 9, + 105, + 46, + 111, + 119, + 110, + 101, + 114, + 46, + 97, + 7, + 99, + 117, + 114, + 114, + 101, + 110, + 116, + 8, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 13, + 118, + 46, + 99, + 97, + 65, + 108, + 103, + 111, + 46, + 48, + 46, + 97, + 115, + 11, + 99, + 111, + 110, + 116, + 114, + 97, + 99, + 116, + 58, + 65, + 58, + 5, + 105, + 46, + 118, + 101, + 114, + 3, + 10, + 129, + 1, + 1, + 48, + 11, + 99, + 111, + 110, + 116, + 114, + 97, + 99, + 116, + 58, + 67, + 58, + 12, + 117, + 46, + 99, + 97, + 118, + 46, + 97, + 108, + 103, + 111, + 46, + 97, + 16, + 105, + 46, + 101, + 120, + 112, + 105, + 114, + 97, + 116, + 105, + 111, + 110, + 84, + 105, + 109, + 101, + 1, + 0, + 5, + 110, + 97, + 109, + 101, + 47, + 7, + 105, + 46, + 97, + 112, + 112, + 105, + 100, + 6, + 105, + 46, + 97, + 112, + 112, + 115, + 15, + 105, + 46, + 115, + 101, + 103, + 109, + 101, + 110, + 116, + 76, + 111, + 99, + 107, + 101, + 100, + 6, + 105, + 46, + 110, + 97, + 109, + 101, + 7, + 46, + 46, + 46, + 97, + 108, + 103, + 111, + 128, + 8, + 0, + 0, + 0, + 0, + 7, + 1, + 163, + 144, + 23, + 53, + 204, + 128, + 8, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 50, + 23, + 53, + 203, + 128, + 32, + 140, + 192, + 44, + 36, + 6, + 26, + 39, + 87, + 142, + 136, + 93, + 94, + 83, + 159, + 168, + 35, + 71, + 123, + 171, + 202, + 213, + 25, + 64, + 50, + 84, + 80, + 201, + 214, + 220, + 200, + 26, + 116, + 53, + 202, + 128, + 32, + 254, + 115, + 101, + 249, + 131, + 173, + 194, + 235, + 65, + 228, + 41, + 1, + 8, + 109, + 106, + 175, + 251, + 215, + 53, + 172, + 16, + 84, + 237, + 88, + 59, + 48, + 34, + 94, + 151, + 72, + 133, + 83, + 53, + 201, + 128, + 8, + 0, + 0, + 0, + 0, + 5, + 7, + 85, + 184, + 23, + 53, + 200, + 49, + 24, + 20, + 37, + 11, + 49, + 25, + 8, + 141, + 12, + 23, + 240, + 0, + 0, + 0, + 0, + 0, + 0, + 24, + 162, + 0, + 0, + 23, + 226, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 136, + 0, + 2, + 35, + 67, + 138, + 0, + 0, + 49, + 0, + 54, + 50, + 0, + 114, + 7, + 72, + 18, + 68, + 137, + 138, + 0, + 0, + 40, + 49, + 25, + 33, + 7, + 18, + 65, + 0, + 4, + 136, + 255, + 227, + 137, + 49, + 32, + 50, + 3, + 18, + 68, + 54, + 26, + 0, + 128, + 3, + 103, + 97, + 115, + 18, + 65, + 0, + 1, + 137, + 49, + 27, + 33, + 8, + 18, + 73, + 65, + 0, + 25, + 54, + 26, + 0, + 128, + 18, + 105, + 115, + 95, + 118, + 97, + 108, + 105, + 100, + 95, + 110, + 102, + 100, + 95, + 97, + 112, + 112, + 105, + 100, + 18, + 16, + 65, + 0, + 21, + 54, + 26, + 2, + 23, + 54, + 26, + 1, + 136, + 9, + 251, + 65, + 0, + 4, + 35, + 66, + 0, + 1, + 34, + 22, + 176, + 137, + 49, + 27, + 33, + 7, + 18, + 73, + 65, + 0, + 22, + 54, + 26, + 0, + 128, + 15, + 118, + 101, + 114, + 105, + 102, + 121, + 95, + 110, + 102, + 100, + 95, + 97, + 100, + 100, + 114, + 18, + 16, + 65, + 0, + 14, + 54, + 26, + 3, + 54, + 26, + 2, + 23, + 54, + 26, + 1, + 136, + 6, + 230, + 137, + 49, + 27, + 33, + 7, + 18, + 73, + 65, + 0, + 22, + 54, + 26, + 0, + 128, + 15, + 117, + 110, + 108, + 105, + 110, + 107, + 95, + 110, + 102, + 100, + 95, + 97, + 100, + 100, + 114, + 18, + 16, + 65, + 0, + 14, + 54, + 26, + 3, + 54, + 26, + 2, + 23, + 54, + 26, + 1, + 136, + 7, + 42, + 137, + 49, + 27, + 33, + 7, + 18, + 73, + 65, + 0, + 27, + 54, + 26, + 0, + 128, + 20, + 115, + 101, + 116, + 95, + 97, + 100, + 100, + 114, + 95, + 112, + 114, + 105, + 109, + 97, + 114, + 121, + 95, + 110, + 102, + 100, + 18, + 16, + 65, + 0, + 14, + 54, + 26, + 3, + 54, + 26, + 2, + 23, + 54, + 26, + 1, + 136, + 8, + 56, + 137, + 49, + 27, + 33, + 5, + 18, + 73, + 65, + 0, + 21, + 54, + 26, + 0, + 128, + 14, + 103, + 101, + 116, + 95, + 110, + 97, + 109, + 101, + 95, + 97, + 112, + 112, + 105, + 100, + 18, + 16, + 65, + 0, + 4, + 136, + 13, + 183, + 137, + 49, + 27, + 33, + 8, + 18, + 73, + 65, + 0, + 25, + 54, + 26, + 0, + 128, + 18, + 103, + 101, + 116, + 95, + 97, + 100, + 100, + 114, + 101, + 115, + 115, + 95, + 97, + 112, + 112, + 105, + 100, + 115, + 18, + 16, + 65, + 0, + 4, + 136, + 13, + 154, + 137, + 50, + 4, + 33, + 5, + 15, + 65, + 0, + 134, + 49, + 22, + 35, + 9, + 140, + 0, + 139, + 0, + 56, + 16, + 35, + 18, + 73, + 65, + 0, + 8, + 139, + 0, + 56, + 32, + 50, + 3, + 18, + 16, + 73, + 65, + 0, + 8, + 139, + 0, + 56, + 9, + 50, + 3, + 18, + 16, + 73, + 65, + 0, + 20, + 139, + 0, + 56, + 8, + 50, + 0, + 15, + 73, + 64, + 0, + 8, + 139, + 0, + 56, + 1, + 50, + 0, + 13, + 17, + 16, + 73, + 65, + 0, + 6, + 139, + 0, + 136, + 10, + 195, + 16, + 65, + 0, + 61, + 49, + 27, + 33, + 5, + 18, + 73, + 65, + 0, + 18, + 54, + 26, + 0, + 128, + 11, + 114, + 101, + 109, + 111, + 118, + 101, + 95, + 97, + 100, + 100, + 114, + 18, + 16, + 73, + 65, + 0, + 10, + 49, + 22, + 35, + 9, + 56, + 7, + 49, + 0, + 18, + 16, + 65, + 0, + 16, + 54, + 26, + 1, + 23, + 33, + 9, + 39, + 16, + 49, + 0, + 136, + 15, + 123, + 66, + 0, + 1, + 0, + 49, + 22, + 136, + 10, + 125, + 65, + 0, + 113, + 49, + 27, + 33, + 8, + 18, + 73, + 65, + 0, + 19, + 54, + 26, + 0, + 128, + 12, + 109, + 105, + 103, + 114, + 97, + 116, + 101, + 95, + 110, + 97, + 109, + 101, + 18, + 16, + 65, + 0, + 4, + 136, + 12, + 255, + 137, + 49, + 27, + 33, + 8, + 18, + 73, + 65, + 0, + 22, + 54, + 26, + 0, + 128, + 15, + 109, + 105, + 103, + 114, + 97, + 116, + 101, + 95, + 97, + 100, + 100, + 114, + 101, + 115, + 115, + 18, + 16, + 65, + 0, + 10, + 54, + 26, + 2, + 54, + 26, + 1, + 136, + 13, + 7, + 137, + 49, + 27, + 33, + 5, + 18, + 73, + 65, + 0, + 17, + 54, + 26, + 0, + 128, + 10, + 115, + 119, + 101, + 101, + 112, + 95, + 100, + 117, + 115, + 116, + 18, + 16, + 65, + 0, + 4, + 136, + 15, + 50, + 137, + 0, + 0, + 137, + 136, + 0, + 2, + 35, + 67, + 138, + 0, + 0, + 137, + 41, + 54, + 26, + 2, + 73, + 21, + 33, + 4, + 18, + 68, + 54, + 26, + 1, + 87, + 2, + 0, + 136, + 0, + 4, + 80, + 176, + 35, + 67, + 138, + 2, + 1, + 139, + 254, + 139, + 255, + 136, + 15, + 65, + 139, + 255, + 136, + 16, + 239, + 137, + 41, + 136, + 0, + 4, + 80, + 176, + 35, + 67, + 138, + 0, + 1, + 40, + 50, + 7, + 129, + 244, + 3, + 136, + 18, + 190, + 140, + 0, + 139, + 0, + 22, + 139, + 0, + 136, + 9, + 14, + 22, + 80, + 128, + 8, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 20, + 80, + 52, + 201, + 80, + 128, + 8, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 28, + 80, + 128, + 8, + 0, + 0, + 0, + 0, + 0, + 152, + 150, + 128, + 80, + 128, + 60, + 48, + 48, + 48, + 48, + 48, + 48, + 48, + 48, + 48, + 48, + 48, + 48, + 48, + 48, + 48, + 48, + 48, + 48, + 48, + 48, + 48, + 48, + 48, + 48, + 48, + 48, + 48, + 46, + 48, + 48, + 48, + 48, + 48, + 48, + 48, + 48, + 48, + 48, + 48, + 48, + 48, + 48, + 48, + 48, + 48, + 48, + 48, + 48, + 48, + 48, + 48, + 48, + 48, + 48, + 48, + 46, + 97, + 108, + 103, + 111, + 136, + 0, + 20, + 22, + 80, + 140, + 0, + 137, + 41, + 54, + 26, + 1, + 87, + 2, + 0, + 136, + 0, + 5, + 22, + 80, + 176, + 35, + 67, + 138, + 1, + 1, + 40, + 73, + 33, + 13, + 34, + 71, + 3, + 33, + 8, + 35, + 136, + 18, + 132, + 33, + 11, + 9, + 140, + 0, + 129, + 89, + 139, + 255, + 21, + 8, + 33, + 5, + 136, + 18, + 199, + 140, + 1, + 139, + 0, + 139, + 1, + 8, + 136, + 9, + 59, + 8, + 140, + 0, + 70, + 1, + 137, + 41, + 54, + 26, + 1, + 73, + 21, + 33, + 4, + 18, + 68, + 136, + 0, + 4, + 80, + 176, + 35, + 67, + 138, + 1, + 1, + 39, + 5, + 21, + 33, + 4, + 8, + 35, + 136, + 18, + 153, + 22, + 139, + 255, + 136, + 8, + 196, + 22, + 80, + 137, + 41, + 54, + 26, + 3, + 73, + 21, + 35, + 18, + 68, + 34, + 83, + 54, + 26, + 2, + 73, + 21, + 33, + 4, + 18, + 68, + 54, + 26, + 1, + 87, + 2, + 0, + 49, + 22, + 35, + 9, + 73, + 56, + 16, + 35, + 18, + 68, + 136, + 0, + 5, + 22, + 80, + 176, + 35, + 67, + 138, + 4, + 1, + 40, + 71, + 17, + 139, + 255, + 56, + 7, + 50, + 10, + 18, + 68, + 33, + 4, + 73, + 18, + 68, + 139, + 253, + 50, + 3, + 19, + 68, + 177, + 37, + 178, + 16, + 34, + 178, + 1, + 39, + 8, + 73, + 178, + 30, + 178, + 31, + 33, + 6, + 178, + 25, + 179, + 139, + 254, + 136, + 13, + 238, + 140, + 0, + 34, + 140, + 1, + 50, + 3, + 140, + 2, + 139, + 0, + 53, + 255, + 52, + 255, + 34, + 83, + 65, + 0, + 81, + 177, + 37, + 178, + 16, + 34, + 178, + 1, + 39, + 8, + 73, + 178, + 30, + 178, + 31, + 33, + 6, + 178, + 25, + 179, + 139, + 0, + 139, + 254, + 136, + 15, + 48, + 136, + 14, + 254, + 140, + 1, + 139, + 1, + 34, + 19, + 68, + 39, + 17, + 139, + 1, + 136, + 15, + 51, + 39, + 9, + 18, + 65, + 0, + 21, + 139, + 1, + 128, + 10, + 105, + 46, + 115, + 101, + 108, + 108, + 101, + 114, + 46, + 97, + 101, + 68, + 140, + 2, + 66, + 0, + 11, + 139, + 255, + 56, + 0, + 139, + 1, + 42, + 101, + 68, + 18, + 68, + 49, + 0, + 139, + 0, + 139, + 254, + 136, + 15, + 51, + 53, + 255, + 52, + 255, + 87, + 0, + 8, + 23, + 140, + 3, + 139, + 3, + 34, + 13, + 68, + 139, + 254, + 136, + 254, + 202, + 140, + 4, + 34, + 140, + 5, + 139, + 252, + 65, + 0, + 39, + 49, + 0, + 136, + 254, + 252, + 140, + 6, + 139, + 6, + 87, + 0, + 8, + 23, + 140, + 5, + 139, + 4, + 139, + 6, + 87, + 0, + 8, + 23, + 139, + 6, + 87, + 8, + 8, + 23, + 8, + 8, + 140, + 4, + 49, + 0, + 139, + 253, + 18, + 68, + 33, + 14, + 139, + 255, + 56, + 8, + 139, + 4, + 9, + 11, + 139, + 3, + 10, + 33, + 13, + 15, + 68, + 43, + 190, + 68, + 140, + 7, + 39, + 6, + 43, + 190, + 68, + 80, + 140, + 8, + 39, + 10, + 139, + 7, + 80, + 190, + 68, + 140, + 9, + 139, + 8, + 189, + 68, + 140, + 10, + 50, + 12, + 129, + 200, + 1, + 12, + 65, + 0, + 19, + 177, + 37, + 178, + 16, + 34, + 178, + 1, + 39, + 8, + 73, + 178, + 30, + 178, + 31, + 33, + 6, + 178, + 25, + 179, + 129, + 20, + 50, + 7, + 139, + 255, + 56, + 8, + 139, + 4, + 9, + 139, + 3, + 136, + 18, + 166, + 140, + 11, + 177, + 37, + 178, + 16, + 34, + 178, + 25, + 139, + 8, + 34, + 33, + 10, + 186, + 178, + 64, + 139, + 8, + 33, + 10, + 139, + 10, + 33, + 10, + 9, + 186, + 178, + 64, + 139, + 9, + 178, + 31, + 34, + 178, + 52, + 33, + 13, + 178, + 53, + 33, + 8, + 178, + 56, + 128, + 4, + 13, + 202, + 82, + 193, + 178, + 26, + 139, + 254, + 73, + 21, + 22, + 87, + 6, + 2, + 76, + 80, + 178, + 26, + 52, + 201, + 178, + 26, + 139, + 253, + 178, + 26, + 139, + 255, + 56, + 8, + 139, + 4, + 9, + 22, + 178, + 26, + 139, + 11, + 22, + 178, + 26, + 52, + 202, + 178, + 26, + 52, + 203, + 22, + 178, + 26, + 50, + 3, + 178, + 26, + 39, + 4, + 178, + 26, + 139, + 1, + 22, + 178, + 26, + 139, + 2, + 178, + 26, + 34, + 178, + 1, + 179, + 180, + 61, + 140, + 12, + 180, + 61, + 114, + 8, + 72, + 140, + 13, + 136, + 7, + 34, + 140, + 14, + 177, + 35, + 178, + 16, + 139, + 255, + 56, + 8, + 139, + 4, + 9, + 139, + 14, + 8, + 139, + 5, + 8, + 178, + 8, + 139, + 13, + 178, + 7, + 34, + 178, + 1, + 179, + 177, + 37, + 178, + 16, + 128, + 4, + 6, + 223, + 46, + 91, + 178, + 26, + 139, + 12, + 178, + 24, + 139, + 254, + 136, + 16, + 131, + 73, + 21, + 22, + 87, + 6, + 2, + 76, + 80, + 178, + 26, + 128, + 62, + 0, + 60, + 116, + 101, + 109, + 112, + 108, + 97, + 116, + 101, + 45, + 105, + 112, + 102, + 115, + 58, + 47, + 47, + 123, + 105, + 112, + 102, + 115, + 99, + 105, + 100, + 58, + 49, + 58, + 100, + 97, + 103, + 45, + 112, + 98, + 58, + 114, + 101, + 115, + 101, + 114, + 118, + 101, + 58, + 115, + 104, + 97, + 50, + 45, + 50, + 53, + 54, + 125, + 47, + 110, + 102, + 100, + 46, + 106, + 115, + 111, + 110, + 178, + 26, + 34, + 178, + 1, + 179, + 180, + 62, + 23, + 140, + 15, + 34, + 139, + 12, + 139, + 15, + 139, + 254, + 136, + 9, + 182, + 139, + 1, + 34, + 19, + 65, + 0, + 110, + 139, + 1, + 136, + 17, + 181, + 65, + 0, + 65, + 139, + 1, + 39, + 7, + 101, + 68, + 128, + 4, + 50, + 46, + 49, + 50, + 18, + 68, + 177, + 37, + 178, + 16, + 34, + 178, + 25, + 139, + 1, + 178, + 24, + 128, + 20, + 117, + 112, + 100, + 97, + 116, + 101, + 95, + 115, + 101, + 103, + 109, + 101, + 110, + 116, + 95, + 99, + 111, + 117, + 110, + 116, + 178, + 26, + 139, + 254, + 178, + 26, + 139, + 12, + 22, + 178, + 26, + 34, + 178, + 1, + 179, + 66, + 0, + 37, + 177, + 37, + 178, + 16, + 128, + 4, + 13, + 38, + 197, + 145, + 178, + 26, + 139, + 1, + 178, + 24, + 139, + 254, + 73, + 21, + 22, + 87, + 6, + 2, + 76, + 80, + 178, + 26, + 139, + 12, + 22, + 178, + 26, + 34, + 178, + 1, + 179, + 136, + 252, + 35, + 140, + 16, + 177, + 37, + 178, + 16, + 128, + 4, + 254, + 57, + 209, + 27, + 178, + 26, + 139, + 12, + 178, + 24, + 139, + 16, + 87, + 8, + 8, + 23, + 22, + 178, + 26, + 34, + 178, + 1, + 179, + 180, + 59, + 35, + 9, + 197, + 58, + 87, + 4, + 0, + 140, + 17, + 128, + 4, + 53, + 197, + 148, + 24, + 40, + 40, + 128, + 2, + 0, + 226, + 139, + 12, + 22, + 136, + 18, + 71, + 139, + 254, + 73, + 21, + 22, + 87, + 6, + 2, + 76, + 80, + 136, + 18, + 71, + 139, + 3, + 22, + 136, + 18, + 52, + 139, + 255, + 56, + 8, + 139, + 4, + 9, + 22, + 136, + 18, + 41, + 139, + 4, + 22, + 136, + 18, + 35, + 52, + 201, + 136, + 18, + 30, + 139, + 255, + 56, + 0, + 136, + 18, + 23, + 139, + 253, + 136, + 18, + 18, + 139, + 11, + 22, + 136, + 18, + 12, + 139, + 17, + 87, + 0, + 8, + 23, + 22, + 136, + 18, + 2, + 139, + 17, + 87, + 8, + 32, + 136, + 17, + 250, + 139, + 17, + 87, + 40, + 8, + 23, + 22, + 136, + 17, + 240, + 139, + 17, + 87, + 48, + 32, + 136, + 17, + 232, + 139, + 17, + 87, + 80, + 8, + 23, + 22, + 136, + 17, + 222, + 72, + 80, + 80, + 176, + 139, + 252, + 65, + 0, + 71, + 177, + 37, + 178, + 16, + 128, + 4, + 120, + 244, + 39, + 17, + 178, + 26, + 139, + 12, + 178, + 24, + 40, + 40, + 128, + 2, + 0, + 4, + 39, + 11, + 73, + 21, + 22, + 87, + 6, + 2, + 76, + 80, + 136, + 17, + 191, + 49, + 0, + 73, + 21, + 22, + 87, + 6, + 2, + 76, + 80, + 136, + 17, + 178, + 72, + 80, + 128, + 2, + 0, + 2, + 76, + 80, + 178, + 26, + 34, + 178, + 1, + 179, + 49, + 0, + 139, + 12, + 139, + 254, + 136, + 0, + 31, + 139, + 12, + 140, + 0, + 70, + 17, + 137, + 54, + 26, + 3, + 73, + 21, + 33, + 4, + 18, + 68, + 54, + 26, + 2, + 23, + 54, + 26, + 1, + 87, + 2, + 0, + 136, + 0, + 2, + 35, + 67, + 138, + 3, + 0, + 40, + 73, + 139, + 253, + 136, + 15, + 127, + 140, + 0, + 139, + 254, + 42, + 101, + 68, + 140, + 1, + 139, + 254, + 139, + 255, + 136, + 15, + 145, + 68, + 139, + 254, + 114, + 8, + 72, + 139, + 253, + 18, + 65, + 0, + 9, + 49, + 0, + 139, + 1, + 18, + 68, + 66, + 0, + 6, + 49, + 0, + 139, + 253, + 18, + 68, + 139, + 253, + 39, + 11, + 139, + 254, + 136, + 4, + 212, + 68, + 139, + 254, + 139, + 0, + 136, + 5, + 56, + 20, + 65, + 0, + 8, + 139, + 254, + 139, + 0, + 136, + 5, + 131, + 68, + 39, + 5, + 39, + 11, + 139, + 254, + 136, + 5, + 253, + 137, + 54, + 26, + 3, + 73, + 21, + 33, + 4, + 18, + 68, + 54, + 26, + 2, + 23, + 54, + 26, + 1, + 87, + 2, + 0, + 136, + 0, + 2, + 35, + 67, + 138, + 3, + 0, + 40, + 73, + 139, + 254, + 42, + 101, + 68, + 140, + 0, + 139, + 254, + 139, + 255, + 136, + 15, + 36, + 68, + 39, + 12, + 139, + 254, + 136, + 11, + 78, + 136, + 6, + 183, + 20, + 65, + 0, + 16, + 49, + 0, + 139, + 0, + 18, + 73, + 64, + 0, + 6, + 49, + 0, + 139, + 253, + 18, + 17, + 68, + 139, + 253, + 39, + 5, + 139, + 254, + 136, + 4, + 99, + 68, + 139, + 253, + 136, + 14, + 212, + 140, + 1, + 139, + 254, + 139, + 1, + 136, + 8, + 68, + 68, + 139, + 1, + 189, + 76, + 72, + 20, + 65, + 0, + 36, + 177, + 35, + 178, + 16, + 139, + 1, + 21, + 36, + 8, + 35, + 136, + 13, + 178, + 178, + 8, + 49, + 0, + 178, + 7, + 128, + 9, + 98, + 111, + 120, + 82, + 101, + 102, + 117, + 110, + 100, + 178, + 5, + 34, + 178, + 1, + 179, + 49, + 0, + 139, + 253, + 39, + 5, + 139, + 254, + 136, + 5, + 218, + 137, + 54, + 26, + 2, + 23, + 54, + 26, + 1, + 87, + 2, + 0, + 136, + 0, + 2, + 35, + 67, + 138, + 2, + 0, + 40, + 139, + 254, + 139, + 255, + 136, + 1, + 201, + 68, + 139, + 254, + 139, + 254, + 42, + 101, + 68, + 136, + 14, + 128, + 140, + 0, + 139, + 0, + 189, + 76, + 72, + 20, + 68, + 139, + 0, + 139, + 255, + 191, + 137, + 54, + 26, + 4, + 73, + 21, + 33, + 4, + 18, + 68, + 54, + 26, + 3, + 73, + 21, + 33, + 4, + 18, + 68, + 54, + 26, + 2, + 23, + 54, + 26, + 1, + 87, + 2, + 0, + 136, + 0, + 2, + 35, + 67, + 138, + 4, + 0, + 40, + 73, + 139, + 253, + 139, + 252, + 18, + 65, + 0, + 1, + 137, + 139, + 254, + 139, + 255, + 136, + 14, + 73, + 68, + 139, + 254, + 39, + 7, + 101, + 68, + 128, + 3, + 51, + 46, + 51, + 18, + 65, + 0, + 9, + 49, + 22, + 136, + 3, + 103, + 68, + 66, + 0, + 9, + 49, + 0, + 139, + 254, + 114, + 8, + 72, + 18, + 68, + 139, + 254, + 139, + 253, + 136, + 14, + 18, + 140, + 0, + 139, + 254, + 139, + 252, + 136, + 14, + 9, + 140, + 1, + 139, + 0, + 188, + 139, + 1, + 139, + 255, + 191, + 137, + 54, + 26, + 3, + 73, + 21, + 33, + 4, + 18, + 68, + 54, + 26, + 2, + 23, + 54, + 26, + 1, + 87, + 2, + 0, + 136, + 0, + 2, + 35, + 67, + 138, + 3, + 0, + 40, + 139, + 254, + 139, + 255, + 136, + 13, + 233, + 68, + 139, + 254, + 42, + 101, + 68, + 140, + 0, + 139, + 254, + 114, + 8, + 72, + 139, + 253, + 18, + 65, + 0, + 9, + 49, + 0, + 139, + 0, + 18, + 68, + 66, + 0, + 6, + 49, + 0, + 139, + 253, + 18, + 68, + 139, + 254, + 54, + 26, + 3, + 136, + 13, + 157, + 136, + 6, + 148, + 128, + 4, + 81, + 114, + 207, + 1, + 40, + 40, + 128, + 2, + 0, + 42, + 139, + 254, + 22, + 136, + 15, + 110, + 139, + 255, + 73, + 21, + 22, + 87, + 6, + 2, + 76, + 80, + 136, + 15, + 110, + 139, + 253, + 136, + 15, + 92, + 72, + 80, + 80, + 176, + 137, + 41, + 54, + 26, + 1, + 87, + 2, + 0, + 136, + 0, + 12, + 73, + 21, + 22, + 87, + 6, + 2, + 76, + 80, + 80, + 176, + 35, + 67, + 138, + 1, + 1, + 40, + 71, + 5, + 139, + 255, + 136, + 0, + 217, + 140, + 0, + 139, + 0, + 42, + 101, + 68, + 140, + 1, + 139, + 0, + 39, + 18, + 101, + 68, + 139, + 255, + 18, + 68, + 49, + 0, + 139, + 1, + 18, + 68, + 139, + 0, + 39, + 12, + 101, + 76, + 72, + 68, + 43, + 190, + 68, + 140, + 2, + 139, + 0, + 39, + 7, + 101, + 68, + 139, + 2, + 19, + 68, + 39, + 6, + 43, + 190, + 68, + 80, + 140, + 3, + 39, + 10, + 139, + 2, + 80, + 190, + 68, + 140, + 4, + 139, + 3, + 189, + 68, + 140, + 5, + 177, + 37, + 178, + 16, + 128, + 4, + 23, + 71, + 64, + 91, + 178, + 26, + 33, + 7, + 178, + 25, + 139, + 0, + 178, + 24, + 139, + 2, + 73, + 21, + 22, + 87, + 6, + 2, + 76, + 80, + 178, + 26, + 139, + 3, + 34, + 33, + 10, + 186, + 178, + 64, + 139, + 3, + 33, + 10, + 139, + 5, + 33, + 10, + 9, + 186, + 178, + 64, + 139, + 4, + 178, + 31, + 34, + 178, + 1, + 179, + 139, + 2, + 140, + 0, + 70, + 5, + 137, + 41, + 54, + 26, + 2, + 23, + 54, + 26, + 1, + 87, + 2, + 0, + 136, + 0, + 10, + 39, + 13, + 34, + 79, + 2, + 84, + 80, + 176, + 35, + 67, + 138, + 2, + 1, + 40, + 139, + 255, + 136, + 12, + 155, + 140, + 0, + 139, + 0, + 189, + 76, + 72, + 20, + 65, + 0, + 10, + 139, + 254, + 139, + 255, + 136, + 12, + 100, + 66, + 0, + 7, + 139, + 254, + 139, + 255, + 136, + 12, + 171, + 140, + 0, + 137, + 41, + 54, + 26, + 1, + 87, + 2, + 0, + 136, + 0, + 5, + 22, + 80, + 176, + 35, + 67, + 138, + 1, + 1, + 40, + 73, + 139, + 255, + 136, + 12, + 99, + 140, + 0, + 139, + 0, + 189, + 76, + 72, + 20, + 65, + 0, + 4, + 34, + 66, + 0, + 17, + 139, + 0, + 190, + 68, + 140, + 1, + 139, + 1, + 21, + 33, + 9, + 18, + 68, + 139, + 1, + 36, + 91, + 140, + 0, + 70, + 1, + 137, + 41, + 54, + 26, + 1, + 73, + 21, + 33, + 4, + 18, + 68, + 136, + 0, + 14, + 73, + 21, + 36, + 10, + 22, + 87, + 6, + 2, + 76, + 80, + 80, + 176, + 35, + 67, + 138, + 1, + 1, + 40, + 71, + 4, + 40, + 140, + 0, + 139, + 255, + 136, + 12, + 31, + 140, + 1, + 139, + 1, + 189, + 76, + 72, + 20, + 65, + 0, + 5, + 139, + 0, + 66, + 0, + 53, + 139, + 1, + 190, + 68, + 140, + 2, + 34, + 140, + 3, + 139, + 3, + 139, + 2, + 21, + 12, + 65, + 0, + 33, + 139, + 2, + 139, + 3, + 36, + 88, + 23, + 140, + 4, + 139, + 4, + 34, + 19, + 65, + 0, + 8, + 139, + 0, + 139, + 4, + 22, + 80, + 140, + 0, + 139, + 3, + 36, + 8, + 140, + 3, + 66, + 255, + 214, + 139, + 0, + 140, + 0, + 70, + 4, + 137, + 54, + 26, + 3, + 87, + 2, + 0, + 54, + 26, + 2, + 23, + 54, + 26, + 1, + 87, + 2, + 0, + 136, + 0, + 2, + 35, + 67, + 138, + 3, + 0, + 49, + 22, + 136, + 1, + 13, + 68, + 39, + 6, + 139, + 255, + 80, + 139, + 254, + 185, + 72, + 39, + 10, + 139, + 255, + 80, + 139, + 253, + 191, + 137, + 54, + 26, + 3, + 87, + 2, + 0, + 54, + 26, + 2, + 23, + 54, + 26, + 1, + 87, + 2, + 0, + 136, + 0, + 2, + 35, + 67, + 138, + 3, + 0, + 49, + 22, + 136, + 0, + 221, + 68, + 39, + 6, + 139, + 255, + 80, + 139, + 254, + 139, + 253, + 187, + 137, + 54, + 26, + 1, + 87, + 2, + 0, + 136, + 0, + 2, + 35, + 67, + 138, + 1, + 0, + 49, + 22, + 136, + 0, + 190, + 68, + 43, + 139, + 255, + 191, + 137, + 41, + 54, + 26, + 1, + 23, + 136, + 0, + 5, + 22, + 80, + 176, + 35, + 67, + 138, + 1, + 1, + 40, + 71, + 2, + 52, + 204, + 128, + 2, + 116, + 115, + 101, + 68, + 140, + 0, + 52, + 204, + 128, + 8, + 100, + 101, + 99, + 105, + 109, + 97, + 108, + 115, + 101, + 68, + 140, + 1, + 52, + 204, + 128, + 5, + 112, + 114, + 105, + 99, + 101, + 101, + 68, + 140, + 2, + 50, + 7, + 139, + 0, + 9, + 33, + 15, + 13, + 65, + 0, + 34, + 33, + 5, + 140, + 1, + 129, + 33, + 140, + 2, + 128, + 23, + 111, + 114, + 97, + 99, + 108, + 101, + 32, + 62, + 50, + 52, + 104, + 114, + 32, + 117, + 115, + 105, + 110, + 103, + 32, + 46, + 51, + 51, + 99, + 176, + 139, + 255, + 33, + 16, + 11, + 139, + 1, + 136, + 9, + 136, + 11, + 139, + 2, + 10, + 33, + 16, + 10, + 33, + 16, + 11, + 140, + 0, + 70, + 2, + 137, + 41, + 54, + 26, + 1, + 73, + 21, + 33, + 4, + 18, + 68, + 136, + 0, + 5, + 22, + 80, + 176, + 35, + 67, + 138, + 1, + 1, + 40, + 139, + 255, + 136, + 10, + 200, + 140, + 0, + 139, + 0, + 189, + 76, + 72, + 20, + 65, + 0, + 12, + 139, + 0, + 21, + 36, + 8, + 35, + 136, + 9, + 178, + 66, + 0, + 3, + 129, + 128, + 25, + 140, + 0, + 137, + 138, + 1, + 1, + 139, + 255, + 56, + 0, + 52, + 200, + 112, + 0, + 72, + 35, + 18, + 73, + 65, + 0, + 8, + 139, + 255, + 56, + 9, + 50, + 3, + 18, + 16, + 73, + 65, + 0, + 8, + 139, + 255, + 56, + 32, + 50, + 3, + 18, + 16, + 137, + 138, + 0, + 1, + 34, + 71, + 3, + 35, + 34, + 73, + 136, + 9, + 35, + 137, + 138, + 3, + 1, + 139, + 255, + 136, + 11, + 27, + 65, + 0, + 49, + 177, + 37, + 178, + 16, + 139, + 255, + 178, + 24, + 128, + 19, + 105, + 115, + 95, + 97, + 100, + 100, + 114, + 101, + 115, + 115, + 95, + 105, + 110, + 95, + 102, + 105, + 101, + 108, + 100, + 178, + 26, + 139, + 254, + 178, + 26, + 139, + 253, + 178, + 26, + 34, + 178, + 1, + 179, + 180, + 62, + 23, + 35, + 18, + 137, + 177, + 37, + 178, + 16, + 128, + 4, + 212, + 67, + 149, + 42, + 178, + 26, + 139, + 255, + 178, + 24, + 139, + 254, + 73, + 21, + 22, + 87, + 6, + 2, + 76, + 80, + 178, + 26, + 139, + 253, + 178, + 26, + 34, + 178, + 1, + 179, + 180, + 59, + 35, + 9, + 197, + 58, + 87, + 4, + 0, + 34, + 83, + 137, + 138, + 2, + 1, + 40, + 71, + 3, + 139, + 254, + 34, + 19, + 68, + 139, + 255, + 189, + 76, + 72, + 20, + 65, + 0, + 4, + 34, + 66, + 0, + 57, + 139, + 255, + 190, + 68, + 140, + 0, + 139, + 0, + 140, + 1, + 139, + 0, + 21, + 36, + 10, + 140, + 2, + 34, + 140, + 3, + 139, + 3, + 139, + 2, + 12, + 65, + 0, + 28, + 139, + 1, + 139, + 3, + 36, + 11, + 36, + 88, + 23, + 139, + 254, + 18, + 65, + 0, + 4, + 35, + 66, + 0, + 10, + 139, + 3, + 35, + 8, + 140, + 3, + 66, + 255, + 220, + 34, + 140, + 0, + 70, + 3, + 137, + 138, + 2, + 1, + 40, + 71, + 3, + 139, + 255, + 189, + 76, + 72, + 20, + 65, + 0, + 10, + 139, + 255, + 139, + 254, + 22, + 191, + 35, + 66, + 0, + 102, + 139, + 255, + 190, + 68, + 140, + 0, + 139, + 0, + 21, + 36, + 10, + 140, + 1, + 34, + 140, + 2, + 139, + 2, + 139, + 1, + 12, + 65, + 0, + 51, + 139, + 0, + 139, + 2, + 36, + 11, + 91, + 140, + 3, + 139, + 3, + 34, + 18, + 65, + 0, + 14, + 139, + 255, + 139, + 2, + 36, + 11, + 139, + 254, + 22, + 187, + 35, + 66, + 0, + 48, + 139, + 3, + 139, + 254, + 18, + 65, + 0, + 4, + 35, + 66, + 0, + 36, + 139, + 2, + 35, + 8, + 140, + 2, + 66, + 255, + 197, + 139, + 0, + 21, + 129, + 240, + 7, + 12, + 65, + 0, + 16, + 139, + 255, + 188, + 139, + 255, + 139, + 0, + 139, + 254, + 22, + 80, + 191, + 35, + 66, + 0, + 1, + 34, + 140, + 0, + 70, + 3, + 137, + 138, + 3, + 1, + 139, + 255, + 136, + 9, + 213, + 65, + 0, + 54, + 177, + 37, + 178, + 16, + 139, + 255, + 178, + 24, + 128, + 24, + 114, + 101, + 103, + 95, + 97, + 100, + 100, + 95, + 118, + 101, + 114, + 105, + 102, + 105, + 101, + 100, + 95, + 97, + 100, + 100, + 114, + 101, + 115, + 115, + 178, + 26, + 139, + 254, + 178, + 26, + 139, + 253, + 178, + 26, + 34, + 178, + 1, + 179, + 180, + 62, + 23, + 35, + 18, + 137, + 177, + 37, + 178, + 16, + 128, + 4, + 133, + 204, + 237, + 87, + 178, + 26, + 139, + 255, + 178, + 24, + 139, + 254, + 73, + 21, + 22, + 87, + 6, + 2, + 76, + 80, + 178, + 26, + 139, + 253, + 73, + 21, + 22, + 87, + 6, + 2, + 76, + 80, + 178, + 26, + 34, + 178, + 1, + 179, + 180, + 59, + 35, + 9, + 197, + 58, + 87, + 4, + 0, + 34, + 83, + 137, + 138, + 4, + 1, + 139, + 255, + 136, + 9, + 92, + 65, + 0, + 57, + 177, + 37, + 178, + 16, + 139, + 255, + 178, + 24, + 128, + 27, + 114, + 101, + 103, + 95, + 114, + 101, + 109, + 111, + 118, + 101, + 95, + 118, + 101, + 114, + 105, + 102, + 105, + 101, + 100, + 95, + 97, + 100, + 100, + 114, + 101, + 115, + 115, + 178, + 26, + 139, + 254, + 178, + 26, + 139, + 253, + 178, + 26, + 34, + 178, + 1, + 179, + 180, + 62, + 23, + 35, + 18, + 137, + 177, + 37, + 178, + 16, + 128, + 4, + 177, + 137, + 10, + 117, + 178, + 26, + 139, + 255, + 178, + 24, + 139, + 254, + 73, + 21, + 22, + 87, + 6, + 2, + 76, + 80, + 178, + 26, + 139, + 253, + 178, + 26, + 139, + 252, + 178, + 26, + 34, + 178, + 1, + 179, + 180, + 59, + 35, + 9, + 197, + 58, + 87, + 4, + 0, + 34, + 83, + 137, + 138, + 1, + 1, + 139, + 255, + 34, + 18, + 65, + 0, + 2, + 34, + 137, + 50, + 7, + 139, + 255, + 13, + 137, + 138, + 0, + 0, + 54, + 26, + 1, + 136, + 251, + 174, + 22, + 176, + 137, + 138, + 0, + 0, + 40, + 54, + 26, + 1, + 136, + 8, + 24, + 140, + 0, + 139, + 0, + 189, + 76, + 72, + 20, + 65, + 0, + 3, + 40, + 176, + 137, + 139, + 0, + 190, + 68, + 176, + 137, + 138, + 0, + 0, + 40, + 54, + 26, + 2, + 23, + 54, + 26, + 1, + 136, + 7, + 199, + 68, + 54, + 26, + 2, + 23, + 128, + 7, + 105, + 46, + 97, + 115, + 97, + 105, + 100, + 101, + 68, + 140, + 0, + 139, + 0, + 40, + 19, + 68, + 35, + 54, + 26, + 2, + 23, + 139, + 0, + 23, + 54, + 26, + 1, + 136, + 0, + 114, + 137, + 138, + 2, + 0, + 40, + 71, + 3, + 139, + 255, + 136, + 7, + 197, + 189, + 76, + 72, + 65, + 0, + 1, + 137, + 128, + 8, + 97, + 100, + 100, + 114, + 101, + 115, + 115, + 47, + 139, + 254, + 80, + 136, + 7, + 32, + 140, + 0, + 40, + 140, + 1, + 34, + 140, + 2, + 139, + 2, + 33, + 9, + 12, + 65, + 0, + 62, + 39, + 16, + 139, + 2, + 136, + 9, + 80, + 80, + 140, + 3, + 139, + 0, + 54, + 50, + 0, + 139, + 3, + 99, + 76, + 72, + 65, + 0, + 13, + 139, + 1, + 139, + 0, + 139, + 3, + 98, + 80, + 140, + 1, + 66, + 0, + 17, + 139, + 1, + 21, + 34, + 13, + 65, + 0, + 8, + 139, + 255, + 136, + 7, + 109, + 139, + 1, + 191, + 137, + 139, + 2, + 35, + 8, + 140, + 2, + 66, + 255, + 186, + 137, + 138, + 4, + 0, + 40, + 139, + 252, + 20, + 65, + 0, + 7, + 139, + 255, + 136, + 0, + 33, + 20, + 68, + 139, + 255, + 136, + 7, + 63, + 140, + 0, + 139, + 254, + 68, + 139, + 253, + 68, + 139, + 0, + 189, + 76, + 72, + 20, + 68, + 139, + 0, + 139, + 254, + 22, + 139, + 253, + 22, + 80, + 191, + 137, + 138, + 1, + 1, + 40, + 39, + 14, + 139, + 255, + 80, + 136, + 6, + 149, + 140, + 0, + 139, + 0, + 54, + 50, + 0, + 97, + 20, + 65, + 0, + 4, + 34, + 66, + 0, + 10, + 139, + 0, + 54, + 50, + 0, + 39, + 15, + 99, + 76, + 72, + 140, + 0, + 137, + 138, + 2, + 1, + 40, + 71, + 4, + 139, + 255, + 190, + 68, + 140, + 0, + 139, + 254, + 34, + 19, + 68, + 139, + 0, + 21, + 33, + 9, + 15, + 68, + 139, + 0, + 34, + 91, + 139, + 254, + 18, + 65, + 0, + 4, + 35, + 66, + 0, + 84, + 139, + 0, + 21, + 36, + 10, + 140, + 1, + 34, + 140, + 2, + 34, + 140, + 3, + 139, + 3, + 139, + 1, + 12, + 65, + 0, + 29, + 139, + 0, + 139, + 3, + 36, + 11, + 91, + 139, + 254, + 18, + 65, + 0, + 7, + 139, + 3, + 140, + 2, + 66, + 0, + 9, + 139, + 3, + 35, + 8, + 140, + 3, + 66, + 255, + 219, + 139, + 2, + 34, + 19, + 68, + 139, + 0, + 34, + 91, + 140, + 4, + 139, + 0, + 34, + 139, + 254, + 22, + 93, + 140, + 0, + 139, + 255, + 139, + 0, + 139, + 2, + 36, + 11, + 139, + 4, + 22, + 93, + 191, + 35, + 140, + 0, + 70, + 4, + 137, + 138, + 2, + 1, + 40, + 71, + 2, + 139, + 255, + 190, + 68, + 140, + 0, + 139, + 0, + 21, + 36, + 10, + 140, + 1, + 34, + 140, + 2, + 139, + 2, + 139, + 1, + 12, + 65, + 0, + 70, + 139, + 0, + 139, + 2, + 36, + 11, + 91, + 139, + 254, + 18, + 65, + 0, + 48, + 139, + 2, + 139, + 1, + 35, + 9, + 18, + 65, + 0, + 25, + 139, + 255, + 188, + 139, + 2, + 34, + 13, + 65, + 0, + 11, + 139, + 255, + 139, + 0, + 34, + 139, + 2, + 36, + 11, + 88, + 191, + 35, + 66, + 0, + 23, + 139, + 255, + 139, + 2, + 36, + 11, + 39, + 4, + 187, + 35, + 66, + 0, + 10, + 139, + 2, + 35, + 8, + 140, + 2, + 66, + 255, + 178, + 34, + 140, + 0, + 70, + 2, + 137, + 138, + 3, + 1, + 139, + 254, + 34, + 139, + 253, + 82, + 139, + 255, + 22, + 80, + 139, + 254, + 139, + 253, + 36, + 8, + 139, + 254, + 21, + 82, + 80, + 137, + 138, + 3, + 1, + 40, + 71, + 2, + 139, + 255, + 139, + 254, + 98, + 140, + 0, + 139, + 0, + 21, + 36, + 10, + 140, + 1, + 34, + 140, + 2, + 139, + 2, + 139, + 1, + 12, + 65, + 0, + 41, + 139, + 0, + 139, + 2, + 36, + 11, + 91, + 139, + 253, + 18, + 65, + 0, + 19, + 139, + 255, + 139, + 254, + 139, + 2, + 36, + 11, + 139, + 0, + 34, + 136, + 255, + 173, + 102, + 35, + 66, + 0, + 10, + 139, + 2, + 35, + 8, + 140, + 2, + 66, + 255, + 207, + 34, + 140, + 0, + 70, + 2, + 137, + 138, + 4, + 1, + 40, + 34, + 140, + 0, + 139, + 0, + 139, + 253, + 12, + 65, + 0, + 31, + 139, + 252, + 139, + 254, + 139, + 0, + 136, + 7, + 87, + 80, + 139, + 255, + 136, + 255, + 148, + 65, + 0, + 4, + 35, + 66, + 0, + 10, + 139, + 0, + 35, + 8, + 140, + 0, + 66, + 255, + 217, + 34, + 140, + 0, + 137, + 138, + 0, + 0, + 40, + 73, + 50, + 10, + 115, + 0, + 72, + 140, + 0, + 50, + 10, + 115, + 1, + 72, + 140, + 1, + 139, + 0, + 139, + 1, + 13, + 65, + 0, + 33, + 177, + 35, + 178, + 16, + 139, + 0, + 139, + 1, + 9, + 178, + 8, + 54, + 26, + 1, + 178, + 7, + 128, + 9, + 115, + 119, + 101, + 101, + 112, + 68, + 117, + 115, + 116, + 178, + 5, + 34, + 178, + 1, + 179, + 137, + 138, + 1, + 1, + 40, + 71, + 6, + 139, + 255, + 21, + 140, + 0, + 139, + 0, + 37, + 15, + 68, + 139, + 255, + 139, + 0, + 33, + 6, + 9, + 33, + 6, + 88, + 128, + 5, + 46, + 97, + 108, + 103, + 111, + 18, + 68, + 39, + 13, + 34, + 73, + 84, + 39, + 4, + 80, + 39, + 4, + 80, + 140, + 1, + 34, + 140, + 2, + 34, + 140, + 3, + 34, + 140, + 4, + 34, + 140, + 5, + 139, + 5, + 139, + 0, + 33, + 7, + 9, + 12, + 65, + 0, + 153, + 139, + 255, + 139, + 5, + 85, + 140, + 6, + 139, + 6, + 129, + 46, + 18, + 65, + 0, + 81, + 139, + 2, + 35, + 8, + 140, + 2, + 139, + 2, + 35, + 18, + 65, + 0, + 25, + 139, + 5, + 140, + 4, + 139, + 3, + 35, + 15, + 73, + 65, + 0, + 6, + 139, + 3, + 33, + 17, + 14, + 16, + 68, + 34, + 140, + 3, + 66, + 0, + 40, + 139, + 2, + 33, + 5, + 18, + 65, + 0, + 31, + 139, + 3, + 35, + 15, + 73, + 65, + 0, + 6, + 139, + 3, + 33, + 17, + 14, + 16, + 73, + 65, + 0, + 9, + 139, + 5, + 139, + 0, + 33, + 6, + 9, + 18, + 16, + 68, + 66, + 0, + 1, + 0, + 66, + 0, + 48, + 139, + 6, + 129, + 97, + 15, + 73, + 65, + 0, + 6, + 139, + 6, + 129, + 122, + 14, + 16, + 73, + 64, + 0, + 16, + 139, + 6, + 129, + 48, + 15, + 73, + 65, + 0, + 6, + 139, + 6, + 129, + 57, + 14, + 16, + 17, + 65, + 0, + 9, + 139, + 3, + 35, + 8, + 140, + 3, + 66, + 0, + 1, + 0, + 139, + 5, + 35, + 8, + 140, + 5, + 66, + 255, + 92, + 139, + 2, + 35, + 18, + 65, + 0, + 39, + 139, + 1, + 53, + 255, + 52, + 255, + 34, + 73, + 84, + 140, + 1, + 139, + 1, + 53, + 255, + 52, + 255, + 35, + 139, + 4, + 22, + 93, + 140, + 1, + 139, + 1, + 53, + 255, + 52, + 255, + 39, + 4, + 92, + 9, + 140, + 1, + 66, + 0, + 44, + 139, + 1, + 53, + 255, + 52, + 255, + 34, + 35, + 84, + 140, + 1, + 139, + 1, + 53, + 255, + 52, + 255, + 35, + 139, + 3, + 22, + 93, + 140, + 1, + 139, + 1, + 53, + 255, + 52, + 255, + 129, + 9, + 139, + 0, + 33, + 6, + 9, + 139, + 3, + 9, + 22, + 93, + 140, + 1, + 139, + 1, + 140, + 0, + 70, + 6, + 137, + 138, + 1, + 1, + 40, + 73, + 139, + 255, + 136, + 3, + 242, + 140, + 0, + 139, + 0, + 189, + 76, + 72, + 20, + 65, + 0, + 4, + 34, + 66, + 0, + 17, + 139, + 0, + 190, + 68, + 140, + 1, + 139, + 1, + 21, + 33, + 9, + 18, + 68, + 139, + 1, + 36, + 91, + 140, + 0, + 70, + 1, + 137, + 138, + 2, + 1, + 139, + 255, + 139, + 254, + 53, + 255, + 52, + 255, + 87, + 9, + 8, + 23, + 139, + 255, + 21, + 82, + 137, + 138, + 2, + 1, + 139, + 255, + 139, + 254, + 101, + 76, + 72, + 20, + 65, + 0, + 2, + 40, + 137, + 139, + 255, + 139, + 254, + 101, + 68, + 137, + 138, + 2, + 1, + 139, + 255, + 139, + 254, + 101, + 76, + 72, + 20, + 65, + 0, + 2, + 34, + 137, + 139, + 255, + 139, + 254, + 101, + 68, + 23, + 137, + 138, + 3, + 1, + 40, + 71, + 19, + 136, + 239, + 17, + 140, + 0, + 139, + 254, + 53, + 255, + 52, + 255, + 34, + 83, + 65, + 0, + 110, + 139, + 254, + 139, + 255, + 136, + 255, + 160, + 136, + 255, + 110, + 140, + 2, + 139, + 2, + 34, + 19, + 68, + 34, + 140, + 3, + 39, + 17, + 139, + 2, + 136, + 255, + 160, + 39, + 9, + 18, + 65, + 0, + 49, + 128, + 17, + 105, + 46, + 115, + 101, + 103, + 109, + 101, + 110, + 116, + 80, + 114, + 105, + 99, + 101, + 85, + 115, + 100, + 139, + 2, + 136, + 255, + 153, + 140, + 3, + 139, + 3, + 139, + 0, + 87, + 0, + 8, + 23, + 12, + 65, + 0, + 8, + 139, + 0, + 87, + 0, + 8, + 23, + 140, + 3, + 66, + 0, + 8, + 139, + 0, + 87, + 0, + 8, + 23, + 140, + 3, + 139, + 3, + 139, + 0, + 87, + 0, + 8, + 23, + 15, + 68, + 139, + 3, + 136, + 247, + 191, + 140, + 1, + 66, + 0, + 112, + 139, + 254, + 53, + 255, + 52, + 255, + 87, + 1, + 8, + 23, + 140, + 4, + 34, + 140, + 5, + 139, + 4, + 33, + 6, + 15, + 65, + 0, + 8, + 129, + 216, + 4, + 140, + 5, + 66, + 0, + 65, + 139, + 4, + 33, + 7, + 18, + 65, + 0, + 8, + 129, + 176, + 9, + 140, + 5, + 66, + 0, + 49, + 139, + 4, + 33, + 8, + 18, + 65, + 0, + 8, + 129, + 184, + 23, + 140, + 5, + 66, + 0, + 33, + 139, + 4, + 33, + 5, + 18, + 65, + 0, + 8, + 129, + 168, + 70, + 140, + 5, + 66, + 0, + 17, + 139, + 4, + 35, + 18, + 65, + 0, + 9, + 129, + 140, + 246, + 1, + 140, + 5, + 66, + 0, + 1, + 0, + 50, + 7, + 139, + 5, + 136, + 0, + 249, + 140, + 6, + 139, + 6, + 136, + 247, + 76, + 140, + 1, + 139, + 255, + 136, + 246, + 36, + 140, + 7, + 34, + 140, + 8, + 34, + 140, + 9, + 139, + 7, + 34, + 19, + 65, + 0, + 151, + 139, + 253, + 139, + 7, + 42, + 101, + 68, + 18, + 140, + 10, + 39, + 12, + 139, + 7, + 136, + 254, + 207, + 140, + 11, + 139, + 11, + 136, + 250, + 52, + 73, + 65, + 0, + 4, + 139, + 10, + 20, + 16, + 65, + 0, + 116, + 35, + 140, + 8, + 35, + 140, + 9, + 139, + 0, + 87, + 64, + 8, + 23, + 136, + 247, + 4, + 140, + 12, + 139, + 1, + 140, + 13, + 50, + 7, + 140, + 14, + 139, + 11, + 139, + 0, + 87, + 56, + 8, + 23, + 33, + 18, + 11, + 33, + 18, + 11, + 129, + 24, + 11, + 8, + 140, + 15, + 139, + 14, + 139, + 11, + 13, + 68, + 139, + 14, + 139, + 15, + 15, + 65, + 0, + 7, + 139, + 13, + 140, + 1, + 66, + 0, + 50, + 139, + 14, + 139, + 11, + 9, + 140, + 16, + 139, + 15, + 139, + 11, + 9, + 140, + 17, + 139, + 12, + 139, + 13, + 9, + 140, + 18, + 139, + 18, + 139, + 16, + 11, + 139, + 17, + 10, + 140, + 19, + 139, + 12, + 139, + 19, + 9, + 140, + 1, + 139, + 1, + 139, + 13, + 12, + 65, + 0, + 4, + 139, + 13, + 140, + 1, + 139, + 1, + 129, + 192, + 132, + 61, + 15, + 68, + 139, + 1, + 22, + 139, + 7, + 34, + 18, + 65, + 0, + 8, + 139, + 255, + 136, + 237, + 245, + 66, + 0, + 1, + 34, + 22, + 80, + 39, + 13, + 34, + 139, + 7, + 34, + 19, + 84, + 35, + 139, + 9, + 84, + 33, + 5, + 139, + 8, + 84, + 80, + 140, + 0, + 70, + 19, + 137, + 41, + 54, + 26, + 2, + 23, + 54, + 26, + 1, + 23, + 136, + 0, + 5, + 22, + 80, + 176, + 35, + 67, + 138, + 2, + 1, + 40, + 71, + 3, + 139, + 254, + 33, + 19, + 12, + 65, + 0, + 5, + 139, + 255, + 66, + 0, + 46, + 139, + 254, + 33, + 19, + 9, + 140, + 0, + 139, + 0, + 129, + 128, + 231, + 132, + 15, + 10, + 140, + 1, + 139, + 1, + 34, + 18, + 65, + 0, + 5, + 139, + 255, + 66, + 0, + 17, + 129, + 102, + 139, + 1, + 149, + 140, + 2, + 140, + 3, + 139, + 255, + 139, + 2, + 11, + 129, + 100, + 10, + 140, + 0, + 70, + 3, + 137, + 138, + 1, + 1, + 40, + 73, + 33, + 12, + 139, + 255, + 149, + 140, + 0, + 140, + 1, + 139, + 0, + 140, + 0, + 70, + 1, + 137, + 138, + 7, + 1, + 40, + 33, + 11, + 140, + 0, + 139, + 0, + 139, + 255, + 33, + 11, + 11, + 8, + 140, + 0, + 139, + 0, + 139, + 254, + 33, + 11, + 11, + 8, + 140, + 0, + 139, + 0, + 139, + 253, + 33, + 11, + 11, + 8, + 140, + 0, + 139, + 0, + 139, + 252, + 33, + 20, + 11, + 8, + 140, + 0, + 139, + 0, + 139, + 250, + 33, + 20, + 11, + 8, + 140, + 0, + 139, + 0, + 139, + 251, + 33, + 21, + 11, + 8, + 140, + 0, + 139, + 0, + 139, + 249, + 33, + 21, + 11, + 8, + 140, + 0, + 139, + 0, + 140, + 0, + 137, + 138, + 2, + 1, + 129, + 196, + 19, + 139, + 255, + 11, + 139, + 254, + 129, + 144, + 3, + 11, + 8, + 137, + 138, + 1, + 1, + 139, + 255, + 21, + 33, + 4, + 14, + 65, + 0, + 3, + 139, + 255, + 137, + 139, + 255, + 34, + 33, + 4, + 39, + 19, + 21, + 9, + 82, + 39, + 19, + 80, + 137, + 138, + 2, + 1, + 40, + 139, + 254, + 140, + 0, + 139, + 255, + 33, + 22, + 15, + 65, + 0, + 25, + 139, + 255, + 33, + 23, + 26, + 33, + 22, + 25, + 22, + 87, + 7, + 1, + 139, + 255, + 129, + 7, + 145, + 136, + 255, + 220, + 140, + 0, + 66, + 0, + 11, + 139, + 255, + 33, + 23, + 26, + 22, + 87, + 7, + 1, + 140, + 0, + 139, + 254, + 139, + 0, + 80, + 140, + 0, + 137, + 138, + 1, + 1, + 40, + 139, + 255, + 136, + 255, + 187, + 137, + 138, + 1, + 1, + 40, + 128, + 47, + 5, + 32, + 1, + 1, + 128, + 8, + 1, + 2, + 3, + 4, + 5, + 6, + 7, + 8, + 23, + 53, + 0, + 49, + 24, + 52, + 0, + 18, + 49, + 16, + 129, + 6, + 18, + 16, + 49, + 25, + 34, + 18, + 49, + 25, + 129, + 0, + 18, + 17, + 16, + 64, + 0, + 1, + 0, + 34, + 67, + 38, + 1, + 140, + 0, + 139, + 0, + 37, + 54, + 50, + 0, + 22, + 93, + 140, + 0, + 139, + 0, + 139, + 255, + 21, + 136, + 255, + 173, + 80, + 139, + 255, + 80, + 140, + 0, + 128, + 7, + 80, + 114, + 111, + 103, + 114, + 97, + 109, + 139, + 0, + 80, + 3, + 140, + 0, + 137, + 138, + 2, + 1, + 40, + 39, + 14, + 139, + 255, + 80, + 136, + 255, + 149, + 140, + 0, + 139, + 0, + 54, + 50, + 0, + 39, + 15, + 99, + 76, + 72, + 68, + 139, + 0, + 39, + 15, + 98, + 139, + 254, + 22, + 18, + 140, + 0, + 137, + 138, + 1, + 1, + 39, + 14, + 139, + 255, + 80, + 1, + 137, + 138, + 1, + 1, + 128, + 10, + 97, + 100, + 100, + 114, + 47, + 97, + 108, + 103, + 111, + 47, + 139, + 255, + 80, + 1, + 137, + 138, + 2, + 1, + 128, + 1, + 79, + 139, + 255, + 139, + 254, + 22, + 80, + 80, + 137, + 138, + 2, + 1, + 40, + 71, + 2, + 139, + 255, + 136, + 255, + 201, + 140, + 0, + 139, + 0, + 190, + 68, + 140, + 1, + 139, + 0, + 189, + 68, + 140, + 2, + 139, + 0, + 189, + 76, + 72, + 20, + 65, + 0, + 4, + 34, + 66, + 0, + 48, + 139, + 2, + 33, + 9, + 19, + 65, + 0, + 4, + 34, + 66, + 0, + 36, + 139, + 255, + 21, + 33, + 6, + 12, + 65, + 0, + 4, + 34, + 66, + 0, + 23, + 139, + 254, + 39, + 18, + 101, + 68, + 139, + 255, + 19, + 65, + 0, + 4, + 34, + 66, + 0, + 7, + 139, + 1, + 36, + 91, + 139, + 254, + 18, + 140, + 0, + 70, + 2, + 137, + 138, + 4, + 1, + 40, + 73, + 33, + 14, + 139, + 254, + 11, + 139, + 255, + 10, + 140, + 0, + 139, + 253, + 139, + 0, + 33, + 15, + 11, + 8, + 140, + 1, + 139, + 1, + 50, + 7, + 33, + 14, + 139, + 252, + 11, + 33, + 15, + 11, + 8, + 14, + 68, + 139, + 1, + 140, + 0, + 70, + 1, + 137, + 138, + 1, + 1, + 40, + 139, + 255, + 39, + 7, + 101, + 68, + 87, + 0, + 2, + 140, + 0, + 139, + 0, + 128, + 2, + 49, + 46, + 18, + 73, + 64, + 0, + 8, + 139, + 0, + 128, + 2, + 50, + 46, + 18, + 17, + 140, + 0, + 137, + 35, + 67, + 128, + 4, + 184, + 68, + 123, + 54, + 54, + 26, + 0, + 142, + 1, + 255, + 241, + 0, + 128, + 4, + 49, + 114, + 202, + 157, + 128, + 4, + 255, + 194, + 48, + 60, + 128, + 4, + 112, + 59, + 140, + 231, + 128, + 4, + 32, + 224, + 46, + 119, + 128, + 4, + 126, + 20, + 182, + 211, + 128, + 4, + 62, + 142, + 75, + 118, + 128, + 4, + 148, + 15, + 164, + 113, + 128, + 4, + 149, + 216, + 245, + 204, + 128, + 4, + 210, + 89, + 143, + 2, + 128, + 4, + 242, + 44, + 87, + 242, + 128, + 4, + 214, + 113, + 21, + 91, + 128, + 4, + 22, + 237, + 106, + 94, + 128, + 4, + 75, + 226, + 47, + 198, + 128, + 4, + 237, + 131, + 21, + 67, + 128, + 4, + 255, + 235, + 149, + 85, + 128, + 4, + 44, + 77, + 200, + 176, + 128, + 4, + 243, + 137, + 168, + 204, + 128, + 4, + 47, + 48, + 180, + 133, + 128, + 4, + 161, + 104, + 8, + 1, + 128, + 4, + 79, + 99, + 255, + 246, + 128, + 4, + 140, + 200, + 93, + 173, + 54, + 26, + 0, + 142, + 21, + 233, + 192, + 233, + 201, + 233, + 240, + 234, + 122, + 234, + 185, + 234, + 224, + 238, + 209, + 239, + 69, + 239, + 225, + 240, + 21, + 240, + 136, + 241, + 1, + 241, + 172, + 241, + 236, + 242, + 42, + 242, + 157, + 242, + 205, + 242, + 246, + 243, + 15, + 243, + 143, + 252, + 177, + 136, + 231, + 116, + 35, + 67, + 128, + 4, + 70, + 247, + 101, + 51, + 54, + 26, + 0, + 142, + 1, + 231, + 82, + 136, + 231, + 98, + 35, + 67, + 138, + 1, + 1, + 128, + 10, + 48, + 49, + 50, + 51, + 52, + 53, + 54, + 55, + 56, + 57, + 139, + 255, + 35, + 88, + 137, + 138, + 1, + 1, + 139, + 255, + 34, + 18, + 65, + 0, + 3, + 39, + 9, + 137, + 139, + 255, + 33, + 12, + 10, + 34, + 13, + 65, + 0, + 11, + 139, + 255, + 33, + 12, + 10, + 136, + 255, + 225, + 66, + 0, + 1, + 40, + 139, + 255, + 33, + 12, + 24, + 136, + 255, + 193, + 80, + 137, + 138, + 4, + 3, + 139, + 252, + 139, + 255, + 80, + 139, + 253, + 139, + 254, + 137, + 138, + 4, + 3, + 139, + 252, + 139, + 254, + 80, + 140, + 252, + 139, + 255, + 73, + 21, + 139, + 254, + 23, + 8, + 22, + 87, + 6, + 2, + 140, + 254, + 139, + 253, + 76, + 80, + 140, + 253, + 139, + 252, + 139, + 253, + 139, + 254, + 137, + 164, + 97, + 112, + 105, + 100, + 206, + 5, + 7, + 85, + 233, + 164, + 97, + 112, + 115, + 117, + 196, + 1, + 10, + 163, + 102, + 101, + 101, + 205, + 3, + 232, + 162, + 102, + 118, + 206, + 2, + 154, + 128, + 107, + 163, + 103, + 101, + 110, + 172, + 116, + 101, + 115, + 116, + 110, + 101, + 116, + 45, + 118, + 49, + 46, + 48, + 162, + 103, + 104, + 196, + 32, + 72, + 99, + 181, + 24, + 164, + 179, + 200, + 78, + 200, + 16, + 242, + 45, + 79, + 16, + 129, + 203, + 15, + 113, + 240, + 89, + 167, + 172, + 32, + 222, + 198, + 47, + 127, + 112, + 229, + 9, + 58, + 34, + 162, + 108, + 118, + 206, + 2, + 154, + 128, + 207, + 164, + 110, + 111, + 116, + 101, + 196, + 80, + 78, + 70, + 68, + 32, + 82, + 101, + 103, + 105, + 115, + 116, + 114, + 121, + 32, + 67, + 111, + 110, + 116, + 114, + 97, + 99, + 116, + 58, + 87, + 83, + 79, + 84, + 82, + 74, + 88, + 76, + 89, + 66, + 81, + 89, + 86, + 77, + 70, + 76, + 79, + 73, + 76, + 89, + 86, + 85, + 83, + 78, + 73, + 87, + 75, + 66, + 87, + 85, + 66, + 87, + 51, + 71, + 78, + 85, + 87, + 65, + 70, + 75, + 71, + 75, + 72, + 78, + 75, + 78, + 82, + 88, + 54, + 54, + 78, + 69, + 90, + 73, + 84, + 85, + 76, + 77, + 163, + 115, + 110, + 100, + 196, + 32, + 222, + 61, + 163, + 205, + 60, + 182, + 36, + 130, + 40, + 95, + 229, + 201, + 178, + 233, + 37, + 20, + 191, + 255, + 240, + 141, + 216, + 176, + 218, + 30, + 2, + 33, + 80, + 223, + 192, + 56, + 40, + 44, + 164, + 116, + 121, + 112, + 101, + 164, + 97, + 112, + 112, + 108 + ], + "signingPrivateKey": [ + 2, + 205, + 103, + 33, + 67, + 14, + 82, + 196, + 115, + 196, + 206, + 254, + 50, + 110, + 63, + 182, + 149, + 229, + 184, + 216, + 93, + 11, + 13, + 99, + 69, + 213, + 218, + 165, + 134, + 118, + 47, + 44 + ], + "transaction": { + "appCall": { + "appId": 84366825, + "approvalProgram": [ + 10, + 32, + 24, + 0, + 1, + 8, + 6, + 32, + 2, + 5, + 4, + 3, + 16, + 128, + 32, + 160, + 141, + 6, + 10, + 30, + 237, + 2, + 128, + 163, + 5, + 144, + 78, + 27, + 60, + 128, + 212, + 141, + 190, + 202, + 16, + 212, + 222, + 1, + 208, + 134, + 3, + 128, + 1, + 255, + 1, + 38, + 20, + 0, + 4, + 21, + 31, + 124, + 117, + 9, + 105, + 46, + 111, + 119, + 110, + 101, + 114, + 46, + 97, + 7, + 99, + 117, + 114, + 114, + 101, + 110, + 116, + 8, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 13, + 118, + 46, + 99, + 97, + 65, + 108, + 103, + 111, + 46, + 48, + 46, + 97, + 115, + 11, + 99, + 111, + 110, + 116, + 114, + 97, + 99, + 116, + 58, + 65, + 58, + 5, + 105, + 46, + 118, + 101, + 114, + 3, + 10, + 129, + 1, + 1, + 48, + 11, + 99, + 111, + 110, + 116, + 114, + 97, + 99, + 116, + 58, + 67, + 58, + 12, + 117, + 46, + 99, + 97, + 118, + 46, + 97, + 108, + 103, + 111, + 46, + 97, + 16, + 105, + 46, + 101, + 120, + 112, + 105, + 114, + 97, + 116, + 105, + 111, + 110, + 84, + 105, + 109, + 101, + 1, + 0, + 5, + 110, + 97, + 109, + 101, + 47, + 7, + 105, + 46, + 97, + 112, + 112, + 105, + 100, + 6, + 105, + 46, + 97, + 112, + 112, + 115, + 15, + 105, + 46, + 115, + 101, + 103, + 109, + 101, + 110, + 116, + 76, + 111, + 99, + 107, + 101, + 100, + 6, + 105, + 46, + 110, + 97, + 109, + 101, + 7, + 46, + 46, + 46, + 97, + 108, + 103, + 111, + 128, + 8, + 0, + 0, + 0, + 0, + 7, + 1, + 163, + 144, + 23, + 53, + 204, + 128, + 8, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 50, + 23, + 53, + 203, + 128, + 32, + 140, + 192, + 44, + 36, + 6, + 26, + 39, + 87, + 142, + 136, + 93, + 94, + 83, + 159, + 168, + 35, + 71, + 123, + 171, + 202, + 213, + 25, + 64, + 50, + 84, + 80, + 201, + 214, + 220, + 200, + 26, + 116, + 53, + 202, + 128, + 32, + 254, + 115, + 101, + 249, + 131, + 173, + 194, + 235, + 65, + 228, + 41, + 1, + 8, + 109, + 106, + 175, + 251, + 215, + 53, + 172, + 16, + 84, + 237, + 88, + 59, + 48, + 34, + 94, + 151, + 72, + 133, + 83, + 53, + 201, + 128, + 8, + 0, + 0, + 0, + 0, + 5, + 7, + 85, + 184, + 23, + 53, + 200, + 49, + 24, + 20, + 37, + 11, + 49, + 25, + 8, + 141, + 12, + 23, + 240, + 0, + 0, + 0, + 0, + 0, + 0, + 24, + 162, + 0, + 0, + 23, + 226, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 136, + 0, + 2, + 35, + 67, + 138, + 0, + 0, + 49, + 0, + 54, + 50, + 0, + 114, + 7, + 72, + 18, + 68, + 137, + 138, + 0, + 0, + 40, + 49, + 25, + 33, + 7, + 18, + 65, + 0, + 4, + 136, + 255, + 227, + 137, + 49, + 32, + 50, + 3, + 18, + 68, + 54, + 26, + 0, + 128, + 3, + 103, + 97, + 115, + 18, + 65, + 0, + 1, + 137, + 49, + 27, + 33, + 8, + 18, + 73, + 65, + 0, + 25, + 54, + 26, + 0, + 128, + 18, + 105, + 115, + 95, + 118, + 97, + 108, + 105, + 100, + 95, + 110, + 102, + 100, + 95, + 97, + 112, + 112, + 105, + 100, + 18, + 16, + 65, + 0, + 21, + 54, + 26, + 2, + 23, + 54, + 26, + 1, + 136, + 9, + 251, + 65, + 0, + 4, + 35, + 66, + 0, + 1, + 34, + 22, + 176, + 137, + 49, + 27, + 33, + 7, + 18, + 73, + 65, + 0, + 22, + 54, + 26, + 0, + 128, + 15, + 118, + 101, + 114, + 105, + 102, + 121, + 95, + 110, + 102, + 100, + 95, + 97, + 100, + 100, + 114, + 18, + 16, + 65, + 0, + 14, + 54, + 26, + 3, + 54, + 26, + 2, + 23, + 54, + 26, + 1, + 136, + 6, + 230, + 137, + 49, + 27, + 33, + 7, + 18, + 73, + 65, + 0, + 22, + 54, + 26, + 0, + 128, + 15, + 117, + 110, + 108, + 105, + 110, + 107, + 95, + 110, + 102, + 100, + 95, + 97, + 100, + 100, + 114, + 18, + 16, + 65, + 0, + 14, + 54, + 26, + 3, + 54, + 26, + 2, + 23, + 54, + 26, + 1, + 136, + 7, + 42, + 137, + 49, + 27, + 33, + 7, + 18, + 73, + 65, + 0, + 27, + 54, + 26, + 0, + 128, + 20, + 115, + 101, + 116, + 95, + 97, + 100, + 100, + 114, + 95, + 112, + 114, + 105, + 109, + 97, + 114, + 121, + 95, + 110, + 102, + 100, + 18, + 16, + 65, + 0, + 14, + 54, + 26, + 3, + 54, + 26, + 2, + 23, + 54, + 26, + 1, + 136, + 8, + 56, + 137, + 49, + 27, + 33, + 5, + 18, + 73, + 65, + 0, + 21, + 54, + 26, + 0, + 128, + 14, + 103, + 101, + 116, + 95, + 110, + 97, + 109, + 101, + 95, + 97, + 112, + 112, + 105, + 100, + 18, + 16, + 65, + 0, + 4, + 136, + 13, + 183, + 137, + 49, + 27, + 33, + 8, + 18, + 73, + 65, + 0, + 25, + 54, + 26, + 0, + 128, + 18, + 103, + 101, + 116, + 95, + 97, + 100, + 100, + 114, + 101, + 115, + 115, + 95, + 97, + 112, + 112, + 105, + 100, + 115, + 18, + 16, + 65, + 0, + 4, + 136, + 13, + 154, + 137, + 50, + 4, + 33, + 5, + 15, + 65, + 0, + 134, + 49, + 22, + 35, + 9, + 140, + 0, + 139, + 0, + 56, + 16, + 35, + 18, + 73, + 65, + 0, + 8, + 139, + 0, + 56, + 32, + 50, + 3, + 18, + 16, + 73, + 65, + 0, + 8, + 139, + 0, + 56, + 9, + 50, + 3, + 18, + 16, + 73, + 65, + 0, + 20, + 139, + 0, + 56, + 8, + 50, + 0, + 15, + 73, + 64, + 0, + 8, + 139, + 0, + 56, + 1, + 50, + 0, + 13, + 17, + 16, + 73, + 65, + 0, + 6, + 139, + 0, + 136, + 10, + 195, + 16, + 65, + 0, + 61, + 49, + 27, + 33, + 5, + 18, + 73, + 65, + 0, + 18, + 54, + 26, + 0, + 128, + 11, + 114, + 101, + 109, + 111, + 118, + 101, + 95, + 97, + 100, + 100, + 114, + 18, + 16, + 73, + 65, + 0, + 10, + 49, + 22, + 35, + 9, + 56, + 7, + 49, + 0, + 18, + 16, + 65, + 0, + 16, + 54, + 26, + 1, + 23, + 33, + 9, + 39, + 16, + 49, + 0, + 136, + 15, + 123, + 66, + 0, + 1, + 0, + 49, + 22, + 136, + 10, + 125, + 65, + 0, + 113, + 49, + 27, + 33, + 8, + 18, + 73, + 65, + 0, + 19, + 54, + 26, + 0, + 128, + 12, + 109, + 105, + 103, + 114, + 97, + 116, + 101, + 95, + 110, + 97, + 109, + 101, + 18, + 16, + 65, + 0, + 4, + 136, + 12, + 255, + 137, + 49, + 27, + 33, + 8, + 18, + 73, + 65, + 0, + 22, + 54, + 26, + 0, + 128, + 15, + 109, + 105, + 103, + 114, + 97, + 116, + 101, + 95, + 97, + 100, + 100, + 114, + 101, + 115, + 115, + 18, + 16, + 65, + 0, + 10, + 54, + 26, + 2, + 54, + 26, + 1, + 136, + 13, + 7, + 137, + 49, + 27, + 33, + 5, + 18, + 73, + 65, + 0, + 17, + 54, + 26, + 0, + 128, + 10, + 115, + 119, + 101, + 101, + 112, + 95, + 100, + 117, + 115, + 116, + 18, + 16, + 65, + 0, + 4, + 136, + 15, + 50, + 137, + 0, + 0, + 137, + 136, + 0, + 2, + 35, + 67, + 138, + 0, + 0, + 137, + 41, + 54, + 26, + 2, + 73, + 21, + 33, + 4, + 18, + 68, + 54, + 26, + 1, + 87, + 2, + 0, + 136, + 0, + 4, + 80, + 176, + 35, + 67, + 138, + 2, + 1, + 139, + 254, + 139, + 255, + 136, + 15, + 65, + 139, + 255, + 136, + 16, + 239, + 137, + 41, + 136, + 0, + 4, + 80, + 176, + 35, + 67, + 138, + 0, + 1, + 40, + 50, + 7, + 129, + 244, + 3, + 136, + 18, + 190, + 140, + 0, + 139, + 0, + 22, + 139, + 0, + 136, + 9, + 14, + 22, + 80, + 128, + 8, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 20, + 80, + 52, + 201, + 80, + 128, + 8, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 28, + 80, + 128, + 8, + 0, + 0, + 0, + 0, + 0, + 152, + 150, + 128, + 80, + 128, + 60, + 48, + 48, + 48, + 48, + 48, + 48, + 48, + 48, + 48, + 48, + 48, + 48, + 48, + 48, + 48, + 48, + 48, + 48, + 48, + 48, + 48, + 48, + 48, + 48, + 48, + 48, + 48, + 46, + 48, + 48, + 48, + 48, + 48, + 48, + 48, + 48, + 48, + 48, + 48, + 48, + 48, + 48, + 48, + 48, + 48, + 48, + 48, + 48, + 48, + 48, + 48, + 48, + 48, + 48, + 48, + 46, + 97, + 108, + 103, + 111, + 136, + 0, + 20, + 22, + 80, + 140, + 0, + 137, + 41, + 54, + 26, + 1, + 87, + 2, + 0, + 136, + 0, + 5, + 22, + 80, + 176, + 35, + 67, + 138, + 1, + 1, + 40, + 73, + 33, + 13, + 34, + 71, + 3, + 33, + 8, + 35, + 136, + 18, + 132, + 33, + 11, + 9, + 140, + 0, + 129, + 89, + 139, + 255, + 21, + 8, + 33, + 5, + 136, + 18, + 199, + 140, + 1, + 139, + 0, + 139, + 1, + 8, + 136, + 9, + 59, + 8, + 140, + 0, + 70, + 1, + 137, + 41, + 54, + 26, + 1, + 73, + 21, + 33, + 4, + 18, + 68, + 136, + 0, + 4, + 80, + 176, + 35, + 67, + 138, + 1, + 1, + 39, + 5, + 21, + 33, + 4, + 8, + 35, + 136, + 18, + 153, + 22, + 139, + 255, + 136, + 8, + 196, + 22, + 80, + 137, + 41, + 54, + 26, + 3, + 73, + 21, + 35, + 18, + 68, + 34, + 83, + 54, + 26, + 2, + 73, + 21, + 33, + 4, + 18, + 68, + 54, + 26, + 1, + 87, + 2, + 0, + 49, + 22, + 35, + 9, + 73, + 56, + 16, + 35, + 18, + 68, + 136, + 0, + 5, + 22, + 80, + 176, + 35, + 67, + 138, + 4, + 1, + 40, + 71, + 17, + 139, + 255, + 56, + 7, + 50, + 10, + 18, + 68, + 33, + 4, + 73, + 18, + 68, + 139, + 253, + 50, + 3, + 19, + 68, + 177, + 37, + 178, + 16, + 34, + 178, + 1, + 39, + 8, + 73, + 178, + 30, + 178, + 31, + 33, + 6, + 178, + 25, + 179, + 139, + 254, + 136, + 13, + 238, + 140, + 0, + 34, + 140, + 1, + 50, + 3, + 140, + 2, + 139, + 0, + 53, + 255, + 52, + 255, + 34, + 83, + 65, + 0, + 81, + 177, + 37, + 178, + 16, + 34, + 178, + 1, + 39, + 8, + 73, + 178, + 30, + 178, + 31, + 33, + 6, + 178, + 25, + 179, + 139, + 0, + 139, + 254, + 136, + 15, + 48, + 136, + 14, + 254, + 140, + 1, + 139, + 1, + 34, + 19, + 68, + 39, + 17, + 139, + 1, + 136, + 15, + 51, + 39, + 9, + 18, + 65, + 0, + 21, + 139, + 1, + 128, + 10, + 105, + 46, + 115, + 101, + 108, + 108, + 101, + 114, + 46, + 97, + 101, + 68, + 140, + 2, + 66, + 0, + 11, + 139, + 255, + 56, + 0, + 139, + 1, + 42, + 101, + 68, + 18, + 68, + 49, + 0, + 139, + 0, + 139, + 254, + 136, + 15, + 51, + 53, + 255, + 52, + 255, + 87, + 0, + 8, + 23, + 140, + 3, + 139, + 3, + 34, + 13, + 68, + 139, + 254, + 136, + 254, + 202, + 140, + 4, + 34, + 140, + 5, + 139, + 252, + 65, + 0, + 39, + 49, + 0, + 136, + 254, + 252, + 140, + 6, + 139, + 6, + 87, + 0, + 8, + 23, + 140, + 5, + 139, + 4, + 139, + 6, + 87, + 0, + 8, + 23, + 139, + 6, + 87, + 8, + 8, + 23, + 8, + 8, + 140, + 4, + 49, + 0, + 139, + 253, + 18, + 68, + 33, + 14, + 139, + 255, + 56, + 8, + 139, + 4, + 9, + 11, + 139, + 3, + 10, + 33, + 13, + 15, + 68, + 43, + 190, + 68, + 140, + 7, + 39, + 6, + 43, + 190, + 68, + 80, + 140, + 8, + 39, + 10, + 139, + 7, + 80, + 190, + 68, + 140, + 9, + 139, + 8, + 189, + 68, + 140, + 10, + 50, + 12, + 129, + 200, + 1, + 12, + 65, + 0, + 19, + 177, + 37, + 178, + 16, + 34, + 178, + 1, + 39, + 8, + 73, + 178, + 30, + 178, + 31, + 33, + 6, + 178, + 25, + 179, + 129, + 20, + 50, + 7, + 139, + 255, + 56, + 8, + 139, + 4, + 9, + 139, + 3, + 136, + 18, + 166, + 140, + 11, + 177, + 37, + 178, + 16, + 34, + 178, + 25, + 139, + 8, + 34, + 33, + 10, + 186, + 178, + 64, + 139, + 8, + 33, + 10, + 139, + 10, + 33, + 10, + 9, + 186, + 178, + 64, + 139, + 9, + 178, + 31, + 34, + 178, + 52, + 33, + 13, + 178, + 53, + 33, + 8, + 178, + 56, + 128, + 4, + 13, + 202, + 82, + 193, + 178, + 26, + 139, + 254, + 73, + 21, + 22, + 87, + 6, + 2, + 76, + 80, + 178, + 26, + 52, + 201, + 178, + 26, + 139, + 253, + 178, + 26, + 139, + 255, + 56, + 8, + 139, + 4, + 9, + 22, + 178, + 26, + 139, + 11, + 22, + 178, + 26, + 52, + 202, + 178, + 26, + 52, + 203, + 22, + 178, + 26, + 50, + 3, + 178, + 26, + 39, + 4, + 178, + 26, + 139, + 1, + 22, + 178, + 26, + 139, + 2, + 178, + 26, + 34, + 178, + 1, + 179, + 180, + 61, + 140, + 12, + 180, + 61, + 114, + 8, + 72, + 140, + 13, + 136, + 7, + 34, + 140, + 14, + 177, + 35, + 178, + 16, + 139, + 255, + 56, + 8, + 139, + 4, + 9, + 139, + 14, + 8, + 139, + 5, + 8, + 178, + 8, + 139, + 13, + 178, + 7, + 34, + 178, + 1, + 179, + 177, + 37, + 178, + 16, + 128, + 4, + 6, + 223, + 46, + 91, + 178, + 26, + 139, + 12, + 178, + 24, + 139, + 254, + 136, + 16, + 131, + 73, + 21, + 22, + 87, + 6, + 2, + 76, + 80, + 178, + 26, + 128, + 62, + 0, + 60, + 116, + 101, + 109, + 112, + 108, + 97, + 116, + 101, + 45, + 105, + 112, + 102, + 115, + 58, + 47, + 47, + 123, + 105, + 112, + 102, + 115, + 99, + 105, + 100, + 58, + 49, + 58, + 100, + 97, + 103, + 45, + 112, + 98, + 58, + 114, + 101, + 115, + 101, + 114, + 118, + 101, + 58, + 115, + 104, + 97, + 50, + 45, + 50, + 53, + 54, + 125, + 47, + 110, + 102, + 100, + 46, + 106, + 115, + 111, + 110, + 178, + 26, + 34, + 178, + 1, + 179, + 180, + 62, + 23, + 140, + 15, + 34, + 139, + 12, + 139, + 15, + 139, + 254, + 136, + 9, + 182, + 139, + 1, + 34, + 19, + 65, + 0, + 110, + 139, + 1, + 136, + 17, + 181, + 65, + 0, + 65, + 139, + 1, + 39, + 7, + 101, + 68, + 128, + 4, + 50, + 46, + 49, + 50, + 18, + 68, + 177, + 37, + 178, + 16, + 34, + 178, + 25, + 139, + 1, + 178, + 24, + 128, + 20, + 117, + 112, + 100, + 97, + 116, + 101, + 95, + 115, + 101, + 103, + 109, + 101, + 110, + 116, + 95, + 99, + 111, + 117, + 110, + 116, + 178, + 26, + 139, + 254, + 178, + 26, + 139, + 12, + 22, + 178, + 26, + 34, + 178, + 1, + 179, + 66, + 0, + 37, + 177, + 37, + 178, + 16, + 128, + 4, + 13, + 38, + 197, + 145, + 178, + 26, + 139, + 1, + 178, + 24, + 139, + 254, + 73, + 21, + 22, + 87, + 6, + 2, + 76, + 80, + 178, + 26, + 139, + 12, + 22, + 178, + 26, + 34, + 178, + 1, + 179, + 136, + 252, + 35, + 140, + 16, + 177, + 37, + 178, + 16, + 128, + 4, + 254, + 57, + 209, + 27, + 178, + 26, + 139, + 12, + 178, + 24, + 139, + 16, + 87, + 8, + 8, + 23, + 22, + 178, + 26, + 34, + 178, + 1, + 179, + 180, + 59, + 35, + 9, + 197, + 58, + 87, + 4, + 0, + 140, + 17, + 128, + 4, + 53, + 197, + 148, + 24, + 40, + 40, + 128, + 2, + 0, + 226, + 139, + 12, + 22, + 136, + 18, + 71, + 139, + 254, + 73, + 21, + 22, + 87, + 6, + 2, + 76, + 80, + 136, + 18, + 71, + 139, + 3, + 22, + 136, + 18, + 52, + 139, + 255, + 56, + 8, + 139, + 4, + 9, + 22, + 136, + 18, + 41, + 139, + 4, + 22, + 136, + 18, + 35, + 52, + 201, + 136, + 18, + 30, + 139, + 255, + 56, + 0, + 136, + 18, + 23, + 139, + 253, + 136, + 18, + 18, + 139, + 11, + 22, + 136, + 18, + 12, + 139, + 17, + 87, + 0, + 8, + 23, + 22, + 136, + 18, + 2, + 139, + 17, + 87, + 8, + 32, + 136, + 17, + 250, + 139, + 17, + 87, + 40, + 8, + 23, + 22, + 136, + 17, + 240, + 139, + 17, + 87, + 48, + 32, + 136, + 17, + 232, + 139, + 17, + 87, + 80, + 8, + 23, + 22, + 136, + 17, + 222, + 72, + 80, + 80, + 176, + 139, + 252, + 65, + 0, + 71, + 177, + 37, + 178, + 16, + 128, + 4, + 120, + 244, + 39, + 17, + 178, + 26, + 139, + 12, + 178, + 24, + 40, + 40, + 128, + 2, + 0, + 4, + 39, + 11, + 73, + 21, + 22, + 87, + 6, + 2, + 76, + 80, + 136, + 17, + 191, + 49, + 0, + 73, + 21, + 22, + 87, + 6, + 2, + 76, + 80, + 136, + 17, + 178, + 72, + 80, + 128, + 2, + 0, + 2, + 76, + 80, + 178, + 26, + 34, + 178, + 1, + 179, + 49, + 0, + 139, + 12, + 139, + 254, + 136, + 0, + 31, + 139, + 12, + 140, + 0, + 70, + 17, + 137, + 54, + 26, + 3, + 73, + 21, + 33, + 4, + 18, + 68, + 54, + 26, + 2, + 23, + 54, + 26, + 1, + 87, + 2, + 0, + 136, + 0, + 2, + 35, + 67, + 138, + 3, + 0, + 40, + 73, + 139, + 253, + 136, + 15, + 127, + 140, + 0, + 139, + 254, + 42, + 101, + 68, + 140, + 1, + 139, + 254, + 139, + 255, + 136, + 15, + 145, + 68, + 139, + 254, + 114, + 8, + 72, + 139, + 253, + 18, + 65, + 0, + 9, + 49, + 0, + 139, + 1, + 18, + 68, + 66, + 0, + 6, + 49, + 0, + 139, + 253, + 18, + 68, + 139, + 253, + 39, + 11, + 139, + 254, + 136, + 4, + 212, + 68, + 139, + 254, + 139, + 0, + 136, + 5, + 56, + 20, + 65, + 0, + 8, + 139, + 254, + 139, + 0, + 136, + 5, + 131, + 68, + 39, + 5, + 39, + 11, + 139, + 254, + 136, + 5, + 253, + 137, + 54, + 26, + 3, + 73, + 21, + 33, + 4, + 18, + 68, + 54, + 26, + 2, + 23, + 54, + 26, + 1, + 87, + 2, + 0, + 136, + 0, + 2, + 35, + 67, + 138, + 3, + 0, + 40, + 73, + 139, + 254, + 42, + 101, + 68, + 140, + 0, + 139, + 254, + 139, + 255, + 136, + 15, + 36, + 68, + 39, + 12, + 139, + 254, + 136, + 11, + 78, + 136, + 6, + 183, + 20, + 65, + 0, + 16, + 49, + 0, + 139, + 0, + 18, + 73, + 64, + 0, + 6, + 49, + 0, + 139, + 253, + 18, + 17, + 68, + 139, + 253, + 39, + 5, + 139, + 254, + 136, + 4, + 99, + 68, + 139, + 253, + 136, + 14, + 212, + 140, + 1, + 139, + 254, + 139, + 1, + 136, + 8, + 68, + 68, + 139, + 1, + 189, + 76, + 72, + 20, + 65, + 0, + 36, + 177, + 35, + 178, + 16, + 139, + 1, + 21, + 36, + 8, + 35, + 136, + 13, + 178, + 178, + 8, + 49, + 0, + 178, + 7, + 128, + 9, + 98, + 111, + 120, + 82, + 101, + 102, + 117, + 110, + 100, + 178, + 5, + 34, + 178, + 1, + 179, + 49, + 0, + 139, + 253, + 39, + 5, + 139, + 254, + 136, + 5, + 218, + 137, + 54, + 26, + 2, + 23, + 54, + 26, + 1, + 87, + 2, + 0, + 136, + 0, + 2, + 35, + 67, + 138, + 2, + 0, + 40, + 139, + 254, + 139, + 255, + 136, + 1, + 201, + 68, + 139, + 254, + 139, + 254, + 42, + 101, + 68, + 136, + 14, + 128, + 140, + 0, + 139, + 0, + 189, + 76, + 72, + 20, + 68, + 139, + 0, + 139, + 255, + 191, + 137, + 54, + 26, + 4, + 73, + 21, + 33, + 4, + 18, + 68, + 54, + 26, + 3, + 73, + 21, + 33, + 4, + 18, + 68, + 54, + 26, + 2, + 23, + 54, + 26, + 1, + 87, + 2, + 0, + 136, + 0, + 2, + 35, + 67, + 138, + 4, + 0, + 40, + 73, + 139, + 253, + 139, + 252, + 18, + 65, + 0, + 1, + 137, + 139, + 254, + 139, + 255, + 136, + 14, + 73, + 68, + 139, + 254, + 39, + 7, + 101, + 68, + 128, + 3, + 51, + 46, + 51, + 18, + 65, + 0, + 9, + 49, + 22, + 136, + 3, + 103, + 68, + 66, + 0, + 9, + 49, + 0, + 139, + 254, + 114, + 8, + 72, + 18, + 68, + 139, + 254, + 139, + 253, + 136, + 14, + 18, + 140, + 0, + 139, + 254, + 139, + 252, + 136, + 14, + 9, + 140, + 1, + 139, + 0, + 188, + 139, + 1, + 139, + 255, + 191, + 137, + 54, + 26, + 3, + 73, + 21, + 33, + 4, + 18, + 68, + 54, + 26, + 2, + 23, + 54, + 26, + 1, + 87, + 2, + 0, + 136, + 0, + 2, + 35, + 67, + 138, + 3, + 0, + 40, + 139, + 254, + 139, + 255, + 136, + 13, + 233, + 68, + 139, + 254, + 42, + 101, + 68, + 140, + 0, + 139, + 254, + 114, + 8, + 72, + 139, + 253, + 18, + 65, + 0, + 9, + 49, + 0, + 139, + 0, + 18, + 68, + 66, + 0, + 6, + 49, + 0, + 139, + 253, + 18, + 68, + 139, + 254, + 54, + 26, + 3, + 136, + 13, + 157, + 136, + 6, + 148, + 128, + 4, + 81, + 114, + 207, + 1, + 40, + 40, + 128, + 2, + 0, + 42, + 139, + 254, + 22, + 136, + 15, + 110, + 139, + 255, + 73, + 21, + 22, + 87, + 6, + 2, + 76, + 80, + 136, + 15, + 110, + 139, + 253, + 136, + 15, + 92, + 72, + 80, + 80, + 176, + 137, + 41, + 54, + 26, + 1, + 87, + 2, + 0, + 136, + 0, + 12, + 73, + 21, + 22, + 87, + 6, + 2, + 76, + 80, + 80, + 176, + 35, + 67, + 138, + 1, + 1, + 40, + 71, + 5, + 139, + 255, + 136, + 0, + 217, + 140, + 0, + 139, + 0, + 42, + 101, + 68, + 140, + 1, + 139, + 0, + 39, + 18, + 101, + 68, + 139, + 255, + 18, + 68, + 49, + 0, + 139, + 1, + 18, + 68, + 139, + 0, + 39, + 12, + 101, + 76, + 72, + 68, + 43, + 190, + 68, + 140, + 2, + 139, + 0, + 39, + 7, + 101, + 68, + 139, + 2, + 19, + 68, + 39, + 6, + 43, + 190, + 68, + 80, + 140, + 3, + 39, + 10, + 139, + 2, + 80, + 190, + 68, + 140, + 4, + 139, + 3, + 189, + 68, + 140, + 5, + 177, + 37, + 178, + 16, + 128, + 4, + 23, + 71, + 64, + 91, + 178, + 26, + 33, + 7, + 178, + 25, + 139, + 0, + 178, + 24, + 139, + 2, + 73, + 21, + 22, + 87, + 6, + 2, + 76, + 80, + 178, + 26, + 139, + 3, + 34, + 33, + 10, + 186, + 178, + 64, + 139, + 3, + 33, + 10, + 139, + 5, + 33, + 10, + 9, + 186, + 178, + 64, + 139, + 4, + 178, + 31, + 34, + 178, + 1, + 179, + 139, + 2, + 140, + 0, + 70, + 5, + 137, + 41, + 54, + 26, + 2, + 23, + 54, + 26, + 1, + 87, + 2, + 0, + 136, + 0, + 10, + 39, + 13, + 34, + 79, + 2, + 84, + 80, + 176, + 35, + 67, + 138, + 2, + 1, + 40, + 139, + 255, + 136, + 12, + 155, + 140, + 0, + 139, + 0, + 189, + 76, + 72, + 20, + 65, + 0, + 10, + 139, + 254, + 139, + 255, + 136, + 12, + 100, + 66, + 0, + 7, + 139, + 254, + 139, + 255, + 136, + 12, + 171, + 140, + 0, + 137, + 41, + 54, + 26, + 1, + 87, + 2, + 0, + 136, + 0, + 5, + 22, + 80, + 176, + 35, + 67, + 138, + 1, + 1, + 40, + 73, + 139, + 255, + 136, + 12, + 99, + 140, + 0, + 139, + 0, + 189, + 76, + 72, + 20, + 65, + 0, + 4, + 34, + 66, + 0, + 17, + 139, + 0, + 190, + 68, + 140, + 1, + 139, + 1, + 21, + 33, + 9, + 18, + 68, + 139, + 1, + 36, + 91, + 140, + 0, + 70, + 1, + 137, + 41, + 54, + 26, + 1, + 73, + 21, + 33, + 4, + 18, + 68, + 136, + 0, + 14, + 73, + 21, + 36, + 10, + 22, + 87, + 6, + 2, + 76, + 80, + 80, + 176, + 35, + 67, + 138, + 1, + 1, + 40, + 71, + 4, + 40, + 140, + 0, + 139, + 255, + 136, + 12, + 31, + 140, + 1, + 139, + 1, + 189, + 76, + 72, + 20, + 65, + 0, + 5, + 139, + 0, + 66, + 0, + 53, + 139, + 1, + 190, + 68, + 140, + 2, + 34, + 140, + 3, + 139, + 3, + 139, + 2, + 21, + 12, + 65, + 0, + 33, + 139, + 2, + 139, + 3, + 36, + 88, + 23, + 140, + 4, + 139, + 4, + 34, + 19, + 65, + 0, + 8, + 139, + 0, + 139, + 4, + 22, + 80, + 140, + 0, + 139, + 3, + 36, + 8, + 140, + 3, + 66, + 255, + 214, + 139, + 0, + 140, + 0, + 70, + 4, + 137, + 54, + 26, + 3, + 87, + 2, + 0, + 54, + 26, + 2, + 23, + 54, + 26, + 1, + 87, + 2, + 0, + 136, + 0, + 2, + 35, + 67, + 138, + 3, + 0, + 49, + 22, + 136, + 1, + 13, + 68, + 39, + 6, + 139, + 255, + 80, + 139, + 254, + 185, + 72, + 39, + 10, + 139, + 255, + 80, + 139, + 253, + 191, + 137, + 54, + 26, + 3, + 87, + 2, + 0, + 54, + 26, + 2, + 23, + 54, + 26, + 1, + 87, + 2, + 0, + 136, + 0, + 2, + 35, + 67, + 138, + 3, + 0, + 49, + 22, + 136, + 0, + 221, + 68, + 39, + 6, + 139, + 255, + 80, + 139, + 254, + 139, + 253, + 187, + 137, + 54, + 26, + 1, + 87, + 2, + 0, + 136, + 0, + 2, + 35, + 67, + 138, + 1, + 0, + 49, + 22, + 136, + 0, + 190, + 68, + 43, + 139, + 255, + 191, + 137, + 41, + 54, + 26, + 1, + 23, + 136, + 0, + 5, + 22, + 80, + 176, + 35, + 67, + 138, + 1, + 1, + 40, + 71, + 2, + 52, + 204, + 128, + 2, + 116, + 115, + 101, + 68, + 140, + 0, + 52, + 204, + 128, + 8, + 100, + 101, + 99, + 105, + 109, + 97, + 108, + 115, + 101, + 68, + 140, + 1, + 52, + 204, + 128, + 5, + 112, + 114, + 105, + 99, + 101, + 101, + 68, + 140, + 2, + 50, + 7, + 139, + 0, + 9, + 33, + 15, + 13, + 65, + 0, + 34, + 33, + 5, + 140, + 1, + 129, + 33, + 140, + 2, + 128, + 23, + 111, + 114, + 97, + 99, + 108, + 101, + 32, + 62, + 50, + 52, + 104, + 114, + 32, + 117, + 115, + 105, + 110, + 103, + 32, + 46, + 51, + 51, + 99, + 176, + 139, + 255, + 33, + 16, + 11, + 139, + 1, + 136, + 9, + 136, + 11, + 139, + 2, + 10, + 33, + 16, + 10, + 33, + 16, + 11, + 140, + 0, + 70, + 2, + 137, + 41, + 54, + 26, + 1, + 73, + 21, + 33, + 4, + 18, + 68, + 136, + 0, + 5, + 22, + 80, + 176, + 35, + 67, + 138, + 1, + 1, + 40, + 139, + 255, + 136, + 10, + 200, + 140, + 0, + 139, + 0, + 189, + 76, + 72, + 20, + 65, + 0, + 12, + 139, + 0, + 21, + 36, + 8, + 35, + 136, + 9, + 178, + 66, + 0, + 3, + 129, + 128, + 25, + 140, + 0, + 137, + 138, + 1, + 1, + 139, + 255, + 56, + 0, + 52, + 200, + 112, + 0, + 72, + 35, + 18, + 73, + 65, + 0, + 8, + 139, + 255, + 56, + 9, + 50, + 3, + 18, + 16, + 73, + 65, + 0, + 8, + 139, + 255, + 56, + 32, + 50, + 3, + 18, + 16, + 137, + 138, + 0, + 1, + 34, + 71, + 3, + 35, + 34, + 73, + 136, + 9, + 35, + 137, + 138, + 3, + 1, + 139, + 255, + 136, + 11, + 27, + 65, + 0, + 49, + 177, + 37, + 178, + 16, + 139, + 255, + 178, + 24, + 128, + 19, + 105, + 115, + 95, + 97, + 100, + 100, + 114, + 101, + 115, + 115, + 95, + 105, + 110, + 95, + 102, + 105, + 101, + 108, + 100, + 178, + 26, + 139, + 254, + 178, + 26, + 139, + 253, + 178, + 26, + 34, + 178, + 1, + 179, + 180, + 62, + 23, + 35, + 18, + 137, + 177, + 37, + 178, + 16, + 128, + 4, + 212, + 67, + 149, + 42, + 178, + 26, + 139, + 255, + 178, + 24, + 139, + 254, + 73, + 21, + 22, + 87, + 6, + 2, + 76, + 80, + 178, + 26, + 139, + 253, + 178, + 26, + 34, + 178, + 1, + 179, + 180, + 59, + 35, + 9, + 197, + 58, + 87, + 4, + 0, + 34, + 83, + 137, + 138, + 2, + 1, + 40, + 71, + 3, + 139, + 254, + 34, + 19, + 68, + 139, + 255, + 189, + 76, + 72, + 20, + 65, + 0, + 4, + 34, + 66, + 0, + 57, + 139, + 255, + 190, + 68, + 140, + 0, + 139, + 0, + 140, + 1, + 139, + 0, + 21, + 36, + 10, + 140, + 2, + 34, + 140, + 3, + 139, + 3, + 139, + 2, + 12, + 65, + 0, + 28, + 139, + 1, + 139, + 3, + 36, + 11, + 36, + 88, + 23, + 139, + 254, + 18, + 65, + 0, + 4, + 35, + 66, + 0, + 10, + 139, + 3, + 35, + 8, + 140, + 3, + 66, + 255, + 220, + 34, + 140, + 0, + 70, + 3, + 137, + 138, + 2, + 1, + 40, + 71, + 3, + 139, + 255, + 189, + 76, + 72, + 20, + 65, + 0, + 10, + 139, + 255, + 139, + 254, + 22, + 191, + 35, + 66, + 0, + 102, + 139, + 255, + 190, + 68, + 140, + 0, + 139, + 0, + 21, + 36, + 10, + 140, + 1, + 34, + 140, + 2, + 139, + 2, + 139, + 1, + 12, + 65, + 0, + 51, + 139, + 0, + 139, + 2, + 36, + 11, + 91, + 140, + 3, + 139, + 3, + 34, + 18, + 65, + 0, + 14, + 139, + 255, + 139, + 2, + 36, + 11, + 139, + 254, + 22, + 187, + 35, + 66, + 0, + 48, + 139, + 3, + 139, + 254, + 18, + 65, + 0, + 4, + 35, + 66, + 0, + 36, + 139, + 2, + 35, + 8, + 140, + 2, + 66, + 255, + 197, + 139, + 0, + 21, + 129, + 240, + 7, + 12, + 65, + 0, + 16, + 139, + 255, + 188, + 139, + 255, + 139, + 0, + 139, + 254, + 22, + 80, + 191, + 35, + 66, + 0, + 1, + 34, + 140, + 0, + 70, + 3, + 137, + 138, + 3, + 1, + 139, + 255, + 136, + 9, + 213, + 65, + 0, + 54, + 177, + 37, + 178, + 16, + 139, + 255, + 178, + 24, + 128, + 24, + 114, + 101, + 103, + 95, + 97, + 100, + 100, + 95, + 118, + 101, + 114, + 105, + 102, + 105, + 101, + 100, + 95, + 97, + 100, + 100, + 114, + 101, + 115, + 115, + 178, + 26, + 139, + 254, + 178, + 26, + 139, + 253, + 178, + 26, + 34, + 178, + 1, + 179, + 180, + 62, + 23, + 35, + 18, + 137, + 177, + 37, + 178, + 16, + 128, + 4, + 133, + 204, + 237, + 87, + 178, + 26, + 139, + 255, + 178, + 24, + 139, + 254, + 73, + 21, + 22, + 87, + 6, + 2, + 76, + 80, + 178, + 26, + 139, + 253, + 73, + 21, + 22, + 87, + 6, + 2, + 76, + 80, + 178, + 26, + 34, + 178, + 1, + 179, + 180, + 59, + 35, + 9, + 197, + 58, + 87, + 4, + 0, + 34, + 83, + 137, + 138, + 4, + 1, + 139, + 255, + 136, + 9, + 92, + 65, + 0, + 57, + 177, + 37, + 178, + 16, + 139, + 255, + 178, + 24, + 128, + 27, + 114, + 101, + 103, + 95, + 114, + 101, + 109, + 111, + 118, + 101, + 95, + 118, + 101, + 114, + 105, + 102, + 105, + 101, + 100, + 95, + 97, + 100, + 100, + 114, + 101, + 115, + 115, + 178, + 26, + 139, + 254, + 178, + 26, + 139, + 253, + 178, + 26, + 34, + 178, + 1, + 179, + 180, + 62, + 23, + 35, + 18, + 137, + 177, + 37, + 178, + 16, + 128, + 4, + 177, + 137, + 10, + 117, + 178, + 26, + 139, + 255, + 178, + 24, + 139, + 254, + 73, + 21, + 22, + 87, + 6, + 2, + 76, + 80, + 178, + 26, + 139, + 253, + 178, + 26, + 139, + 252, + 178, + 26, + 34, + 178, + 1, + 179, + 180, + 59, + 35, + 9, + 197, + 58, + 87, + 4, + 0, + 34, + 83, + 137, + 138, + 1, + 1, + 139, + 255, + 34, + 18, + 65, + 0, + 2, + 34, + 137, + 50, + 7, + 139, + 255, + 13, + 137, + 138, + 0, + 0, + 54, + 26, + 1, + 136, + 251, + 174, + 22, + 176, + 137, + 138, + 0, + 0, + 40, + 54, + 26, + 1, + 136, + 8, + 24, + 140, + 0, + 139, + 0, + 189, + 76, + 72, + 20, + 65, + 0, + 3, + 40, + 176, + 137, + 139, + 0, + 190, + 68, + 176, + 137, + 138, + 0, + 0, + 40, + 54, + 26, + 2, + 23, + 54, + 26, + 1, + 136, + 7, + 199, + 68, + 54, + 26, + 2, + 23, + 128, + 7, + 105, + 46, + 97, + 115, + 97, + 105, + 100, + 101, + 68, + 140, + 0, + 139, + 0, + 40, + 19, + 68, + 35, + 54, + 26, + 2, + 23, + 139, + 0, + 23, + 54, + 26, + 1, + 136, + 0, + 114, + 137, + 138, + 2, + 0, + 40, + 71, + 3, + 139, + 255, + 136, + 7, + 197, + 189, + 76, + 72, + 65, + 0, + 1, + 137, + 128, + 8, + 97, + 100, + 100, + 114, + 101, + 115, + 115, + 47, + 139, + 254, + 80, + 136, + 7, + 32, + 140, + 0, + 40, + 140, + 1, + 34, + 140, + 2, + 139, + 2, + 33, + 9, + 12, + 65, + 0, + 62, + 39, + 16, + 139, + 2, + 136, + 9, + 80, + 80, + 140, + 3, + 139, + 0, + 54, + 50, + 0, + 139, + 3, + 99, + 76, + 72, + 65, + 0, + 13, + 139, + 1, + 139, + 0, + 139, + 3, + 98, + 80, + 140, + 1, + 66, + 0, + 17, + 139, + 1, + 21, + 34, + 13, + 65, + 0, + 8, + 139, + 255, + 136, + 7, + 109, + 139, + 1, + 191, + 137, + 139, + 2, + 35, + 8, + 140, + 2, + 66, + 255, + 186, + 137, + 138, + 4, + 0, + 40, + 139, + 252, + 20, + 65, + 0, + 7, + 139, + 255, + 136, + 0, + 33, + 20, + 68, + 139, + 255, + 136, + 7, + 63, + 140, + 0, + 139, + 254, + 68, + 139, + 253, + 68, + 139, + 0, + 189, + 76, + 72, + 20, + 68, + 139, + 0, + 139, + 254, + 22, + 139, + 253, + 22, + 80, + 191, + 137, + 138, + 1, + 1, + 40, + 39, + 14, + 139, + 255, + 80, + 136, + 6, + 149, + 140, + 0, + 139, + 0, + 54, + 50, + 0, + 97, + 20, + 65, + 0, + 4, + 34, + 66, + 0, + 10, + 139, + 0, + 54, + 50, + 0, + 39, + 15, + 99, + 76, + 72, + 140, + 0, + 137, + 138, + 2, + 1, + 40, + 71, + 4, + 139, + 255, + 190, + 68, + 140, + 0, + 139, + 254, + 34, + 19, + 68, + 139, + 0, + 21, + 33, + 9, + 15, + 68, + 139, + 0, + 34, + 91, + 139, + 254, + 18, + 65, + 0, + 4, + 35, + 66, + 0, + 84, + 139, + 0, + 21, + 36, + 10, + 140, + 1, + 34, + 140, + 2, + 34, + 140, + 3, + 139, + 3, + 139, + 1, + 12, + 65, + 0, + 29, + 139, + 0, + 139, + 3, + 36, + 11, + 91, + 139, + 254, + 18, + 65, + 0, + 7, + 139, + 3, + 140, + 2, + 66, + 0, + 9, + 139, + 3, + 35, + 8, + 140, + 3, + 66, + 255, + 219, + 139, + 2, + 34, + 19, + 68, + 139, + 0, + 34, + 91, + 140, + 4, + 139, + 0, + 34, + 139, + 254, + 22, + 93, + 140, + 0, + 139, + 255, + 139, + 0, + 139, + 2, + 36, + 11, + 139, + 4, + 22, + 93, + 191, + 35, + 140, + 0, + 70, + 4, + 137, + 138, + 2, + 1, + 40, + 71, + 2, + 139, + 255, + 190, + 68, + 140, + 0, + 139, + 0, + 21, + 36, + 10, + 140, + 1, + 34, + 140, + 2, + 139, + 2, + 139, + 1, + 12, + 65, + 0, + 70, + 139, + 0, + 139, + 2, + 36, + 11, + 91, + 139, + 254, + 18, + 65, + 0, + 48, + 139, + 2, + 139, + 1, + 35, + 9, + 18, + 65, + 0, + 25, + 139, + 255, + 188, + 139, + 2, + 34, + 13, + 65, + 0, + 11, + 139, + 255, + 139, + 0, + 34, + 139, + 2, + 36, + 11, + 88, + 191, + 35, + 66, + 0, + 23, + 139, + 255, + 139, + 2, + 36, + 11, + 39, + 4, + 187, + 35, + 66, + 0, + 10, + 139, + 2, + 35, + 8, + 140, + 2, + 66, + 255, + 178, + 34, + 140, + 0, + 70, + 2, + 137, + 138, + 3, + 1, + 139, + 254, + 34, + 139, + 253, + 82, + 139, + 255, + 22, + 80, + 139, + 254, + 139, + 253, + 36, + 8, + 139, + 254, + 21, + 82, + 80, + 137, + 138, + 3, + 1, + 40, + 71, + 2, + 139, + 255, + 139, + 254, + 98, + 140, + 0, + 139, + 0, + 21, + 36, + 10, + 140, + 1, + 34, + 140, + 2, + 139, + 2, + 139, + 1, + 12, + 65, + 0, + 41, + 139, + 0, + 139, + 2, + 36, + 11, + 91, + 139, + 253, + 18, + 65, + 0, + 19, + 139, + 255, + 139, + 254, + 139, + 2, + 36, + 11, + 139, + 0, + 34, + 136, + 255, + 173, + 102, + 35, + 66, + 0, + 10, + 139, + 2, + 35, + 8, + 140, + 2, + 66, + 255, + 207, + 34, + 140, + 0, + 70, + 2, + 137, + 138, + 4, + 1, + 40, + 34, + 140, + 0, + 139, + 0, + 139, + 253, + 12, + 65, + 0, + 31, + 139, + 252, + 139, + 254, + 139, + 0, + 136, + 7, + 87, + 80, + 139, + 255, + 136, + 255, + 148, + 65, + 0, + 4, + 35, + 66, + 0, + 10, + 139, + 0, + 35, + 8, + 140, + 0, + 66, + 255, + 217, + 34, + 140, + 0, + 137, + 138, + 0, + 0, + 40, + 73, + 50, + 10, + 115, + 0, + 72, + 140, + 0, + 50, + 10, + 115, + 1, + 72, + 140, + 1, + 139, + 0, + 139, + 1, + 13, + 65, + 0, + 33, + 177, + 35, + 178, + 16, + 139, + 0, + 139, + 1, + 9, + 178, + 8, + 54, + 26, + 1, + 178, + 7, + 128, + 9, + 115, + 119, + 101, + 101, + 112, + 68, + 117, + 115, + 116, + 178, + 5, + 34, + 178, + 1, + 179, + 137, + 138, + 1, + 1, + 40, + 71, + 6, + 139, + 255, + 21, + 140, + 0, + 139, + 0, + 37, + 15, + 68, + 139, + 255, + 139, + 0, + 33, + 6, + 9, + 33, + 6, + 88, + 128, + 5, + 46, + 97, + 108, + 103, + 111, + 18, + 68, + 39, + 13, + 34, + 73, + 84, + 39, + 4, + 80, + 39, + 4, + 80, + 140, + 1, + 34, + 140, + 2, + 34, + 140, + 3, + 34, + 140, + 4, + 34, + 140, + 5, + 139, + 5, + 139, + 0, + 33, + 7, + 9, + 12, + 65, + 0, + 153, + 139, + 255, + 139, + 5, + 85, + 140, + 6, + 139, + 6, + 129, + 46, + 18, + 65, + 0, + 81, + 139, + 2, + 35, + 8, + 140, + 2, + 139, + 2, + 35, + 18, + 65, + 0, + 25, + 139, + 5, + 140, + 4, + 139, + 3, + 35, + 15, + 73, + 65, + 0, + 6, + 139, + 3, + 33, + 17, + 14, + 16, + 68, + 34, + 140, + 3, + 66, + 0, + 40, + 139, + 2, + 33, + 5, + 18, + 65, + 0, + 31, + 139, + 3, + 35, + 15, + 73, + 65, + 0, + 6, + 139, + 3, + 33, + 17, + 14, + 16, + 73, + 65, + 0, + 9, + 139, + 5, + 139, + 0, + 33, + 6, + 9, + 18, + 16, + 68, + 66, + 0, + 1, + 0, + 66, + 0, + 48, + 139, + 6, + 129, + 97, + 15, + 73, + 65, + 0, + 6, + 139, + 6, + 129, + 122, + 14, + 16, + 73, + 64, + 0, + 16, + 139, + 6, + 129, + 48, + 15, + 73, + 65, + 0, + 6, + 139, + 6, + 129, + 57, + 14, + 16, + 17, + 65, + 0, + 9, + 139, + 3, + 35, + 8, + 140, + 3, + 66, + 0, + 1, + 0, + 139, + 5, + 35, + 8, + 140, + 5, + 66, + 255, + 92, + 139, + 2, + 35, + 18, + 65, + 0, + 39, + 139, + 1, + 53, + 255, + 52, + 255, + 34, + 73, + 84, + 140, + 1, + 139, + 1, + 53, + 255, + 52, + 255, + 35, + 139, + 4, + 22, + 93, + 140, + 1, + 139, + 1, + 53, + 255, + 52, + 255, + 39, + 4, + 92, + 9, + 140, + 1, + 66, + 0, + 44, + 139, + 1, + 53, + 255, + 52, + 255, + 34, + 35, + 84, + 140, + 1, + 139, + 1, + 53, + 255, + 52, + 255, + 35, + 139, + 3, + 22, + 93, + 140, + 1, + 139, + 1, + 53, + 255, + 52, + 255, + 129, + 9, + 139, + 0, + 33, + 6, + 9, + 139, + 3, + 9, + 22, + 93, + 140, + 1, + 139, + 1, + 140, + 0, + 70, + 6, + 137, + 138, + 1, + 1, + 40, + 73, + 139, + 255, + 136, + 3, + 242, + 140, + 0, + 139, + 0, + 189, + 76, + 72, + 20, + 65, + 0, + 4, + 34, + 66, + 0, + 17, + 139, + 0, + 190, + 68, + 140, + 1, + 139, + 1, + 21, + 33, + 9, + 18, + 68, + 139, + 1, + 36, + 91, + 140, + 0, + 70, + 1, + 137, + 138, + 2, + 1, + 139, + 255, + 139, + 254, + 53, + 255, + 52, + 255, + 87, + 9, + 8, + 23, + 139, + 255, + 21, + 82, + 137, + 138, + 2, + 1, + 139, + 255, + 139, + 254, + 101, + 76, + 72, + 20, + 65, + 0, + 2, + 40, + 137, + 139, + 255, + 139, + 254, + 101, + 68, + 137, + 138, + 2, + 1, + 139, + 255, + 139, + 254, + 101, + 76, + 72, + 20, + 65, + 0, + 2, + 34, + 137, + 139, + 255, + 139, + 254, + 101, + 68, + 23, + 137, + 138, + 3, + 1, + 40, + 71, + 19, + 136, + 239, + 17, + 140, + 0, + 139, + 254, + 53, + 255, + 52, + 255, + 34, + 83, + 65, + 0, + 110, + 139, + 254, + 139, + 255, + 136, + 255, + 160, + 136, + 255, + 110, + 140, + 2, + 139, + 2, + 34, + 19, + 68, + 34, + 140, + 3, + 39, + 17, + 139, + 2, + 136, + 255, + 160, + 39, + 9, + 18, + 65, + 0, + 49, + 128, + 17, + 105, + 46, + 115, + 101, + 103, + 109, + 101, + 110, + 116, + 80, + 114, + 105, + 99, + 101, + 85, + 115, + 100, + 139, + 2, + 136, + 255, + 153, + 140, + 3, + 139, + 3, + 139, + 0, + 87, + 0, + 8, + 23, + 12, + 65, + 0, + 8, + 139, + 0, + 87, + 0, + 8, + 23, + 140, + 3, + 66, + 0, + 8, + 139, + 0, + 87, + 0, + 8, + 23, + 140, + 3, + 139, + 3, + 139, + 0, + 87, + 0, + 8, + 23, + 15, + 68, + 139, + 3, + 136, + 247, + 191, + 140, + 1, + 66, + 0, + 112, + 139, + 254, + 53, + 255, + 52, + 255, + 87, + 1, + 8, + 23, + 140, + 4, + 34, + 140, + 5, + 139, + 4, + 33, + 6, + 15, + 65, + 0, + 8, + 129, + 216, + 4, + 140, + 5, + 66, + 0, + 65, + 139, + 4, + 33, + 7, + 18, + 65, + 0, + 8, + 129, + 176, + 9, + 140, + 5, + 66, + 0, + 49, + 139, + 4, + 33, + 8, + 18, + 65, + 0, + 8, + 129, + 184, + 23, + 140, + 5, + 66, + 0, + 33, + 139, + 4, + 33, + 5, + 18, + 65, + 0, + 8, + 129, + 168, + 70, + 140, + 5, + 66, + 0, + 17, + 139, + 4, + 35, + 18, + 65, + 0, + 9, + 129, + 140, + 246, + 1, + 140, + 5, + 66, + 0, + 1, + 0, + 50, + 7, + 139, + 5, + 136, + 0, + 249, + 140, + 6, + 139, + 6, + 136, + 247, + 76, + 140, + 1, + 139, + 255, + 136, + 246, + 36, + 140, + 7, + 34, + 140, + 8, + 34, + 140, + 9, + 139, + 7, + 34, + 19, + 65, + 0, + 151, + 139, + 253, + 139, + 7, + 42, + 101, + 68, + 18, + 140, + 10, + 39, + 12, + 139, + 7, + 136, + 254, + 207, + 140, + 11, + 139, + 11, + 136, + 250, + 52, + 73, + 65, + 0, + 4, + 139, + 10, + 20, + 16, + 65, + 0, + 116, + 35, + 140, + 8, + 35, + 140, + 9, + 139, + 0, + 87, + 64, + 8, + 23, + 136, + 247, + 4, + 140, + 12, + 139, + 1, + 140, + 13, + 50, + 7, + 140, + 14, + 139, + 11, + 139, + 0, + 87, + 56, + 8, + 23, + 33, + 18, + 11, + 33, + 18, + 11, + 129, + 24, + 11, + 8, + 140, + 15, + 139, + 14, + 139, + 11, + 13, + 68, + 139, + 14, + 139, + 15, + 15, + 65, + 0, + 7, + 139, + 13, + 140, + 1, + 66, + 0, + 50, + 139, + 14, + 139, + 11, + 9, + 140, + 16, + 139, + 15, + 139, + 11, + 9, + 140, + 17, + 139, + 12, + 139, + 13, + 9, + 140, + 18, + 139, + 18, + 139, + 16, + 11, + 139, + 17, + 10, + 140, + 19, + 139, + 12, + 139, + 19, + 9, + 140, + 1, + 139, + 1, + 139, + 13, + 12, + 65, + 0, + 4, + 139, + 13, + 140, + 1, + 139, + 1, + 129, + 192, + 132, + 61, + 15, + 68, + 139, + 1, + 22, + 139, + 7, + 34, + 18, + 65, + 0, + 8, + 139, + 255, + 136, + 237, + 245, + 66, + 0, + 1, + 34, + 22, + 80, + 39, + 13, + 34, + 139, + 7, + 34, + 19, + 84, + 35, + 139, + 9, + 84, + 33, + 5, + 139, + 8, + 84, + 80, + 140, + 0, + 70, + 19, + 137, + 41, + 54, + 26, + 2, + 23, + 54, + 26, + 1, + 23, + 136, + 0, + 5, + 22, + 80, + 176, + 35, + 67, + 138, + 2, + 1, + 40, + 71, + 3, + 139, + 254, + 33, + 19, + 12, + 65, + 0, + 5, + 139, + 255, + 66, + 0, + 46, + 139, + 254, + 33, + 19, + 9, + 140, + 0, + 139, + 0, + 129, + 128, + 231, + 132, + 15, + 10, + 140, + 1, + 139, + 1, + 34, + 18, + 65, + 0, + 5, + 139, + 255, + 66, + 0, + 17, + 129, + 102, + 139, + 1, + 149, + 140, + 2, + 140, + 3, + 139, + 255, + 139, + 2, + 11, + 129, + 100, + 10, + 140, + 0, + 70, + 3, + 137, + 138, + 1, + 1, + 40, + 73, + 33, + 12, + 139, + 255, + 149, + 140, + 0, + 140, + 1, + 139, + 0, + 140, + 0, + 70, + 1, + 137, + 138, + 7, + 1, + 40, + 33, + 11, + 140, + 0, + 139, + 0, + 139, + 255, + 33, + 11, + 11, + 8, + 140, + 0, + 139, + 0, + 139, + 254, + 33, + 11, + 11, + 8, + 140, + 0, + 139, + 0, + 139, + 253, + 33, + 11, + 11, + 8, + 140, + 0, + 139, + 0, + 139, + 252, + 33, + 20, + 11, + 8, + 140, + 0, + 139, + 0, + 139, + 250, + 33, + 20, + 11, + 8, + 140, + 0, + 139, + 0, + 139, + 251, + 33, + 21, + 11, + 8, + 140, + 0, + 139, + 0, + 139, + 249, + 33, + 21, + 11, + 8, + 140, + 0, + 139, + 0, + 140, + 0, + 137, + 138, + 2, + 1, + 129, + 196, + 19, + 139, + 255, + 11, + 139, + 254, + 129, + 144, + 3, + 11, + 8, + 137, + 138, + 1, + 1, + 139, + 255, + 21, + 33, + 4, + 14, + 65, + 0, + 3, + 139, + 255, + 137, + 139, + 255, + 34, + 33, + 4, + 39, + 19, + 21, + 9, + 82, + 39, + 19, + 80, + 137, + 138, + 2, + 1, + 40, + 139, + 254, + 140, + 0, + 139, + 255, + 33, + 22, + 15, + 65, + 0, + 25, + 139, + 255, + 33, + 23, + 26, + 33, + 22, + 25, + 22, + 87, + 7, + 1, + 139, + 255, + 129, + 7, + 145, + 136, + 255, + 220, + 140, + 0, + 66, + 0, + 11, + 139, + 255, + 33, + 23, + 26, + 22, + 87, + 7, + 1, + 140, + 0, + 139, + 254, + 139, + 0, + 80, + 140, + 0, + 137, + 138, + 1, + 1, + 40, + 139, + 255, + 136, + 255, + 187, + 137, + 138, + 1, + 1, + 40, + 128, + 47, + 5, + 32, + 1, + 1, + 128, + 8, + 1, + 2, + 3, + 4, + 5, + 6, + 7, + 8, + 23, + 53, + 0, + 49, + 24, + 52, + 0, + 18, + 49, + 16, + 129, + 6, + 18, + 16, + 49, + 25, + 34, + 18, + 49, + 25, + 129, + 0, + 18, + 17, + 16, + 64, + 0, + 1, + 0, + 34, + 67, + 38, + 1, + 140, + 0, + 139, + 0, + 37, + 54, + 50, + 0, + 22, + 93, + 140, + 0, + 139, + 0, + 139, + 255, + 21, + 136, + 255, + 173, + 80, + 139, + 255, + 80, + 140, + 0, + 128, + 7, + 80, + 114, + 111, + 103, + 114, + 97, + 109, + 139, + 0, + 80, + 3, + 140, + 0, + 137, + 138, + 2, + 1, + 40, + 39, + 14, + 139, + 255, + 80, + 136, + 255, + 149, + 140, + 0, + 139, + 0, + 54, + 50, + 0, + 39, + 15, + 99, + 76, + 72, + 68, + 139, + 0, + 39, + 15, + 98, + 139, + 254, + 22, + 18, + 140, + 0, + 137, + 138, + 1, + 1, + 39, + 14, + 139, + 255, + 80, + 1, + 137, + 138, + 1, + 1, + 128, + 10, + 97, + 100, + 100, + 114, + 47, + 97, + 108, + 103, + 111, + 47, + 139, + 255, + 80, + 1, + 137, + 138, + 2, + 1, + 128, + 1, + 79, + 139, + 255, + 139, + 254, + 22, + 80, + 80, + 137, + 138, + 2, + 1, + 40, + 71, + 2, + 139, + 255, + 136, + 255, + 201, + 140, + 0, + 139, + 0, + 190, + 68, + 140, + 1, + 139, + 0, + 189, + 68, + 140, + 2, + 139, + 0, + 189, + 76, + 72, + 20, + 65, + 0, + 4, + 34, + 66, + 0, + 48, + 139, + 2, + 33, + 9, + 19, + 65, + 0, + 4, + 34, + 66, + 0, + 36, + 139, + 255, + 21, + 33, + 6, + 12, + 65, + 0, + 4, + 34, + 66, + 0, + 23, + 139, + 254, + 39, + 18, + 101, + 68, + 139, + 255, + 19, + 65, + 0, + 4, + 34, + 66, + 0, + 7, + 139, + 1, + 36, + 91, + 139, + 254, + 18, + 140, + 0, + 70, + 2, + 137, + 138, + 4, + 1, + 40, + 73, + 33, + 14, + 139, + 254, + 11, + 139, + 255, + 10, + 140, + 0, + 139, + 253, + 139, + 0, + 33, + 15, + 11, + 8, + 140, + 1, + 139, + 1, + 50, + 7, + 33, + 14, + 139, + 252, + 11, + 33, + 15, + 11, + 8, + 14, + 68, + 139, + 1, + 140, + 0, + 70, + 1, + 137, + 138, + 1, + 1, + 40, + 139, + 255, + 39, + 7, + 101, + 68, + 87, + 0, + 2, + 140, + 0, + 139, + 0, + 128, + 2, + 49, + 46, + 18, + 73, + 64, + 0, + 8, + 139, + 0, + 128, + 2, + 50, + 46, + 18, + 17, + 140, + 0, + 137, + 35, + 67, + 128, + 4, + 184, + 68, + 123, + 54, + 54, + 26, + 0, + 142, + 1, + 255, + 241, + 0, + 128, + 4, + 49, + 114, + 202, + 157, + 128, + 4, + 255, + 194, + 48, + 60, + 128, + 4, + 112, + 59, + 140, + 231, + 128, + 4, + 32, + 224, + 46, + 119, + 128, + 4, + 126, + 20, + 182, + 211, + 128, + 4, + 62, + 142, + 75, + 118, + 128, + 4, + 148, + 15, + 164, + 113, + 128, + 4, + 149, + 216, + 245, + 204, + 128, + 4, + 210, + 89, + 143, + 2, + 128, + 4, + 242, + 44, + 87, + 242, + 128, + 4, + 214, + 113, + 21, + 91, + 128, + 4, + 22, + 237, + 106, + 94, + 128, + 4, + 75, + 226, + 47, + 198, + 128, + 4, + 237, + 131, + 21, + 67, + 128, + 4, + 255, + 235, + 149, + 85, + 128, + 4, + 44, + 77, + 200, + 176, + 128, + 4, + 243, + 137, + 168, + 204, + 128, + 4, + 47, + 48, + 180, + 133, + 128, + 4, + 161, + 104, + 8, + 1, + 128, + 4, + 79, + 99, + 255, + 246, + 128, + 4, + 140, + 200, + 93, + 173, + 54, + 26, + 0, + 142, + 21, + 233, + 192, + 233, + 201, + 233, + 240, + 234, + 122, + 234, + 185, + 234, + 224, + 238, + 209, + 239, + 69, + 239, + 225, + 240, + 21, + 240, + 136, + 241, + 1, + 241, + 172, + 241, + 236, + 242, + 42, + 242, + 157, + 242, + 205, + 242, + 246, + 243, + 15, + 243, + 143, + 252, + 177, + 136, + 231, + 116, + 35, + 67, + 128, + 4, + 70, + 247, + 101, + 51, + 54, + 26, + 0, + 142, + 1, + 231, + 82, + 136, + 231, + 98, + 35, + 67, + 138, + 1, + 1, + 128, + 10, + 48, + 49, + 50, + 51, + 52, + 53, + 54, + 55, + 56, + 57, + 139, + 255, + 35, + 88, + 137, + 138, + 1, + 1, + 139, + 255, + 34, + 18, + 65, + 0, + 3, + 39, + 9, + 137, + 139, + 255, + 33, + 12, + 10, + 34, + 13, + 65, + 0, + 11, + 139, + 255, + 33, + 12, + 10, + 136, + 255, + 225, + 66, + 0, + 1, + 40, + 139, + 255, + 33, + 12, + 24, + 136, + 255, + 193, + 80, + 137, + 138, + 4, + 3, + 139, + 252, + 139, + 255, + 80, + 139, + 253, + 139, + 254, + 137, + 138, + 4, + 3, + 139, + 252, + 139, + 254, + 80, + 140, + 252, + 139, + 255, + 73, + 21, + 139, + 254, + 23, + 8, + 22, + 87, + 6, + 2, + 140, + 254, + 139, + 253, + 76, + 80, + 140, + 253, + 139, + 252, + 139, + 253, + 139, + 254, + 137 + ], + "args": [ + [ + 116, + 101, + 97, + 108, + 115, + 99, + 114, + 105, + 112, + 116, + 45, + 100, + 117, + 109, + 109, + 121 + ] + ], + "clearStateProgram": [ + 10 + ], + "onComplete": "UpdateApplication" + }, + "fee": 1000, + "firstValid": 43679851, + "genesisHash": [ + 72, + 99, + 181, + 24, + 164, + 179, + 200, + 78, + 200, + 16, + 242, + 45, + 79, + 16, + 129, + 203, + 15, + 113, + 240, + 89, + 167, + 172, + 32, + 222, + 198, + 47, + 127, + 112, + 229, + 9, + 58, + 34 + ], + "genesisId": "testnet-v1.0", + "lastValid": 43679951, + "note": [ + 78, + 70, + 68, + 32, + 82, + 101, + 103, + 105, + 115, + 116, + 114, + 121, + 32, + 67, + 111, + 110, + 116, + 114, + 97, + 99, + 116, + 58, + 87, + 83, + 79, + 84, + 82, + 74, + 88, + 76, + 89, + 66, + 81, + 89, + 86, + 77, + 70, + 76, + 79, + 73, + 76, + 89, + 86, + 85, + 83, + 78, + 73, + 87, + 75, + 66, + 87, + 85, + 66, + 87, + 51, + 71, + 78, + 85, + 87, + 65, + 70, + 75, + 71, + 75, + 72, + 78, + 75, + 78, + 82, + 88, + 54, + 54, + 78, + 69, + 90, + 73, + 84, + 85, + 76, + 77 + ], + "sender": "3Y62HTJ4WYSIEKC74XE3F2JFCS7774EN3CYNUHQCEFIN7QBYFAWLKE5MFY", + "transactionType": "AppCall" + }, + "unsignedBytes": [ + 84, + 88, + 141, + 164, + 97, + 112, + 97, + 97, + 145, + 196, + 16, + 116, + 101, + 97, + 108, + 115, + 99, + 114, + 105, + 112, + 116, + 45, + 100, + 117, + 109, + 109, + 121, + 164, + 97, + 112, + 97, + 110, + 4, + 164, + 97, + 112, + 97, + 112, + 197, + 26, + 142, + 10, + 32, + 24, + 0, + 1, + 8, + 6, + 32, + 2, + 5, + 4, + 3, + 16, + 128, + 32, + 160, + 141, + 6, + 10, + 30, + 237, + 2, + 128, + 163, + 5, + 144, + 78, + 27, + 60, + 128, + 212, + 141, + 190, + 202, + 16, + 212, + 222, + 1, + 208, + 134, + 3, + 128, + 1, + 255, + 1, + 38, + 20, + 0, + 4, + 21, + 31, + 124, + 117, + 9, + 105, + 46, + 111, + 119, + 110, + 101, + 114, + 46, + 97, + 7, + 99, + 117, + 114, + 114, + 101, + 110, + 116, + 8, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 13, + 118, + 46, + 99, + 97, + 65, + 108, + 103, + 111, + 46, + 48, + 46, + 97, + 115, + 11, + 99, + 111, + 110, + 116, + 114, + 97, + 99, + 116, + 58, + 65, + 58, + 5, + 105, + 46, + 118, + 101, + 114, + 3, + 10, + 129, + 1, + 1, + 48, + 11, + 99, + 111, + 110, + 116, + 114, + 97, + 99, + 116, + 58, + 67, + 58, + 12, + 117, + 46, + 99, + 97, + 118, + 46, + 97, + 108, + 103, + 111, + 46, + 97, + 16, + 105, + 46, + 101, + 120, + 112, + 105, + 114, + 97, + 116, + 105, + 111, + 110, + 84, + 105, + 109, + 101, + 1, + 0, + 5, + 110, + 97, + 109, + 101, + 47, + 7, + 105, + 46, + 97, + 112, + 112, + 105, + 100, + 6, + 105, + 46, + 97, + 112, + 112, + 115, + 15, + 105, + 46, + 115, + 101, + 103, + 109, + 101, + 110, + 116, + 76, + 111, + 99, + 107, + 101, + 100, + 6, + 105, + 46, + 110, + 97, + 109, + 101, + 7, + 46, + 46, + 46, + 97, + 108, + 103, + 111, + 128, + 8, + 0, + 0, + 0, + 0, + 7, + 1, + 163, + 144, + 23, + 53, + 204, + 128, + 8, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 50, + 23, + 53, + 203, + 128, + 32, + 140, + 192, + 44, + 36, + 6, + 26, + 39, + 87, + 142, + 136, + 93, + 94, + 83, + 159, + 168, + 35, + 71, + 123, + 171, + 202, + 213, + 25, + 64, + 50, + 84, + 80, + 201, + 214, + 220, + 200, + 26, + 116, + 53, + 202, + 128, + 32, + 254, + 115, + 101, + 249, + 131, + 173, + 194, + 235, + 65, + 228, + 41, + 1, + 8, + 109, + 106, + 175, + 251, + 215, + 53, + 172, + 16, + 84, + 237, + 88, + 59, + 48, + 34, + 94, + 151, + 72, + 133, + 83, + 53, + 201, + 128, + 8, + 0, + 0, + 0, + 0, + 5, + 7, + 85, + 184, + 23, + 53, + 200, + 49, + 24, + 20, + 37, + 11, + 49, + 25, + 8, + 141, + 12, + 23, + 240, + 0, + 0, + 0, + 0, + 0, + 0, + 24, + 162, + 0, + 0, + 23, + 226, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 136, + 0, + 2, + 35, + 67, + 138, + 0, + 0, + 49, + 0, + 54, + 50, + 0, + 114, + 7, + 72, + 18, + 68, + 137, + 138, + 0, + 0, + 40, + 49, + 25, + 33, + 7, + 18, + 65, + 0, + 4, + 136, + 255, + 227, + 137, + 49, + 32, + 50, + 3, + 18, + 68, + 54, + 26, + 0, + 128, + 3, + 103, + 97, + 115, + 18, + 65, + 0, + 1, + 137, + 49, + 27, + 33, + 8, + 18, + 73, + 65, + 0, + 25, + 54, + 26, + 0, + 128, + 18, + 105, + 115, + 95, + 118, + 97, + 108, + 105, + 100, + 95, + 110, + 102, + 100, + 95, + 97, + 112, + 112, + 105, + 100, + 18, + 16, + 65, + 0, + 21, + 54, + 26, + 2, + 23, + 54, + 26, + 1, + 136, + 9, + 251, + 65, + 0, + 4, + 35, + 66, + 0, + 1, + 34, + 22, + 176, + 137, + 49, + 27, + 33, + 7, + 18, + 73, + 65, + 0, + 22, + 54, + 26, + 0, + 128, + 15, + 118, + 101, + 114, + 105, + 102, + 121, + 95, + 110, + 102, + 100, + 95, + 97, + 100, + 100, + 114, + 18, + 16, + 65, + 0, + 14, + 54, + 26, + 3, + 54, + 26, + 2, + 23, + 54, + 26, + 1, + 136, + 6, + 230, + 137, + 49, + 27, + 33, + 7, + 18, + 73, + 65, + 0, + 22, + 54, + 26, + 0, + 128, + 15, + 117, + 110, + 108, + 105, + 110, + 107, + 95, + 110, + 102, + 100, + 95, + 97, + 100, + 100, + 114, + 18, + 16, + 65, + 0, + 14, + 54, + 26, + 3, + 54, + 26, + 2, + 23, + 54, + 26, + 1, + 136, + 7, + 42, + 137, + 49, + 27, + 33, + 7, + 18, + 73, + 65, + 0, + 27, + 54, + 26, + 0, + 128, + 20, + 115, + 101, + 116, + 95, + 97, + 100, + 100, + 114, + 95, + 112, + 114, + 105, + 109, + 97, + 114, + 121, + 95, + 110, + 102, + 100, + 18, + 16, + 65, + 0, + 14, + 54, + 26, + 3, + 54, + 26, + 2, + 23, + 54, + 26, + 1, + 136, + 8, + 56, + 137, + 49, + 27, + 33, + 5, + 18, + 73, + 65, + 0, + 21, + 54, + 26, + 0, + 128, + 14, + 103, + 101, + 116, + 95, + 110, + 97, + 109, + 101, + 95, + 97, + 112, + 112, + 105, + 100, + 18, + 16, + 65, + 0, + 4, + 136, + 13, + 183, + 137, + 49, + 27, + 33, + 8, + 18, + 73, + 65, + 0, + 25, + 54, + 26, + 0, + 128, + 18, + 103, + 101, + 116, + 95, + 97, + 100, + 100, + 114, + 101, + 115, + 115, + 95, + 97, + 112, + 112, + 105, + 100, + 115, + 18, + 16, + 65, + 0, + 4, + 136, + 13, + 154, + 137, + 50, + 4, + 33, + 5, + 15, + 65, + 0, + 134, + 49, + 22, + 35, + 9, + 140, + 0, + 139, + 0, + 56, + 16, + 35, + 18, + 73, + 65, + 0, + 8, + 139, + 0, + 56, + 32, + 50, + 3, + 18, + 16, + 73, + 65, + 0, + 8, + 139, + 0, + 56, + 9, + 50, + 3, + 18, + 16, + 73, + 65, + 0, + 20, + 139, + 0, + 56, + 8, + 50, + 0, + 15, + 73, + 64, + 0, + 8, + 139, + 0, + 56, + 1, + 50, + 0, + 13, + 17, + 16, + 73, + 65, + 0, + 6, + 139, + 0, + 136, + 10, + 195, + 16, + 65, + 0, + 61, + 49, + 27, + 33, + 5, + 18, + 73, + 65, + 0, + 18, + 54, + 26, + 0, + 128, + 11, + 114, + 101, + 109, + 111, + 118, + 101, + 95, + 97, + 100, + 100, + 114, + 18, + 16, + 73, + 65, + 0, + 10, + 49, + 22, + 35, + 9, + 56, + 7, + 49, + 0, + 18, + 16, + 65, + 0, + 16, + 54, + 26, + 1, + 23, + 33, + 9, + 39, + 16, + 49, + 0, + 136, + 15, + 123, + 66, + 0, + 1, + 0, + 49, + 22, + 136, + 10, + 125, + 65, + 0, + 113, + 49, + 27, + 33, + 8, + 18, + 73, + 65, + 0, + 19, + 54, + 26, + 0, + 128, + 12, + 109, + 105, + 103, + 114, + 97, + 116, + 101, + 95, + 110, + 97, + 109, + 101, + 18, + 16, + 65, + 0, + 4, + 136, + 12, + 255, + 137, + 49, + 27, + 33, + 8, + 18, + 73, + 65, + 0, + 22, + 54, + 26, + 0, + 128, + 15, + 109, + 105, + 103, + 114, + 97, + 116, + 101, + 95, + 97, + 100, + 100, + 114, + 101, + 115, + 115, + 18, + 16, + 65, + 0, + 10, + 54, + 26, + 2, + 54, + 26, + 1, + 136, + 13, + 7, + 137, + 49, + 27, + 33, + 5, + 18, + 73, + 65, + 0, + 17, + 54, + 26, + 0, + 128, + 10, + 115, + 119, + 101, + 101, + 112, + 95, + 100, + 117, + 115, + 116, + 18, + 16, + 65, + 0, + 4, + 136, + 15, + 50, + 137, + 0, + 0, + 137, + 136, + 0, + 2, + 35, + 67, + 138, + 0, + 0, + 137, + 41, + 54, + 26, + 2, + 73, + 21, + 33, + 4, + 18, + 68, + 54, + 26, + 1, + 87, + 2, + 0, + 136, + 0, + 4, + 80, + 176, + 35, + 67, + 138, + 2, + 1, + 139, + 254, + 139, + 255, + 136, + 15, + 65, + 139, + 255, + 136, + 16, + 239, + 137, + 41, + 136, + 0, + 4, + 80, + 176, + 35, + 67, + 138, + 0, + 1, + 40, + 50, + 7, + 129, + 244, + 3, + 136, + 18, + 190, + 140, + 0, + 139, + 0, + 22, + 139, + 0, + 136, + 9, + 14, + 22, + 80, + 128, + 8, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 20, + 80, + 52, + 201, + 80, + 128, + 8, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 28, + 80, + 128, + 8, + 0, + 0, + 0, + 0, + 0, + 152, + 150, + 128, + 80, + 128, + 60, + 48, + 48, + 48, + 48, + 48, + 48, + 48, + 48, + 48, + 48, + 48, + 48, + 48, + 48, + 48, + 48, + 48, + 48, + 48, + 48, + 48, + 48, + 48, + 48, + 48, + 48, + 48, + 46, + 48, + 48, + 48, + 48, + 48, + 48, + 48, + 48, + 48, + 48, + 48, + 48, + 48, + 48, + 48, + 48, + 48, + 48, + 48, + 48, + 48, + 48, + 48, + 48, + 48, + 48, + 48, + 46, + 97, + 108, + 103, + 111, + 136, + 0, + 20, + 22, + 80, + 140, + 0, + 137, + 41, + 54, + 26, + 1, + 87, + 2, + 0, + 136, + 0, + 5, + 22, + 80, + 176, + 35, + 67, + 138, + 1, + 1, + 40, + 73, + 33, + 13, + 34, + 71, + 3, + 33, + 8, + 35, + 136, + 18, + 132, + 33, + 11, + 9, + 140, + 0, + 129, + 89, + 139, + 255, + 21, + 8, + 33, + 5, + 136, + 18, + 199, + 140, + 1, + 139, + 0, + 139, + 1, + 8, + 136, + 9, + 59, + 8, + 140, + 0, + 70, + 1, + 137, + 41, + 54, + 26, + 1, + 73, + 21, + 33, + 4, + 18, + 68, + 136, + 0, + 4, + 80, + 176, + 35, + 67, + 138, + 1, + 1, + 39, + 5, + 21, + 33, + 4, + 8, + 35, + 136, + 18, + 153, + 22, + 139, + 255, + 136, + 8, + 196, + 22, + 80, + 137, + 41, + 54, + 26, + 3, + 73, + 21, + 35, + 18, + 68, + 34, + 83, + 54, + 26, + 2, + 73, + 21, + 33, + 4, + 18, + 68, + 54, + 26, + 1, + 87, + 2, + 0, + 49, + 22, + 35, + 9, + 73, + 56, + 16, + 35, + 18, + 68, + 136, + 0, + 5, + 22, + 80, + 176, + 35, + 67, + 138, + 4, + 1, + 40, + 71, + 17, + 139, + 255, + 56, + 7, + 50, + 10, + 18, + 68, + 33, + 4, + 73, + 18, + 68, + 139, + 253, + 50, + 3, + 19, + 68, + 177, + 37, + 178, + 16, + 34, + 178, + 1, + 39, + 8, + 73, + 178, + 30, + 178, + 31, + 33, + 6, + 178, + 25, + 179, + 139, + 254, + 136, + 13, + 238, + 140, + 0, + 34, + 140, + 1, + 50, + 3, + 140, + 2, + 139, + 0, + 53, + 255, + 52, + 255, + 34, + 83, + 65, + 0, + 81, + 177, + 37, + 178, + 16, + 34, + 178, + 1, + 39, + 8, + 73, + 178, + 30, + 178, + 31, + 33, + 6, + 178, + 25, + 179, + 139, + 0, + 139, + 254, + 136, + 15, + 48, + 136, + 14, + 254, + 140, + 1, + 139, + 1, + 34, + 19, + 68, + 39, + 17, + 139, + 1, + 136, + 15, + 51, + 39, + 9, + 18, + 65, + 0, + 21, + 139, + 1, + 128, + 10, + 105, + 46, + 115, + 101, + 108, + 108, + 101, + 114, + 46, + 97, + 101, + 68, + 140, + 2, + 66, + 0, + 11, + 139, + 255, + 56, + 0, + 139, + 1, + 42, + 101, + 68, + 18, + 68, + 49, + 0, + 139, + 0, + 139, + 254, + 136, + 15, + 51, + 53, + 255, + 52, + 255, + 87, + 0, + 8, + 23, + 140, + 3, + 139, + 3, + 34, + 13, + 68, + 139, + 254, + 136, + 254, + 202, + 140, + 4, + 34, + 140, + 5, + 139, + 252, + 65, + 0, + 39, + 49, + 0, + 136, + 254, + 252, + 140, + 6, + 139, + 6, + 87, + 0, + 8, + 23, + 140, + 5, + 139, + 4, + 139, + 6, + 87, + 0, + 8, + 23, + 139, + 6, + 87, + 8, + 8, + 23, + 8, + 8, + 140, + 4, + 49, + 0, + 139, + 253, + 18, + 68, + 33, + 14, + 139, + 255, + 56, + 8, + 139, + 4, + 9, + 11, + 139, + 3, + 10, + 33, + 13, + 15, + 68, + 43, + 190, + 68, + 140, + 7, + 39, + 6, + 43, + 190, + 68, + 80, + 140, + 8, + 39, + 10, + 139, + 7, + 80, + 190, + 68, + 140, + 9, + 139, + 8, + 189, + 68, + 140, + 10, + 50, + 12, + 129, + 200, + 1, + 12, + 65, + 0, + 19, + 177, + 37, + 178, + 16, + 34, + 178, + 1, + 39, + 8, + 73, + 178, + 30, + 178, + 31, + 33, + 6, + 178, + 25, + 179, + 129, + 20, + 50, + 7, + 139, + 255, + 56, + 8, + 139, + 4, + 9, + 139, + 3, + 136, + 18, + 166, + 140, + 11, + 177, + 37, + 178, + 16, + 34, + 178, + 25, + 139, + 8, + 34, + 33, + 10, + 186, + 178, + 64, + 139, + 8, + 33, + 10, + 139, + 10, + 33, + 10, + 9, + 186, + 178, + 64, + 139, + 9, + 178, + 31, + 34, + 178, + 52, + 33, + 13, + 178, + 53, + 33, + 8, + 178, + 56, + 128, + 4, + 13, + 202, + 82, + 193, + 178, + 26, + 139, + 254, + 73, + 21, + 22, + 87, + 6, + 2, + 76, + 80, + 178, + 26, + 52, + 201, + 178, + 26, + 139, + 253, + 178, + 26, + 139, + 255, + 56, + 8, + 139, + 4, + 9, + 22, + 178, + 26, + 139, + 11, + 22, + 178, + 26, + 52, + 202, + 178, + 26, + 52, + 203, + 22, + 178, + 26, + 50, + 3, + 178, + 26, + 39, + 4, + 178, + 26, + 139, + 1, + 22, + 178, + 26, + 139, + 2, + 178, + 26, + 34, + 178, + 1, + 179, + 180, + 61, + 140, + 12, + 180, + 61, + 114, + 8, + 72, + 140, + 13, + 136, + 7, + 34, + 140, + 14, + 177, + 35, + 178, + 16, + 139, + 255, + 56, + 8, + 139, + 4, + 9, + 139, + 14, + 8, + 139, + 5, + 8, + 178, + 8, + 139, + 13, + 178, + 7, + 34, + 178, + 1, + 179, + 177, + 37, + 178, + 16, + 128, + 4, + 6, + 223, + 46, + 91, + 178, + 26, + 139, + 12, + 178, + 24, + 139, + 254, + 136, + 16, + 131, + 73, + 21, + 22, + 87, + 6, + 2, + 76, + 80, + 178, + 26, + 128, + 62, + 0, + 60, + 116, + 101, + 109, + 112, + 108, + 97, + 116, + 101, + 45, + 105, + 112, + 102, + 115, + 58, + 47, + 47, + 123, + 105, + 112, + 102, + 115, + 99, + 105, + 100, + 58, + 49, + 58, + 100, + 97, + 103, + 45, + 112, + 98, + 58, + 114, + 101, + 115, + 101, + 114, + 118, + 101, + 58, + 115, + 104, + 97, + 50, + 45, + 50, + 53, + 54, + 125, + 47, + 110, + 102, + 100, + 46, + 106, + 115, + 111, + 110, + 178, + 26, + 34, + 178, + 1, + 179, + 180, + 62, + 23, + 140, + 15, + 34, + 139, + 12, + 139, + 15, + 139, + 254, + 136, + 9, + 182, + 139, + 1, + 34, + 19, + 65, + 0, + 110, + 139, + 1, + 136, + 17, + 181, + 65, + 0, + 65, + 139, + 1, + 39, + 7, + 101, + 68, + 128, + 4, + 50, + 46, + 49, + 50, + 18, + 68, + 177, + 37, + 178, + 16, + 34, + 178, + 25, + 139, + 1, + 178, + 24, + 128, + 20, + 117, + 112, + 100, + 97, + 116, + 101, + 95, + 115, + 101, + 103, + 109, + 101, + 110, + 116, + 95, + 99, + 111, + 117, + 110, + 116, + 178, + 26, + 139, + 254, + 178, + 26, + 139, + 12, + 22, + 178, + 26, + 34, + 178, + 1, + 179, + 66, + 0, + 37, + 177, + 37, + 178, + 16, + 128, + 4, + 13, + 38, + 197, + 145, + 178, + 26, + 139, + 1, + 178, + 24, + 139, + 254, + 73, + 21, + 22, + 87, + 6, + 2, + 76, + 80, + 178, + 26, + 139, + 12, + 22, + 178, + 26, + 34, + 178, + 1, + 179, + 136, + 252, + 35, + 140, + 16, + 177, + 37, + 178, + 16, + 128, + 4, + 254, + 57, + 209, + 27, + 178, + 26, + 139, + 12, + 178, + 24, + 139, + 16, + 87, + 8, + 8, + 23, + 22, + 178, + 26, + 34, + 178, + 1, + 179, + 180, + 59, + 35, + 9, + 197, + 58, + 87, + 4, + 0, + 140, + 17, + 128, + 4, + 53, + 197, + 148, + 24, + 40, + 40, + 128, + 2, + 0, + 226, + 139, + 12, + 22, + 136, + 18, + 71, + 139, + 254, + 73, + 21, + 22, + 87, + 6, + 2, + 76, + 80, + 136, + 18, + 71, + 139, + 3, + 22, + 136, + 18, + 52, + 139, + 255, + 56, + 8, + 139, + 4, + 9, + 22, + 136, + 18, + 41, + 139, + 4, + 22, + 136, + 18, + 35, + 52, + 201, + 136, + 18, + 30, + 139, + 255, + 56, + 0, + 136, + 18, + 23, + 139, + 253, + 136, + 18, + 18, + 139, + 11, + 22, + 136, + 18, + 12, + 139, + 17, + 87, + 0, + 8, + 23, + 22, + 136, + 18, + 2, + 139, + 17, + 87, + 8, + 32, + 136, + 17, + 250, + 139, + 17, + 87, + 40, + 8, + 23, + 22, + 136, + 17, + 240, + 139, + 17, + 87, + 48, + 32, + 136, + 17, + 232, + 139, + 17, + 87, + 80, + 8, + 23, + 22, + 136, + 17, + 222, + 72, + 80, + 80, + 176, + 139, + 252, + 65, + 0, + 71, + 177, + 37, + 178, + 16, + 128, + 4, + 120, + 244, + 39, + 17, + 178, + 26, + 139, + 12, + 178, + 24, + 40, + 40, + 128, + 2, + 0, + 4, + 39, + 11, + 73, + 21, + 22, + 87, + 6, + 2, + 76, + 80, + 136, + 17, + 191, + 49, + 0, + 73, + 21, + 22, + 87, + 6, + 2, + 76, + 80, + 136, + 17, + 178, + 72, + 80, + 128, + 2, + 0, + 2, + 76, + 80, + 178, + 26, + 34, + 178, + 1, + 179, + 49, + 0, + 139, + 12, + 139, + 254, + 136, + 0, + 31, + 139, + 12, + 140, + 0, + 70, + 17, + 137, + 54, + 26, + 3, + 73, + 21, + 33, + 4, + 18, + 68, + 54, + 26, + 2, + 23, + 54, + 26, + 1, + 87, + 2, + 0, + 136, + 0, + 2, + 35, + 67, + 138, + 3, + 0, + 40, + 73, + 139, + 253, + 136, + 15, + 127, + 140, + 0, + 139, + 254, + 42, + 101, + 68, + 140, + 1, + 139, + 254, + 139, + 255, + 136, + 15, + 145, + 68, + 139, + 254, + 114, + 8, + 72, + 139, + 253, + 18, + 65, + 0, + 9, + 49, + 0, + 139, + 1, + 18, + 68, + 66, + 0, + 6, + 49, + 0, + 139, + 253, + 18, + 68, + 139, + 253, + 39, + 11, + 139, + 254, + 136, + 4, + 212, + 68, + 139, + 254, + 139, + 0, + 136, + 5, + 56, + 20, + 65, + 0, + 8, + 139, + 254, + 139, + 0, + 136, + 5, + 131, + 68, + 39, + 5, + 39, + 11, + 139, + 254, + 136, + 5, + 253, + 137, + 54, + 26, + 3, + 73, + 21, + 33, + 4, + 18, + 68, + 54, + 26, + 2, + 23, + 54, + 26, + 1, + 87, + 2, + 0, + 136, + 0, + 2, + 35, + 67, + 138, + 3, + 0, + 40, + 73, + 139, + 254, + 42, + 101, + 68, + 140, + 0, + 139, + 254, + 139, + 255, + 136, + 15, + 36, + 68, + 39, + 12, + 139, + 254, + 136, + 11, + 78, + 136, + 6, + 183, + 20, + 65, + 0, + 16, + 49, + 0, + 139, + 0, + 18, + 73, + 64, + 0, + 6, + 49, + 0, + 139, + 253, + 18, + 17, + 68, + 139, + 253, + 39, + 5, + 139, + 254, + 136, + 4, + 99, + 68, + 139, + 253, + 136, + 14, + 212, + 140, + 1, + 139, + 254, + 139, + 1, + 136, + 8, + 68, + 68, + 139, + 1, + 189, + 76, + 72, + 20, + 65, + 0, + 36, + 177, + 35, + 178, + 16, + 139, + 1, + 21, + 36, + 8, + 35, + 136, + 13, + 178, + 178, + 8, + 49, + 0, + 178, + 7, + 128, + 9, + 98, + 111, + 120, + 82, + 101, + 102, + 117, + 110, + 100, + 178, + 5, + 34, + 178, + 1, + 179, + 49, + 0, + 139, + 253, + 39, + 5, + 139, + 254, + 136, + 5, + 218, + 137, + 54, + 26, + 2, + 23, + 54, + 26, + 1, + 87, + 2, + 0, + 136, + 0, + 2, + 35, + 67, + 138, + 2, + 0, + 40, + 139, + 254, + 139, + 255, + 136, + 1, + 201, + 68, + 139, + 254, + 139, + 254, + 42, + 101, + 68, + 136, + 14, + 128, + 140, + 0, + 139, + 0, + 189, + 76, + 72, + 20, + 68, + 139, + 0, + 139, + 255, + 191, + 137, + 54, + 26, + 4, + 73, + 21, + 33, + 4, + 18, + 68, + 54, + 26, + 3, + 73, + 21, + 33, + 4, + 18, + 68, + 54, + 26, + 2, + 23, + 54, + 26, + 1, + 87, + 2, + 0, + 136, + 0, + 2, + 35, + 67, + 138, + 4, + 0, + 40, + 73, + 139, + 253, + 139, + 252, + 18, + 65, + 0, + 1, + 137, + 139, + 254, + 139, + 255, + 136, + 14, + 73, + 68, + 139, + 254, + 39, + 7, + 101, + 68, + 128, + 3, + 51, + 46, + 51, + 18, + 65, + 0, + 9, + 49, + 22, + 136, + 3, + 103, + 68, + 66, + 0, + 9, + 49, + 0, + 139, + 254, + 114, + 8, + 72, + 18, + 68, + 139, + 254, + 139, + 253, + 136, + 14, + 18, + 140, + 0, + 139, + 254, + 139, + 252, + 136, + 14, + 9, + 140, + 1, + 139, + 0, + 188, + 139, + 1, + 139, + 255, + 191, + 137, + 54, + 26, + 3, + 73, + 21, + 33, + 4, + 18, + 68, + 54, + 26, + 2, + 23, + 54, + 26, + 1, + 87, + 2, + 0, + 136, + 0, + 2, + 35, + 67, + 138, + 3, + 0, + 40, + 139, + 254, + 139, + 255, + 136, + 13, + 233, + 68, + 139, + 254, + 42, + 101, + 68, + 140, + 0, + 139, + 254, + 114, + 8, + 72, + 139, + 253, + 18, + 65, + 0, + 9, + 49, + 0, + 139, + 0, + 18, + 68, + 66, + 0, + 6, + 49, + 0, + 139, + 253, + 18, + 68, + 139, + 254, + 54, + 26, + 3, + 136, + 13, + 157, + 136, + 6, + 148, + 128, + 4, + 81, + 114, + 207, + 1, + 40, + 40, + 128, + 2, + 0, + 42, + 139, + 254, + 22, + 136, + 15, + 110, + 139, + 255, + 73, + 21, + 22, + 87, + 6, + 2, + 76, + 80, + 136, + 15, + 110, + 139, + 253, + 136, + 15, + 92, + 72, + 80, + 80, + 176, + 137, + 41, + 54, + 26, + 1, + 87, + 2, + 0, + 136, + 0, + 12, + 73, + 21, + 22, + 87, + 6, + 2, + 76, + 80, + 80, + 176, + 35, + 67, + 138, + 1, + 1, + 40, + 71, + 5, + 139, + 255, + 136, + 0, + 217, + 140, + 0, + 139, + 0, + 42, + 101, + 68, + 140, + 1, + 139, + 0, + 39, + 18, + 101, + 68, + 139, + 255, + 18, + 68, + 49, + 0, + 139, + 1, + 18, + 68, + 139, + 0, + 39, + 12, + 101, + 76, + 72, + 68, + 43, + 190, + 68, + 140, + 2, + 139, + 0, + 39, + 7, + 101, + 68, + 139, + 2, + 19, + 68, + 39, + 6, + 43, + 190, + 68, + 80, + 140, + 3, + 39, + 10, + 139, + 2, + 80, + 190, + 68, + 140, + 4, + 139, + 3, + 189, + 68, + 140, + 5, + 177, + 37, + 178, + 16, + 128, + 4, + 23, + 71, + 64, + 91, + 178, + 26, + 33, + 7, + 178, + 25, + 139, + 0, + 178, + 24, + 139, + 2, + 73, + 21, + 22, + 87, + 6, + 2, + 76, + 80, + 178, + 26, + 139, + 3, + 34, + 33, + 10, + 186, + 178, + 64, + 139, + 3, + 33, + 10, + 139, + 5, + 33, + 10, + 9, + 186, + 178, + 64, + 139, + 4, + 178, + 31, + 34, + 178, + 1, + 179, + 139, + 2, + 140, + 0, + 70, + 5, + 137, + 41, + 54, + 26, + 2, + 23, + 54, + 26, + 1, + 87, + 2, + 0, + 136, + 0, + 10, + 39, + 13, + 34, + 79, + 2, + 84, + 80, + 176, + 35, + 67, + 138, + 2, + 1, + 40, + 139, + 255, + 136, + 12, + 155, + 140, + 0, + 139, + 0, + 189, + 76, + 72, + 20, + 65, + 0, + 10, + 139, + 254, + 139, + 255, + 136, + 12, + 100, + 66, + 0, + 7, + 139, + 254, + 139, + 255, + 136, + 12, + 171, + 140, + 0, + 137, + 41, + 54, + 26, + 1, + 87, + 2, + 0, + 136, + 0, + 5, + 22, + 80, + 176, + 35, + 67, + 138, + 1, + 1, + 40, + 73, + 139, + 255, + 136, + 12, + 99, + 140, + 0, + 139, + 0, + 189, + 76, + 72, + 20, + 65, + 0, + 4, + 34, + 66, + 0, + 17, + 139, + 0, + 190, + 68, + 140, + 1, + 139, + 1, + 21, + 33, + 9, + 18, + 68, + 139, + 1, + 36, + 91, + 140, + 0, + 70, + 1, + 137, + 41, + 54, + 26, + 1, + 73, + 21, + 33, + 4, + 18, + 68, + 136, + 0, + 14, + 73, + 21, + 36, + 10, + 22, + 87, + 6, + 2, + 76, + 80, + 80, + 176, + 35, + 67, + 138, + 1, + 1, + 40, + 71, + 4, + 40, + 140, + 0, + 139, + 255, + 136, + 12, + 31, + 140, + 1, + 139, + 1, + 189, + 76, + 72, + 20, + 65, + 0, + 5, + 139, + 0, + 66, + 0, + 53, + 139, + 1, + 190, + 68, + 140, + 2, + 34, + 140, + 3, + 139, + 3, + 139, + 2, + 21, + 12, + 65, + 0, + 33, + 139, + 2, + 139, + 3, + 36, + 88, + 23, + 140, + 4, + 139, + 4, + 34, + 19, + 65, + 0, + 8, + 139, + 0, + 139, + 4, + 22, + 80, + 140, + 0, + 139, + 3, + 36, + 8, + 140, + 3, + 66, + 255, + 214, + 139, + 0, + 140, + 0, + 70, + 4, + 137, + 54, + 26, + 3, + 87, + 2, + 0, + 54, + 26, + 2, + 23, + 54, + 26, + 1, + 87, + 2, + 0, + 136, + 0, + 2, + 35, + 67, + 138, + 3, + 0, + 49, + 22, + 136, + 1, + 13, + 68, + 39, + 6, + 139, + 255, + 80, + 139, + 254, + 185, + 72, + 39, + 10, + 139, + 255, + 80, + 139, + 253, + 191, + 137, + 54, + 26, + 3, + 87, + 2, + 0, + 54, + 26, + 2, + 23, + 54, + 26, + 1, + 87, + 2, + 0, + 136, + 0, + 2, + 35, + 67, + 138, + 3, + 0, + 49, + 22, + 136, + 0, + 221, + 68, + 39, + 6, + 139, + 255, + 80, + 139, + 254, + 139, + 253, + 187, + 137, + 54, + 26, + 1, + 87, + 2, + 0, + 136, + 0, + 2, + 35, + 67, + 138, + 1, + 0, + 49, + 22, + 136, + 0, + 190, + 68, + 43, + 139, + 255, + 191, + 137, + 41, + 54, + 26, + 1, + 23, + 136, + 0, + 5, + 22, + 80, + 176, + 35, + 67, + 138, + 1, + 1, + 40, + 71, + 2, + 52, + 204, + 128, + 2, + 116, + 115, + 101, + 68, + 140, + 0, + 52, + 204, + 128, + 8, + 100, + 101, + 99, + 105, + 109, + 97, + 108, + 115, + 101, + 68, + 140, + 1, + 52, + 204, + 128, + 5, + 112, + 114, + 105, + 99, + 101, + 101, + 68, + 140, + 2, + 50, + 7, + 139, + 0, + 9, + 33, + 15, + 13, + 65, + 0, + 34, + 33, + 5, + 140, + 1, + 129, + 33, + 140, + 2, + 128, + 23, + 111, + 114, + 97, + 99, + 108, + 101, + 32, + 62, + 50, + 52, + 104, + 114, + 32, + 117, + 115, + 105, + 110, + 103, + 32, + 46, + 51, + 51, + 99, + 176, + 139, + 255, + 33, + 16, + 11, + 139, + 1, + 136, + 9, + 136, + 11, + 139, + 2, + 10, + 33, + 16, + 10, + 33, + 16, + 11, + 140, + 0, + 70, + 2, + 137, + 41, + 54, + 26, + 1, + 73, + 21, + 33, + 4, + 18, + 68, + 136, + 0, + 5, + 22, + 80, + 176, + 35, + 67, + 138, + 1, + 1, + 40, + 139, + 255, + 136, + 10, + 200, + 140, + 0, + 139, + 0, + 189, + 76, + 72, + 20, + 65, + 0, + 12, + 139, + 0, + 21, + 36, + 8, + 35, + 136, + 9, + 178, + 66, + 0, + 3, + 129, + 128, + 25, + 140, + 0, + 137, + 138, + 1, + 1, + 139, + 255, + 56, + 0, + 52, + 200, + 112, + 0, + 72, + 35, + 18, + 73, + 65, + 0, + 8, + 139, + 255, + 56, + 9, + 50, + 3, + 18, + 16, + 73, + 65, + 0, + 8, + 139, + 255, + 56, + 32, + 50, + 3, + 18, + 16, + 137, + 138, + 0, + 1, + 34, + 71, + 3, + 35, + 34, + 73, + 136, + 9, + 35, + 137, + 138, + 3, + 1, + 139, + 255, + 136, + 11, + 27, + 65, + 0, + 49, + 177, + 37, + 178, + 16, + 139, + 255, + 178, + 24, + 128, + 19, + 105, + 115, + 95, + 97, + 100, + 100, + 114, + 101, + 115, + 115, + 95, + 105, + 110, + 95, + 102, + 105, + 101, + 108, + 100, + 178, + 26, + 139, + 254, + 178, + 26, + 139, + 253, + 178, + 26, + 34, + 178, + 1, + 179, + 180, + 62, + 23, + 35, + 18, + 137, + 177, + 37, + 178, + 16, + 128, + 4, + 212, + 67, + 149, + 42, + 178, + 26, + 139, + 255, + 178, + 24, + 139, + 254, + 73, + 21, + 22, + 87, + 6, + 2, + 76, + 80, + 178, + 26, + 139, + 253, + 178, + 26, + 34, + 178, + 1, + 179, + 180, + 59, + 35, + 9, + 197, + 58, + 87, + 4, + 0, + 34, + 83, + 137, + 138, + 2, + 1, + 40, + 71, + 3, + 139, + 254, + 34, + 19, + 68, + 139, + 255, + 189, + 76, + 72, + 20, + 65, + 0, + 4, + 34, + 66, + 0, + 57, + 139, + 255, + 190, + 68, + 140, + 0, + 139, + 0, + 140, + 1, + 139, + 0, + 21, + 36, + 10, + 140, + 2, + 34, + 140, + 3, + 139, + 3, + 139, + 2, + 12, + 65, + 0, + 28, + 139, + 1, + 139, + 3, + 36, + 11, + 36, + 88, + 23, + 139, + 254, + 18, + 65, + 0, + 4, + 35, + 66, + 0, + 10, + 139, + 3, + 35, + 8, + 140, + 3, + 66, + 255, + 220, + 34, + 140, + 0, + 70, + 3, + 137, + 138, + 2, + 1, + 40, + 71, + 3, + 139, + 255, + 189, + 76, + 72, + 20, + 65, + 0, + 10, + 139, + 255, + 139, + 254, + 22, + 191, + 35, + 66, + 0, + 102, + 139, + 255, + 190, + 68, + 140, + 0, + 139, + 0, + 21, + 36, + 10, + 140, + 1, + 34, + 140, + 2, + 139, + 2, + 139, + 1, + 12, + 65, + 0, + 51, + 139, + 0, + 139, + 2, + 36, + 11, + 91, + 140, + 3, + 139, + 3, + 34, + 18, + 65, + 0, + 14, + 139, + 255, + 139, + 2, + 36, + 11, + 139, + 254, + 22, + 187, + 35, + 66, + 0, + 48, + 139, + 3, + 139, + 254, + 18, + 65, + 0, + 4, + 35, + 66, + 0, + 36, + 139, + 2, + 35, + 8, + 140, + 2, + 66, + 255, + 197, + 139, + 0, + 21, + 129, + 240, + 7, + 12, + 65, + 0, + 16, + 139, + 255, + 188, + 139, + 255, + 139, + 0, + 139, + 254, + 22, + 80, + 191, + 35, + 66, + 0, + 1, + 34, + 140, + 0, + 70, + 3, + 137, + 138, + 3, + 1, + 139, + 255, + 136, + 9, + 213, + 65, + 0, + 54, + 177, + 37, + 178, + 16, + 139, + 255, + 178, + 24, + 128, + 24, + 114, + 101, + 103, + 95, + 97, + 100, + 100, + 95, + 118, + 101, + 114, + 105, + 102, + 105, + 101, + 100, + 95, + 97, + 100, + 100, + 114, + 101, + 115, + 115, + 178, + 26, + 139, + 254, + 178, + 26, + 139, + 253, + 178, + 26, + 34, + 178, + 1, + 179, + 180, + 62, + 23, + 35, + 18, + 137, + 177, + 37, + 178, + 16, + 128, + 4, + 133, + 204, + 237, + 87, + 178, + 26, + 139, + 255, + 178, + 24, + 139, + 254, + 73, + 21, + 22, + 87, + 6, + 2, + 76, + 80, + 178, + 26, + 139, + 253, + 73, + 21, + 22, + 87, + 6, + 2, + 76, + 80, + 178, + 26, + 34, + 178, + 1, + 179, + 180, + 59, + 35, + 9, + 197, + 58, + 87, + 4, + 0, + 34, + 83, + 137, + 138, + 4, + 1, + 139, + 255, + 136, + 9, + 92, + 65, + 0, + 57, + 177, + 37, + 178, + 16, + 139, + 255, + 178, + 24, + 128, + 27, + 114, + 101, + 103, + 95, + 114, + 101, + 109, + 111, + 118, + 101, + 95, + 118, + 101, + 114, + 105, + 102, + 105, + 101, + 100, + 95, + 97, + 100, + 100, + 114, + 101, + 115, + 115, + 178, + 26, + 139, + 254, + 178, + 26, + 139, + 253, + 178, + 26, + 34, + 178, + 1, + 179, + 180, + 62, + 23, + 35, + 18, + 137, + 177, + 37, + 178, + 16, + 128, + 4, + 177, + 137, + 10, + 117, + 178, + 26, + 139, + 255, + 178, + 24, + 139, + 254, + 73, + 21, + 22, + 87, + 6, + 2, + 76, + 80, + 178, + 26, + 139, + 253, + 178, + 26, + 139, + 252, + 178, + 26, + 34, + 178, + 1, + 179, + 180, + 59, + 35, + 9, + 197, + 58, + 87, + 4, + 0, + 34, + 83, + 137, + 138, + 1, + 1, + 139, + 255, + 34, + 18, + 65, + 0, + 2, + 34, + 137, + 50, + 7, + 139, + 255, + 13, + 137, + 138, + 0, + 0, + 54, + 26, + 1, + 136, + 251, + 174, + 22, + 176, + 137, + 138, + 0, + 0, + 40, + 54, + 26, + 1, + 136, + 8, + 24, + 140, + 0, + 139, + 0, + 189, + 76, + 72, + 20, + 65, + 0, + 3, + 40, + 176, + 137, + 139, + 0, + 190, + 68, + 176, + 137, + 138, + 0, + 0, + 40, + 54, + 26, + 2, + 23, + 54, + 26, + 1, + 136, + 7, + 199, + 68, + 54, + 26, + 2, + 23, + 128, + 7, + 105, + 46, + 97, + 115, + 97, + 105, + 100, + 101, + 68, + 140, + 0, + 139, + 0, + 40, + 19, + 68, + 35, + 54, + 26, + 2, + 23, + 139, + 0, + 23, + 54, + 26, + 1, + 136, + 0, + 114, + 137, + 138, + 2, + 0, + 40, + 71, + 3, + 139, + 255, + 136, + 7, + 197, + 189, + 76, + 72, + 65, + 0, + 1, + 137, + 128, + 8, + 97, + 100, + 100, + 114, + 101, + 115, + 115, + 47, + 139, + 254, + 80, + 136, + 7, + 32, + 140, + 0, + 40, + 140, + 1, + 34, + 140, + 2, + 139, + 2, + 33, + 9, + 12, + 65, + 0, + 62, + 39, + 16, + 139, + 2, + 136, + 9, + 80, + 80, + 140, + 3, + 139, + 0, + 54, + 50, + 0, + 139, + 3, + 99, + 76, + 72, + 65, + 0, + 13, + 139, + 1, + 139, + 0, + 139, + 3, + 98, + 80, + 140, + 1, + 66, + 0, + 17, + 139, + 1, + 21, + 34, + 13, + 65, + 0, + 8, + 139, + 255, + 136, + 7, + 109, + 139, + 1, + 191, + 137, + 139, + 2, + 35, + 8, + 140, + 2, + 66, + 255, + 186, + 137, + 138, + 4, + 0, + 40, + 139, + 252, + 20, + 65, + 0, + 7, + 139, + 255, + 136, + 0, + 33, + 20, + 68, + 139, + 255, + 136, + 7, + 63, + 140, + 0, + 139, + 254, + 68, + 139, + 253, + 68, + 139, + 0, + 189, + 76, + 72, + 20, + 68, + 139, + 0, + 139, + 254, + 22, + 139, + 253, + 22, + 80, + 191, + 137, + 138, + 1, + 1, + 40, + 39, + 14, + 139, + 255, + 80, + 136, + 6, + 149, + 140, + 0, + 139, + 0, + 54, + 50, + 0, + 97, + 20, + 65, + 0, + 4, + 34, + 66, + 0, + 10, + 139, + 0, + 54, + 50, + 0, + 39, + 15, + 99, + 76, + 72, + 140, + 0, + 137, + 138, + 2, + 1, + 40, + 71, + 4, + 139, + 255, + 190, + 68, + 140, + 0, + 139, + 254, + 34, + 19, + 68, + 139, + 0, + 21, + 33, + 9, + 15, + 68, + 139, + 0, + 34, + 91, + 139, + 254, + 18, + 65, + 0, + 4, + 35, + 66, + 0, + 84, + 139, + 0, + 21, + 36, + 10, + 140, + 1, + 34, + 140, + 2, + 34, + 140, + 3, + 139, + 3, + 139, + 1, + 12, + 65, + 0, + 29, + 139, + 0, + 139, + 3, + 36, + 11, + 91, + 139, + 254, + 18, + 65, + 0, + 7, + 139, + 3, + 140, + 2, + 66, + 0, + 9, + 139, + 3, + 35, + 8, + 140, + 3, + 66, + 255, + 219, + 139, + 2, + 34, + 19, + 68, + 139, + 0, + 34, + 91, + 140, + 4, + 139, + 0, + 34, + 139, + 254, + 22, + 93, + 140, + 0, + 139, + 255, + 139, + 0, + 139, + 2, + 36, + 11, + 139, + 4, + 22, + 93, + 191, + 35, + 140, + 0, + 70, + 4, + 137, + 138, + 2, + 1, + 40, + 71, + 2, + 139, + 255, + 190, + 68, + 140, + 0, + 139, + 0, + 21, + 36, + 10, + 140, + 1, + 34, + 140, + 2, + 139, + 2, + 139, + 1, + 12, + 65, + 0, + 70, + 139, + 0, + 139, + 2, + 36, + 11, + 91, + 139, + 254, + 18, + 65, + 0, + 48, + 139, + 2, + 139, + 1, + 35, + 9, + 18, + 65, + 0, + 25, + 139, + 255, + 188, + 139, + 2, + 34, + 13, + 65, + 0, + 11, + 139, + 255, + 139, + 0, + 34, + 139, + 2, + 36, + 11, + 88, + 191, + 35, + 66, + 0, + 23, + 139, + 255, + 139, + 2, + 36, + 11, + 39, + 4, + 187, + 35, + 66, + 0, + 10, + 139, + 2, + 35, + 8, + 140, + 2, + 66, + 255, + 178, + 34, + 140, + 0, + 70, + 2, + 137, + 138, + 3, + 1, + 139, + 254, + 34, + 139, + 253, + 82, + 139, + 255, + 22, + 80, + 139, + 254, + 139, + 253, + 36, + 8, + 139, + 254, + 21, + 82, + 80, + 137, + 138, + 3, + 1, + 40, + 71, + 2, + 139, + 255, + 139, + 254, + 98, + 140, + 0, + 139, + 0, + 21, + 36, + 10, + 140, + 1, + 34, + 140, + 2, + 139, + 2, + 139, + 1, + 12, + 65, + 0, + 41, + 139, + 0, + 139, + 2, + 36, + 11, + 91, + 139, + 253, + 18, + 65, + 0, + 19, + 139, + 255, + 139, + 254, + 139, + 2, + 36, + 11, + 139, + 0, + 34, + 136, + 255, + 173, + 102, + 35, + 66, + 0, + 10, + 139, + 2, + 35, + 8, + 140, + 2, + 66, + 255, + 207, + 34, + 140, + 0, + 70, + 2, + 137, + 138, + 4, + 1, + 40, + 34, + 140, + 0, + 139, + 0, + 139, + 253, + 12, + 65, + 0, + 31, + 139, + 252, + 139, + 254, + 139, + 0, + 136, + 7, + 87, + 80, + 139, + 255, + 136, + 255, + 148, + 65, + 0, + 4, + 35, + 66, + 0, + 10, + 139, + 0, + 35, + 8, + 140, + 0, + 66, + 255, + 217, + 34, + 140, + 0, + 137, + 138, + 0, + 0, + 40, + 73, + 50, + 10, + 115, + 0, + 72, + 140, + 0, + 50, + 10, + 115, + 1, + 72, + 140, + 1, + 139, + 0, + 139, + 1, + 13, + 65, + 0, + 33, + 177, + 35, + 178, + 16, + 139, + 0, + 139, + 1, + 9, + 178, + 8, + 54, + 26, + 1, + 178, + 7, + 128, + 9, + 115, + 119, + 101, + 101, + 112, + 68, + 117, + 115, + 116, + 178, + 5, + 34, + 178, + 1, + 179, + 137, + 138, + 1, + 1, + 40, + 71, + 6, + 139, + 255, + 21, + 140, + 0, + 139, + 0, + 37, + 15, + 68, + 139, + 255, + 139, + 0, + 33, + 6, + 9, + 33, + 6, + 88, + 128, + 5, + 46, + 97, + 108, + 103, + 111, + 18, + 68, + 39, + 13, + 34, + 73, + 84, + 39, + 4, + 80, + 39, + 4, + 80, + 140, + 1, + 34, + 140, + 2, + 34, + 140, + 3, + 34, + 140, + 4, + 34, + 140, + 5, + 139, + 5, + 139, + 0, + 33, + 7, + 9, + 12, + 65, + 0, + 153, + 139, + 255, + 139, + 5, + 85, + 140, + 6, + 139, + 6, + 129, + 46, + 18, + 65, + 0, + 81, + 139, + 2, + 35, + 8, + 140, + 2, + 139, + 2, + 35, + 18, + 65, + 0, + 25, + 139, + 5, + 140, + 4, + 139, + 3, + 35, + 15, + 73, + 65, + 0, + 6, + 139, + 3, + 33, + 17, + 14, + 16, + 68, + 34, + 140, + 3, + 66, + 0, + 40, + 139, + 2, + 33, + 5, + 18, + 65, + 0, + 31, + 139, + 3, + 35, + 15, + 73, + 65, + 0, + 6, + 139, + 3, + 33, + 17, + 14, + 16, + 73, + 65, + 0, + 9, + 139, + 5, + 139, + 0, + 33, + 6, + 9, + 18, + 16, + 68, + 66, + 0, + 1, + 0, + 66, + 0, + 48, + 139, + 6, + 129, + 97, + 15, + 73, + 65, + 0, + 6, + 139, + 6, + 129, + 122, + 14, + 16, + 73, + 64, + 0, + 16, + 139, + 6, + 129, + 48, + 15, + 73, + 65, + 0, + 6, + 139, + 6, + 129, + 57, + 14, + 16, + 17, + 65, + 0, + 9, + 139, + 3, + 35, + 8, + 140, + 3, + 66, + 0, + 1, + 0, + 139, + 5, + 35, + 8, + 140, + 5, + 66, + 255, + 92, + 139, + 2, + 35, + 18, + 65, + 0, + 39, + 139, + 1, + 53, + 255, + 52, + 255, + 34, + 73, + 84, + 140, + 1, + 139, + 1, + 53, + 255, + 52, + 255, + 35, + 139, + 4, + 22, + 93, + 140, + 1, + 139, + 1, + 53, + 255, + 52, + 255, + 39, + 4, + 92, + 9, + 140, + 1, + 66, + 0, + 44, + 139, + 1, + 53, + 255, + 52, + 255, + 34, + 35, + 84, + 140, + 1, + 139, + 1, + 53, + 255, + 52, + 255, + 35, + 139, + 3, + 22, + 93, + 140, + 1, + 139, + 1, + 53, + 255, + 52, + 255, + 129, + 9, + 139, + 0, + 33, + 6, + 9, + 139, + 3, + 9, + 22, + 93, + 140, + 1, + 139, + 1, + 140, + 0, + 70, + 6, + 137, + 138, + 1, + 1, + 40, + 73, + 139, + 255, + 136, + 3, + 242, + 140, + 0, + 139, + 0, + 189, + 76, + 72, + 20, + 65, + 0, + 4, + 34, + 66, + 0, + 17, + 139, + 0, + 190, + 68, + 140, + 1, + 139, + 1, + 21, + 33, + 9, + 18, + 68, + 139, + 1, + 36, + 91, + 140, + 0, + 70, + 1, + 137, + 138, + 2, + 1, + 139, + 255, + 139, + 254, + 53, + 255, + 52, + 255, + 87, + 9, + 8, + 23, + 139, + 255, + 21, + 82, + 137, + 138, + 2, + 1, + 139, + 255, + 139, + 254, + 101, + 76, + 72, + 20, + 65, + 0, + 2, + 40, + 137, + 139, + 255, + 139, + 254, + 101, + 68, + 137, + 138, + 2, + 1, + 139, + 255, + 139, + 254, + 101, + 76, + 72, + 20, + 65, + 0, + 2, + 34, + 137, + 139, + 255, + 139, + 254, + 101, + 68, + 23, + 137, + 138, + 3, + 1, + 40, + 71, + 19, + 136, + 239, + 17, + 140, + 0, + 139, + 254, + 53, + 255, + 52, + 255, + 34, + 83, + 65, + 0, + 110, + 139, + 254, + 139, + 255, + 136, + 255, + 160, + 136, + 255, + 110, + 140, + 2, + 139, + 2, + 34, + 19, + 68, + 34, + 140, + 3, + 39, + 17, + 139, + 2, + 136, + 255, + 160, + 39, + 9, + 18, + 65, + 0, + 49, + 128, + 17, + 105, + 46, + 115, + 101, + 103, + 109, + 101, + 110, + 116, + 80, + 114, + 105, + 99, + 101, + 85, + 115, + 100, + 139, + 2, + 136, + 255, + 153, + 140, + 3, + 139, + 3, + 139, + 0, + 87, + 0, + 8, + 23, + 12, + 65, + 0, + 8, + 139, + 0, + 87, + 0, + 8, + 23, + 140, + 3, + 66, + 0, + 8, + 139, + 0, + 87, + 0, + 8, + 23, + 140, + 3, + 139, + 3, + 139, + 0, + 87, + 0, + 8, + 23, + 15, + 68, + 139, + 3, + 136, + 247, + 191, + 140, + 1, + 66, + 0, + 112, + 139, + 254, + 53, + 255, + 52, + 255, + 87, + 1, + 8, + 23, + 140, + 4, + 34, + 140, + 5, + 139, + 4, + 33, + 6, + 15, + 65, + 0, + 8, + 129, + 216, + 4, + 140, + 5, + 66, + 0, + 65, + 139, + 4, + 33, + 7, + 18, + 65, + 0, + 8, + 129, + 176, + 9, + 140, + 5, + 66, + 0, + 49, + 139, + 4, + 33, + 8, + 18, + 65, + 0, + 8, + 129, + 184, + 23, + 140, + 5, + 66, + 0, + 33, + 139, + 4, + 33, + 5, + 18, + 65, + 0, + 8, + 129, + 168, + 70, + 140, + 5, + 66, + 0, + 17, + 139, + 4, + 35, + 18, + 65, + 0, + 9, + 129, + 140, + 246, + 1, + 140, + 5, + 66, + 0, + 1, + 0, + 50, + 7, + 139, + 5, + 136, + 0, + 249, + 140, + 6, + 139, + 6, + 136, + 247, + 76, + 140, + 1, + 139, + 255, + 136, + 246, + 36, + 140, + 7, + 34, + 140, + 8, + 34, + 140, + 9, + 139, + 7, + 34, + 19, + 65, + 0, + 151, + 139, + 253, + 139, + 7, + 42, + 101, + 68, + 18, + 140, + 10, + 39, + 12, + 139, + 7, + 136, + 254, + 207, + 140, + 11, + 139, + 11, + 136, + 250, + 52, + 73, + 65, + 0, + 4, + 139, + 10, + 20, + 16, + 65, + 0, + 116, + 35, + 140, + 8, + 35, + 140, + 9, + 139, + 0, + 87, + 64, + 8, + 23, + 136, + 247, + 4, + 140, + 12, + 139, + 1, + 140, + 13, + 50, + 7, + 140, + 14, + 139, + 11, + 139, + 0, + 87, + 56, + 8, + 23, + 33, + 18, + 11, + 33, + 18, + 11, + 129, + 24, + 11, + 8, + 140, + 15, + 139, + 14, + 139, + 11, + 13, + 68, + 139, + 14, + 139, + 15, + 15, + 65, + 0, + 7, + 139, + 13, + 140, + 1, + 66, + 0, + 50, + 139, + 14, + 139, + 11, + 9, + 140, + 16, + 139, + 15, + 139, + 11, + 9, + 140, + 17, + 139, + 12, + 139, + 13, + 9, + 140, + 18, + 139, + 18, + 139, + 16, + 11, + 139, + 17, + 10, + 140, + 19, + 139, + 12, + 139, + 19, + 9, + 140, + 1, + 139, + 1, + 139, + 13, + 12, + 65, + 0, + 4, + 139, + 13, + 140, + 1, + 139, + 1, + 129, + 192, + 132, + 61, + 15, + 68, + 139, + 1, + 22, + 139, + 7, + 34, + 18, + 65, + 0, + 8, + 139, + 255, + 136, + 237, + 245, + 66, + 0, + 1, + 34, + 22, + 80, + 39, + 13, + 34, + 139, + 7, + 34, + 19, + 84, + 35, + 139, + 9, + 84, + 33, + 5, + 139, + 8, + 84, + 80, + 140, + 0, + 70, + 19, + 137, + 41, + 54, + 26, + 2, + 23, + 54, + 26, + 1, + 23, + 136, + 0, + 5, + 22, + 80, + 176, + 35, + 67, + 138, + 2, + 1, + 40, + 71, + 3, + 139, + 254, + 33, + 19, + 12, + 65, + 0, + 5, + 139, + 255, + 66, + 0, + 46, + 139, + 254, + 33, + 19, + 9, + 140, + 0, + 139, + 0, + 129, + 128, + 231, + 132, + 15, + 10, + 140, + 1, + 139, + 1, + 34, + 18, + 65, + 0, + 5, + 139, + 255, + 66, + 0, + 17, + 129, + 102, + 139, + 1, + 149, + 140, + 2, + 140, + 3, + 139, + 255, + 139, + 2, + 11, + 129, + 100, + 10, + 140, + 0, + 70, + 3, + 137, + 138, + 1, + 1, + 40, + 73, + 33, + 12, + 139, + 255, + 149, + 140, + 0, + 140, + 1, + 139, + 0, + 140, + 0, + 70, + 1, + 137, + 138, + 7, + 1, + 40, + 33, + 11, + 140, + 0, + 139, + 0, + 139, + 255, + 33, + 11, + 11, + 8, + 140, + 0, + 139, + 0, + 139, + 254, + 33, + 11, + 11, + 8, + 140, + 0, + 139, + 0, + 139, + 253, + 33, + 11, + 11, + 8, + 140, + 0, + 139, + 0, + 139, + 252, + 33, + 20, + 11, + 8, + 140, + 0, + 139, + 0, + 139, + 250, + 33, + 20, + 11, + 8, + 140, + 0, + 139, + 0, + 139, + 251, + 33, + 21, + 11, + 8, + 140, + 0, + 139, + 0, + 139, + 249, + 33, + 21, + 11, + 8, + 140, + 0, + 139, + 0, + 140, + 0, + 137, + 138, + 2, + 1, + 129, + 196, + 19, + 139, + 255, + 11, + 139, + 254, + 129, + 144, + 3, + 11, + 8, + 137, + 138, + 1, + 1, + 139, + 255, + 21, + 33, + 4, + 14, + 65, + 0, + 3, + 139, + 255, + 137, + 139, + 255, + 34, + 33, + 4, + 39, + 19, + 21, + 9, + 82, + 39, + 19, + 80, + 137, + 138, + 2, + 1, + 40, + 139, + 254, + 140, + 0, + 139, + 255, + 33, + 22, + 15, + 65, + 0, + 25, + 139, + 255, + 33, + 23, + 26, + 33, + 22, + 25, + 22, + 87, + 7, + 1, + 139, + 255, + 129, + 7, + 145, + 136, + 255, + 220, + 140, + 0, + 66, + 0, + 11, + 139, + 255, + 33, + 23, + 26, + 22, + 87, + 7, + 1, + 140, + 0, + 139, + 254, + 139, + 0, + 80, + 140, + 0, + 137, + 138, + 1, + 1, + 40, + 139, + 255, + 136, + 255, + 187, + 137, + 138, + 1, + 1, + 40, + 128, + 47, + 5, + 32, + 1, + 1, + 128, + 8, + 1, + 2, + 3, + 4, + 5, + 6, + 7, + 8, + 23, + 53, + 0, + 49, + 24, + 52, + 0, + 18, + 49, + 16, + 129, + 6, + 18, + 16, + 49, + 25, + 34, + 18, + 49, + 25, + 129, + 0, + 18, + 17, + 16, + 64, + 0, + 1, + 0, + 34, + 67, + 38, + 1, + 140, + 0, + 139, + 0, + 37, + 54, + 50, + 0, + 22, + 93, + 140, + 0, + 139, + 0, + 139, + 255, + 21, + 136, + 255, + 173, + 80, + 139, + 255, + 80, + 140, + 0, + 128, + 7, + 80, + 114, + 111, + 103, + 114, + 97, + 109, + 139, + 0, + 80, + 3, + 140, + 0, + 137, + 138, + 2, + 1, + 40, + 39, + 14, + 139, + 255, + 80, + 136, + 255, + 149, + 140, + 0, + 139, + 0, + 54, + 50, + 0, + 39, + 15, + 99, + 76, + 72, + 68, + 139, + 0, + 39, + 15, + 98, + 139, + 254, + 22, + 18, + 140, + 0, + 137, + 138, + 1, + 1, + 39, + 14, + 139, + 255, + 80, + 1, + 137, + 138, + 1, + 1, + 128, + 10, + 97, + 100, + 100, + 114, + 47, + 97, + 108, + 103, + 111, + 47, + 139, + 255, + 80, + 1, + 137, + 138, + 2, + 1, + 128, + 1, + 79, + 139, + 255, + 139, + 254, + 22, + 80, + 80, + 137, + 138, + 2, + 1, + 40, + 71, + 2, + 139, + 255, + 136, + 255, + 201, + 140, + 0, + 139, + 0, + 190, + 68, + 140, + 1, + 139, + 0, + 189, + 68, + 140, + 2, + 139, + 0, + 189, + 76, + 72, + 20, + 65, + 0, + 4, + 34, + 66, + 0, + 48, + 139, + 2, + 33, + 9, + 19, + 65, + 0, + 4, + 34, + 66, + 0, + 36, + 139, + 255, + 21, + 33, + 6, + 12, + 65, + 0, + 4, + 34, + 66, + 0, + 23, + 139, + 254, + 39, + 18, + 101, + 68, + 139, + 255, + 19, + 65, + 0, + 4, + 34, + 66, + 0, + 7, + 139, + 1, + 36, + 91, + 139, + 254, + 18, + 140, + 0, + 70, + 2, + 137, + 138, + 4, + 1, + 40, + 73, + 33, + 14, + 139, + 254, + 11, + 139, + 255, + 10, + 140, + 0, + 139, + 253, + 139, + 0, + 33, + 15, + 11, + 8, + 140, + 1, + 139, + 1, + 50, + 7, + 33, + 14, + 139, + 252, + 11, + 33, + 15, + 11, + 8, + 14, + 68, + 139, + 1, + 140, + 0, + 70, + 1, + 137, + 138, + 1, + 1, + 40, + 139, + 255, + 39, + 7, + 101, + 68, + 87, + 0, + 2, + 140, + 0, + 139, + 0, + 128, + 2, + 49, + 46, + 18, + 73, + 64, + 0, + 8, + 139, + 0, + 128, + 2, + 50, + 46, + 18, + 17, + 140, + 0, + 137, + 35, + 67, + 128, + 4, + 184, + 68, + 123, + 54, + 54, + 26, + 0, + 142, + 1, + 255, + 241, + 0, + 128, + 4, + 49, + 114, + 202, + 157, + 128, + 4, + 255, + 194, + 48, + 60, + 128, + 4, + 112, + 59, + 140, + 231, + 128, + 4, + 32, + 224, + 46, + 119, + 128, + 4, + 126, + 20, + 182, + 211, + 128, + 4, + 62, + 142, + 75, + 118, + 128, + 4, + 148, + 15, + 164, + 113, + 128, + 4, + 149, + 216, + 245, + 204, + 128, + 4, + 210, + 89, + 143, + 2, + 128, + 4, + 242, + 44, + 87, + 242, + 128, + 4, + 214, + 113, + 21, + 91, + 128, + 4, + 22, + 237, + 106, + 94, + 128, + 4, + 75, + 226, + 47, + 198, + 128, + 4, + 237, + 131, + 21, + 67, + 128, + 4, + 255, + 235, + 149, + 85, + 128, + 4, + 44, + 77, + 200, + 176, + 128, + 4, + 243, + 137, + 168, + 204, + 128, + 4, + 47, + 48, + 180, + 133, + 128, + 4, + 161, + 104, + 8, + 1, + 128, + 4, + 79, + 99, + 255, + 246, + 128, + 4, + 140, + 200, + 93, + 173, + 54, + 26, + 0, + 142, + 21, + 233, + 192, + 233, + 201, + 233, + 240, + 234, + 122, + 234, + 185, + 234, + 224, + 238, + 209, + 239, + 69, + 239, + 225, + 240, + 21, + 240, + 136, + 241, + 1, + 241, + 172, + 241, + 236, + 242, + 42, + 242, + 157, + 242, + 205, + 242, + 246, + 243, + 15, + 243, + 143, + 252, + 177, + 136, + 231, + 116, + 35, + 67, + 128, + 4, + 70, + 247, + 101, + 51, + 54, + 26, + 0, + 142, + 1, + 231, + 82, + 136, + 231, + 98, + 35, + 67, + 138, + 1, + 1, + 128, + 10, + 48, + 49, + 50, + 51, + 52, + 53, + 54, + 55, + 56, + 57, + 139, + 255, + 35, + 88, + 137, + 138, + 1, + 1, + 139, + 255, + 34, + 18, + 65, + 0, + 3, + 39, + 9, + 137, + 139, + 255, + 33, + 12, + 10, + 34, + 13, + 65, + 0, + 11, + 139, + 255, + 33, + 12, + 10, + 136, + 255, + 225, + 66, + 0, + 1, + 40, + 139, + 255, + 33, + 12, + 24, + 136, + 255, + 193, + 80, + 137, + 138, + 4, + 3, + 139, + 252, + 139, + 255, + 80, + 139, + 253, + 139, + 254, + 137, + 138, + 4, + 3, + 139, + 252, + 139, + 254, + 80, + 140, + 252, + 139, + 255, + 73, + 21, + 139, + 254, + 23, + 8, + 22, + 87, + 6, + 2, + 140, + 254, + 139, + 253, + 76, + 80, + 140, + 253, + 139, + 252, + 139, + 253, + 139, + 254, + 137, + 164, + 97, + 112, + 105, + 100, + 206, + 5, + 7, + 85, + 233, + 164, + 97, + 112, + 115, + 117, + 196, + 1, + 10, + 163, + 102, + 101, + 101, + 205, + 3, + 232, + 162, + 102, + 118, + 206, + 2, + 154, + 128, + 107, + 163, + 103, + 101, + 110, + 172, + 116, + 101, + 115, + 116, + 110, + 101, + 116, + 45, + 118, + 49, + 46, + 48, + 162, + 103, + 104, + 196, + 32, + 72, + 99, + 181, + 24, + 164, + 179, + 200, + 78, + 200, + 16, + 242, + 45, + 79, + 16, + 129, + 203, + 15, + 113, + 240, + 89, + 167, + 172, + 32, + 222, + 198, + 47, + 127, + 112, + 229, + 9, + 58, + 34, + 162, + 108, + 118, + 206, + 2, + 154, + 128, + 207, + 164, + 110, + 111, + 116, + 101, + 196, + 80, + 78, + 70, + 68, + 32, + 82, + 101, + 103, + 105, + 115, + 116, + 114, + 121, + 32, + 67, + 111, + 110, + 116, + 114, + 97, + 99, + 116, + 58, + 87, + 83, + 79, + 84, + 82, + 74, + 88, + 76, + 89, + 66, + 81, + 89, + 86, + 77, + 70, + 76, + 79, + 73, + 76, + 89, + 86, + 85, + 83, + 78, + 73, + 87, + 75, + 66, + 87, + 85, + 66, + 87, + 51, + 71, + 78, + 85, + 87, + 65, + 70, + 75, + 71, + 75, + 72, + 78, + 75, + 78, + 82, + 88, + 54, + 54, + 78, + 69, + 90, + 73, + 84, + 85, + 76, + 77, + 163, + 115, + 110, + 100, + 196, + 32, + 222, + 61, + 163, + 205, + 60, + 182, + 36, + 130, + 40, + 95, + 229, + 201, + 178, + 233, + 37, + 20, + 191, + 255, + 240, + 141, + 216, + 176, + 218, + 30, + 2, + 33, + 80, + 223, + 192, + 56, + 40, + 44, + 164, + 116, + 121, + 112, + 101, + 164, + 97, + 112, + 112, + 108 + ] + }, + "assetConfig": { + "id": "GAMRAG3KCG23U2HOELJF32OQAWAISLIFBB5RLDDDYHUSOZNYN7MQ", + "idRaw": [ + 48, + 25, + 16, + 27, + 106, + 17, + 181, + 186, + 104, + 238, + 34, + 210, + 93, + 233, + 208, + 5, + 128, + 137, + 45, + 5, + 8, + 123, + 21, + 140, + 99, + 193, + 233, + 39, + 101, + 184, + 111, + 217 + ], + "multisigAddresses": [ + "424ZV7KBBUJ52DUKP2KLQ6I5GBOHKBXOW7Q7UQIOOYNDWYRM4EKOSMVVRI", + "NY6DHEEFW73R2NUWY562U2NNKSKBKVYY5OOQFLD3M2II5RUNKRZDEGUGEA" + ], + "multisigSignedBytes": [ + 130, + 164, + 109, + 115, + 105, + 103, + 131, + 166, + 115, + 117, + 98, + 115, + 105, + 103, + 146, + 130, + 162, + 112, + 107, + 196, + 32, + 230, + 185, + 154, + 253, + 65, + 13, + 19, + 221, + 14, + 138, + 126, + 148, + 184, + 121, + 29, + 48, + 92, + 117, + 6, + 238, + 183, + 225, + 250, + 65, + 14, + 118, + 26, + 59, + 98, + 44, + 225, + 20, + 161, + 115, + 196, + 64, + 167, + 7, + 238, + 77, + 120, + 250, + 191, + 255, + 140, + 25, + 61, + 141, + 221, + 193, + 224, + 237, + 34, + 228, + 24, + 179, + 197, + 169, + 100, + 32, + 214, + 238, + 195, + 117, + 135, + 89, + 23, + 160, + 176, + 164, + 186, + 146, + 89, + 49, + 97, + 109, + 157, + 193, + 253, + 112, + 143, + 104, + 41, + 188, + 214, + 196, + 94, + 14, + 93, + 30, + 238, + 12, + 142, + 121, + 240, + 60, + 69, + 135, + 146, + 5, + 130, + 162, + 112, + 107, + 196, + 32, + 110, + 60, + 51, + 144, + 133, + 183, + 247, + 29, + 54, + 150, + 199, + 125, + 170, + 105, + 173, + 84, + 148, + 21, + 87, + 24, + 235, + 157, + 2, + 172, + 123, + 102, + 144, + 142, + 198, + 141, + 84, + 114, + 161, + 115, + 196, + 64, + 167, + 7, + 238, + 77, + 120, + 250, + 191, + 255, + 140, + 25, + 61, + 141, + 221, + 193, + 224, + 237, + 34, + 228, + 24, + 179, + 197, + 169, + 100, + 32, + 214, + 238, + 195, + 117, + 135, + 89, + 23, + 160, + 176, + 164, + 186, + 146, + 89, + 49, + 97, + 109, + 157, + 193, + 253, + 112, + 143, + 104, + 41, + 188, + 214, + 196, + 94, + 14, + 93, + 30, + 238, + 12, + 142, + 121, + 240, + 60, + 69, + 135, + 146, + 5, + 163, + 116, + 104, + 114, + 2, + 161, + 118, + 1, + 163, + 116, + 120, + 110, + 138, + 164, + 97, + 112, + 97, + 114, + 130, + 161, + 109, + 196, + 32, + 33, + 241, + 1, + 96, + 244, + 23, + 132, + 139, + 101, + 97, + 191, + 102, + 57, + 174, + 169, + 228, + 165, + 82, + 114, + 49, + 155, + 20, + 81, + 136, + 220, + 207, + 33, + 248, + 74, + 26, + 189, + 145, + 161, + 114, + 196, + 32, + 123, + 153, + 141, + 254, + 48, + 235, + 240, + 109, + 52, + 234, + 33, + 106, + 58, + 141, + 70, + 182, + 87, + 158, + 52, + 244, + 181, + 45, + 223, + 138, + 166, + 205, + 80, + 252, + 138, + 109, + 1, + 73, + 164, + 99, + 97, + 105, + 100, + 206, + 102, + 63, + 208, + 248, + 163, + 102, + 101, + 101, + 205, + 3, + 232, + 162, + 102, + 118, + 206, + 2, + 60, + 227, + 138, + 163, + 103, + 101, + 110, + 172, + 109, + 97, + 105, + 110, + 110, + 101, + 116, + 45, + 118, + 49, + 46, + 48, + 162, + 103, + 104, + 196, + 32, + 192, + 97, + 196, + 216, + 252, + 29, + 189, + 222, + 210, + 215, + 96, + 75, + 228, + 86, + 142, + 63, + 109, + 4, + 25, + 135, + 172, + 55, + 189, + 228, + 182, + 32, + 181, + 171, + 57, + 36, + 138, + 223, + 162, + 108, + 118, + 206, + 2, + 60, + 231, + 114, + 164, + 110, + 111, + 116, + 101, + 197, + 3, + 107, + 123, + 34, + 115, + 116, + 97, + 110, + 100, + 97, + 114, + 100, + 34, + 58, + 34, + 97, + 114, + 99, + 54, + 57, + 34, + 44, + 34, + 100, + 101, + 115, + 99, + 114, + 105, + 112, + 116, + 105, + 111, + 110, + 34, + 58, + 34, + 84, + 104, + 105, + 115, + 32, + 105, + 115, + 32, + 97, + 32, + 118, + 101, + 114, + 105, + 102, + 105, + 97, + 98, + 108, + 121, + 32, + 97, + 117, + 116, + 104, + 101, + 110, + 116, + 105, + 99, + 32, + 100, + 105, + 103, + 105, + 116, + 97, + 108, + 32, + 104, + 105, + 115, + 116, + 111, + 114, + 105, + 99, + 97, + 108, + 32, + 97, + 114, + 116, + 105, + 102, + 97, + 99, + 116, + 32, + 109, + 105, + 110, + 116, + 101, + 100, + 32, + 98, + 121, + 32, + 84, + 104, + 101, + 32, + 68, + 97, + 116, + 97, + 32, + 72, + 105, + 115, + 116, + 111, + 114, + 121, + 32, + 77, + 117, + 115, + 101, + 117, + 109, + 46, + 32, + 73, + 116, + 32, + 114, + 101, + 112, + 114, + 101, + 115, + 101, + 110, + 116, + 115, + 32, + 97, + 32, + 77, + 97, + 103, + 110, + 105, + 116, + 117, + 100, + 101, + 32, + 53, + 46, + 51, + 32, + 101, + 97, + 114, + 116, + 104, + 113, + 117, + 97, + 107, + 101, + 32, + 119, + 105, + 116, + 104, + 32, + 73, + 68, + 32, + 117, + 115, + 55, + 48, + 48, + 48, + 109, + 57, + 55, + 54, + 32, + 119, + 104, + 105, + 99, + 104, + 32, + 104, + 97, + 115, + 32, + 97, + 110, + 32, + 101, + 112, + 105, + 99, + 101, + 110, + 116, + 114, + 101, + 32, + 110, + 111, + 114, + 116, + 104, + 101, + 114, + 110, + 32, + 69, + 97, + 115, + 116, + 32, + 80, + 97, + 99, + 105, + 102, + 105, + 99, + 32, + 82, + 105, + 115, + 101, + 32, + 97, + 110, + 100, + 32, + 111, + 99, + 99, + 117, + 114, + 114, + 101, + 100, + 32, + 97, + 116, + 32, + 77, + 111, + 110, + 44, + 32, + 48, + 49, + 32, + 65, + 112, + 114, + 32, + 50, + 48, + 50, + 52, + 32, + 49, + 52, + 58, + 52, + 53, + 58, + 49, + 54, + 32, + 71, + 77, + 84, + 46, + 32, + 84, + 104, + 101, + 32, + 118, + 101, + 114, + 105, + 102, + 105, + 101, + 100, + 32, + 115, + 111, + 117, + 114, + 99, + 101, + 32, + 111, + 102, + 32, + 116, + 104, + 105, + 115, + 32, + 100, + 97, + 116, + 97, + 32, + 97, + 114, + 116, + 105, + 102, + 97, + 99, + 116, + 32, + 119, + 97, + 115, + 32, + 116, + 104, + 101, + 32, + 85, + 110, + 105, + 116, + 101, + 100, + 32, + 83, + 116, + 97, + 116, + 101, + 115, + 32, + 71, + 101, + 111, + 108, + 111, + 103, + 105, + 99, + 97, + 108, + 32, + 83, + 117, + 114, + 118, + 101, + 121, + 32, + 40, + 85, + 83, + 71, + 83, + 41, + 46, + 32, + 70, + 111, + 114, + 32, + 109, + 111, + 114, + 101, + 32, + 105, + 110, + 102, + 111, + 114, + 109, + 97, + 116, + 105, + 111, + 110, + 32, + 118, + 105, + 115, + 105, + 116, + 32, + 104, + 116, + 116, + 112, + 115, + 58, + 47, + 47, + 100, + 97, + 116, + 97, + 104, + 105, + 115, + 116, + 111, + 114, + 121, + 46, + 111, + 114, + 103, + 47, + 46, + 34, + 44, + 34, + 101, + 120, + 116, + 101, + 114, + 110, + 97, + 108, + 95, + 117, + 114, + 108, + 34, + 58, + 34, + 104, + 116, + 116, + 112, + 115, + 58, + 47, + 47, + 109, + 117, + 115, + 101, + 117, + 109, + 46, + 100, + 97, + 116, + 97, + 104, + 105, + 115, + 116, + 111, + 114, + 121, + 46, + 111, + 114, + 103, + 47, + 101, + 118, + 101, + 110, + 116, + 47, + 81, + 85, + 65, + 75, + 69, + 47, + 117, + 115, + 55, + 48, + 48, + 48, + 109, + 57, + 55, + 54, + 34, + 44, + 34, + 112, + 114, + 111, + 112, + 101, + 114, + 116, + 105, + 101, + 115, + 34, + 58, + 123, + 34, + 109, + 97, + 103, + 110, + 105, + 116, + 117, + 100, + 101, + 34, + 58, + 53, + 46, + 51, + 44, + 34, + 99, + 108, + 97, + 115, + 115, + 34, + 58, + 34, + 77, + 53, + 34, + 44, + 34, + 100, + 101, + 112, + 116, + 104, + 34, + 58, + 49, + 48, + 44, + 34, + 108, + 97, + 116, + 105, + 116, + 117, + 100, + 101, + 34, + 58, + 56, + 46, + 50, + 53, + 49, + 44, + 34, + 108, + 111, + 110, + 103, + 105, + 116, + 117, + 100, + 101, + 34, + 58, + 45, + 49, + 48, + 51, + 46, + 50, + 50, + 54, + 44, + 34, + 112, + 108, + 97, + 99, + 101, + 34, + 58, + 34, + 110, + 111, + 114, + 116, + 104, + 101, + 114, + 110, + 32, + 69, + 97, + 115, + 116, + 32, + 80, + 97, + 99, + 105, + 102, + 105, + 99, + 32, + 82, + 105, + 115, + 101, + 34, + 44, + 34, + 115, + 111, + 117, + 114, + 99, + 101, + 34, + 58, + 34, + 85, + 83, + 71, + 83, + 34, + 44, + 34, + 115, + 117, + 98, + 84, + 121, + 112, + 101, + 34, + 58, + 34, + 101, + 97, + 114, + 116, + 104, + 113, + 117, + 97, + 107, + 101, + 34, + 44, + 34, + 116, + 105, + 109, + 101, + 34, + 58, + 34, + 50, + 48, + 50, + 52, + 45, + 48, + 52, + 45, + 48, + 49, + 84, + 49, + 52, + 58, + 52, + 53, + 58, + 49, + 54, + 46, + 49, + 48, + 57, + 90, + 34, + 44, + 34, + 116, + 121, + 112, + 101, + 34, + 58, + 34, + 113, + 117, + 97, + 107, + 101, + 34, + 44, + 34, + 117, + 114, + 108, + 34, + 58, + 34, + 104, + 116, + 116, + 112, + 115, + 58, + 47, + 47, + 101, + 97, + 114, + 116, + 104, + 113, + 117, + 97, + 107, + 101, + 46, + 117, + 115, + 103, + 115, + 46, + 103, + 111, + 118, + 47, + 101, + 97, + 114, + 116, + 104, + 113, + 117, + 97, + 107, + 101, + 115, + 47, + 101, + 118, + 101, + 110, + 116, + 112, + 97, + 103, + 101, + 47, + 117, + 115, + 55, + 48, + 48, + 48, + 109, + 57, + 55, + 54, + 34, + 125, + 44, + 34, + 109, + 105, + 109, + 101, + 95, + 116, + 121, + 112, + 101, + 34, + 58, + 34, + 105, + 109, + 97, + 103, + 101, + 47, + 112, + 110, + 103, + 34, + 44, + 34, + 105, + 100, + 34, + 58, + 34, + 117, + 115, + 55, + 48, + 48, + 48, + 109, + 57, + 55, + 54, + 34, + 44, + 34, + 116, + 105, + 116, + 108, + 101, + 34, + 58, + 34, + 77, + 32, + 53, + 46, + 51, + 32, + 45, + 32, + 110, + 111, + 114, + 116, + 104, + 101, + 114, + 110, + 32, + 69, + 97, + 115, + 116, + 32, + 80, + 97, + 99, + 105, + 102, + 105, + 99, + 32, + 82, + 105, + 115, + 101, + 34, + 125, + 163, + 115, + 110, + 100, + 196, + 32, + 33, + 241, + 1, + 96, + 244, + 23, + 132, + 139, + 101, + 97, + 191, + 102, + 57, + 174, + 169, + 228, + 165, + 82, + 114, + 49, + 155, + 20, + 81, + 136, + 220, + 207, + 33, + 248, + 74, + 26, + 189, + 145, + 164, + 116, + 121, + 112, + 101, + 164, + 97, + 99, + 102, + 103 + ], + "rekeyedSenderAuthAddress": "BKDYDIDVSZCP75JVCB76P3WBJRY6HWAIFDSEOKYHJY5WMNJ2UWJ65MYETU", + "rekeyedSenderSignedBytes": [ + 131, + 164, + 115, + 103, + 110, + 114, + 196, + 32, + 10, + 135, + 129, + 160, + 117, + 150, + 68, + 255, + 245, + 53, + 16, + 127, + 231, + 238, + 193, + 76, + 113, + 227, + 216, + 8, + 40, + 228, + 71, + 43, + 7, + 78, + 59, + 102, + 53, + 58, + 165, + 147, + 163, + 115, + 105, + 103, + 196, + 64, + 167, + 7, + 238, + 77, + 120, + 250, + 191, + 255, + 140, + 25, + 61, + 141, + 221, + 193, + 224, + 237, + 34, + 228, + 24, + 179, + 197, + 169, + 100, + 32, + 214, + 238, + 195, + 117, + 135, + 89, + 23, + 160, + 176, + 164, + 186, + 146, + 89, + 49, + 97, + 109, + 157, + 193, + 253, + 112, + 143, + 104, + 41, + 188, + 214, + 196, + 94, + 14, + 93, + 30, + 238, + 12, + 142, + 121, + 240, + 60, + 69, + 135, + 146, + 5, + 163, + 116, + 120, + 110, + 138, + 164, + 97, + 112, + 97, + 114, + 130, + 161, + 109, + 196, + 32, + 33, + 241, + 1, + 96, + 244, + 23, + 132, + 139, + 101, + 97, + 191, + 102, + 57, + 174, + 169, + 228, + 165, + 82, + 114, + 49, + 155, + 20, + 81, + 136, + 220, + 207, + 33, + 248, + 74, + 26, + 189, + 145, + 161, + 114, + 196, + 32, + 123, + 153, + 141, + 254, + 48, + 235, + 240, + 109, + 52, + 234, + 33, + 106, + 58, + 141, + 70, + 182, + 87, + 158, + 52, + 244, + 181, + 45, + 223, + 138, + 166, + 205, + 80, + 252, + 138, + 109, + 1, + 73, + 164, + 99, + 97, + 105, + 100, + 206, + 102, + 63, + 208, + 248, + 163, + 102, + 101, + 101, + 205, + 3, + 232, + 162, + 102, + 118, + 206, + 2, + 60, + 227, + 138, + 163, + 103, + 101, + 110, + 172, + 109, + 97, + 105, + 110, + 110, + 101, + 116, + 45, + 118, + 49, + 46, + 48, + 162, + 103, + 104, + 196, + 32, + 192, + 97, + 196, + 216, + 252, + 29, + 189, + 222, + 210, + 215, + 96, + 75, + 228, + 86, + 142, + 63, + 109, + 4, + 25, + 135, + 172, + 55, + 189, + 228, + 182, + 32, + 181, + 171, + 57, + 36, + 138, + 223, + 162, + 108, + 118, + 206, + 2, + 60, + 231, + 114, + 164, + 110, + 111, + 116, + 101, + 197, + 3, + 107, + 123, + 34, + 115, + 116, + 97, + 110, + 100, + 97, + 114, + 100, + 34, + 58, + 34, + 97, + 114, + 99, + 54, + 57, + 34, + 44, + 34, + 100, + 101, + 115, + 99, + 114, + 105, + 112, + 116, + 105, + 111, + 110, + 34, + 58, + 34, + 84, + 104, + 105, + 115, + 32, + 105, + 115, + 32, + 97, + 32, + 118, + 101, + 114, + 105, + 102, + 105, + 97, + 98, + 108, + 121, + 32, + 97, + 117, + 116, + 104, + 101, + 110, + 116, + 105, + 99, + 32, + 100, + 105, + 103, + 105, + 116, + 97, + 108, + 32, + 104, + 105, + 115, + 116, + 111, + 114, + 105, + 99, + 97, + 108, + 32, + 97, + 114, + 116, + 105, + 102, + 97, + 99, + 116, + 32, + 109, + 105, + 110, + 116, + 101, + 100, + 32, + 98, + 121, + 32, + 84, + 104, + 101, + 32, + 68, + 97, + 116, + 97, + 32, + 72, + 105, + 115, + 116, + 111, + 114, + 121, + 32, + 77, + 117, + 115, + 101, + 117, + 109, + 46, + 32, + 73, + 116, + 32, + 114, + 101, + 112, + 114, + 101, + 115, + 101, + 110, + 116, + 115, + 32, + 97, + 32, + 77, + 97, + 103, + 110, + 105, + 116, + 117, + 100, + 101, + 32, + 53, + 46, + 51, + 32, + 101, + 97, + 114, + 116, + 104, + 113, + 117, + 97, + 107, + 101, + 32, + 119, + 105, + 116, + 104, + 32, + 73, + 68, + 32, + 117, + 115, + 55, + 48, + 48, + 48, + 109, + 57, + 55, + 54, + 32, + 119, + 104, + 105, + 99, + 104, + 32, + 104, + 97, + 115, + 32, + 97, + 110, + 32, + 101, + 112, + 105, + 99, + 101, + 110, + 116, + 114, + 101, + 32, + 110, + 111, + 114, + 116, + 104, + 101, + 114, + 110, + 32, + 69, + 97, + 115, + 116, + 32, + 80, + 97, + 99, + 105, + 102, + 105, + 99, + 32, + 82, + 105, + 115, + 101, + 32, + 97, + 110, + 100, + 32, + 111, + 99, + 99, + 117, + 114, + 114, + 101, + 100, + 32, + 97, + 116, + 32, + 77, + 111, + 110, + 44, + 32, + 48, + 49, + 32, + 65, + 112, + 114, + 32, + 50, + 48, + 50, + 52, + 32, + 49, + 52, + 58, + 52, + 53, + 58, + 49, + 54, + 32, + 71, + 77, + 84, + 46, + 32, + 84, + 104, + 101, + 32, + 118, + 101, + 114, + 105, + 102, + 105, + 101, + 100, + 32, + 115, + 111, + 117, + 114, + 99, + 101, + 32, + 111, + 102, + 32, + 116, + 104, + 105, + 115, + 32, + 100, + 97, + 116, + 97, + 32, + 97, + 114, + 116, + 105, + 102, + 97, + 99, + 116, + 32, + 119, + 97, + 115, + 32, + 116, + 104, + 101, + 32, + 85, + 110, + 105, + 116, + 101, + 100, + 32, + 83, + 116, + 97, + 116, + 101, + 115, + 32, + 71, + 101, + 111, + 108, + 111, + 103, + 105, + 99, + 97, + 108, + 32, + 83, + 117, + 114, + 118, + 101, + 121, + 32, + 40, + 85, + 83, + 71, + 83, + 41, + 46, + 32, + 70, + 111, + 114, + 32, + 109, + 111, + 114, + 101, + 32, + 105, + 110, + 102, + 111, + 114, + 109, + 97, + 116, + 105, + 111, + 110, + 32, + 118, + 105, + 115, + 105, + 116, + 32, + 104, + 116, + 116, + 112, + 115, + 58, + 47, + 47, + 100, + 97, + 116, + 97, + 104, + 105, + 115, + 116, + 111, + 114, + 121, + 46, + 111, + 114, + 103, + 47, + 46, + 34, + 44, + 34, + 101, + 120, + 116, + 101, + 114, + 110, + 97, + 108, + 95, + 117, + 114, + 108, + 34, + 58, + 34, + 104, + 116, + 116, + 112, + 115, + 58, + 47, + 47, + 109, + 117, + 115, + 101, + 117, + 109, + 46, + 100, + 97, + 116, + 97, + 104, + 105, + 115, + 116, + 111, + 114, + 121, + 46, + 111, + 114, + 103, + 47, + 101, + 118, + 101, + 110, + 116, + 47, + 81, + 85, + 65, + 75, + 69, + 47, + 117, + 115, + 55, + 48, + 48, + 48, + 109, + 57, + 55, + 54, + 34, + 44, + 34, + 112, + 114, + 111, + 112, + 101, + 114, + 116, + 105, + 101, + 115, + 34, + 58, + 123, + 34, + 109, + 97, + 103, + 110, + 105, + 116, + 117, + 100, + 101, + 34, + 58, + 53, + 46, + 51, + 44, + 34, + 99, + 108, + 97, + 115, + 115, + 34, + 58, + 34, + 77, + 53, + 34, + 44, + 34, + 100, + 101, + 112, + 116, + 104, + 34, + 58, + 49, + 48, + 44, + 34, + 108, + 97, + 116, + 105, + 116, + 117, + 100, + 101, + 34, + 58, + 56, + 46, + 50, + 53, + 49, + 44, + 34, + 108, + 111, + 110, + 103, + 105, + 116, + 117, + 100, + 101, + 34, + 58, + 45, + 49, + 48, + 51, + 46, + 50, + 50, + 54, + 44, + 34, + 112, + 108, + 97, + 99, + 101, + 34, + 58, + 34, + 110, + 111, + 114, + 116, + 104, + 101, + 114, + 110, + 32, + 69, + 97, + 115, + 116, + 32, + 80, + 97, + 99, + 105, + 102, + 105, + 99, + 32, + 82, + 105, + 115, + 101, + 34, + 44, + 34, + 115, + 111, + 117, + 114, + 99, + 101, + 34, + 58, + 34, + 85, + 83, + 71, + 83, + 34, + 44, + 34, + 115, + 117, + 98, + 84, + 121, + 112, + 101, + 34, + 58, + 34, + 101, + 97, + 114, + 116, + 104, + 113, + 117, + 97, + 107, + 101, + 34, + 44, + 34, + 116, + 105, + 109, + 101, + 34, + 58, + 34, + 50, + 48, + 50, + 52, + 45, + 48, + 52, + 45, + 48, + 49, + 84, + 49, + 52, + 58, + 52, + 53, + 58, + 49, + 54, + 46, + 49, + 48, + 57, + 90, + 34, + 44, + 34, + 116, + 121, + 112, + 101, + 34, + 58, + 34, + 113, + 117, + 97, + 107, + 101, + 34, + 44, + 34, + 117, + 114, + 108, + 34, + 58, + 34, + 104, + 116, + 116, + 112, + 115, + 58, + 47, + 47, + 101, + 97, + 114, + 116, + 104, + 113, + 117, + 97, + 107, + 101, + 46, + 117, + 115, + 103, + 115, + 46, + 103, + 111, + 118, + 47, + 101, + 97, + 114, + 116, + 104, + 113, + 117, + 97, + 107, + 101, + 115, + 47, + 101, + 118, + 101, + 110, + 116, + 112, + 97, + 103, + 101, + 47, + 117, + 115, + 55, + 48, + 48, + 48, + 109, + 57, + 55, + 54, + 34, + 125, + 44, + 34, + 109, + 105, + 109, + 101, + 95, + 116, + 121, + 112, + 101, + 34, + 58, + 34, + 105, + 109, + 97, + 103, + 101, + 47, + 112, + 110, + 103, + 34, + 44, + 34, + 105, + 100, + 34, + 58, + 34, + 117, + 115, + 55, + 48, + 48, + 48, + 109, + 57, + 55, + 54, + 34, + 44, + 34, + 116, + 105, + 116, + 108, + 101, + 34, + 58, + 34, + 77, + 32, + 53, + 46, + 51, + 32, + 45, + 32, + 110, + 111, + 114, + 116, + 104, + 101, + 114, + 110, + 32, + 69, + 97, + 115, + 116, + 32, + 80, + 97, + 99, + 105, + 102, + 105, + 99, + 32, + 82, + 105, + 115, + 101, + 34, + 125, + 163, + 115, + 110, + 100, + 196, + 32, + 33, + 241, + 1, + 96, + 244, + 23, + 132, + 139, + 101, + 97, + 191, + 102, + 57, + 174, + 169, + 228, + 165, + 82, + 114, + 49, + 155, + 20, + 81, + 136, + 220, + 207, + 33, + 248, + 74, + 26, + 189, + 145, + 164, + 116, + 121, + 112, + 101, + 164, + 97, + 99, + 102, + 103 + ], + "signedBytes": [ + 130, + 163, + 115, + 105, + 103, + 196, + 64, + 167, + 7, + 238, + 77, + 120, + 250, + 191, + 255, + 140, + 25, + 61, + 141, + 221, + 193, + 224, + 237, + 34, + 228, + 24, + 179, + 197, + 169, + 100, + 32, + 214, + 238, + 195, + 117, + 135, + 89, + 23, + 160, + 176, + 164, + 186, + 146, + 89, + 49, + 97, + 109, + 157, + 193, + 253, + 112, + 143, + 104, + 41, + 188, + 214, + 196, + 94, + 14, + 93, + 30, + 238, + 12, + 142, + 121, + 240, + 60, + 69, + 135, + 146, + 5, + 163, + 116, + 120, + 110, + 138, + 164, + 97, + 112, + 97, + 114, + 130, + 161, + 109, + 196, + 32, + 33, + 241, + 1, + 96, + 244, + 23, + 132, + 139, + 101, + 97, + 191, + 102, + 57, + 174, + 169, + 228, + 165, + 82, + 114, + 49, + 155, + 20, + 81, + 136, + 220, + 207, + 33, + 248, + 74, + 26, + 189, + 145, + 161, + 114, + 196, + 32, + 123, + 153, + 141, + 254, + 48, + 235, + 240, + 109, + 52, + 234, + 33, + 106, + 58, + 141, + 70, + 182, + 87, + 158, + 52, + 244, + 181, + 45, + 223, + 138, + 166, + 205, + 80, + 252, + 138, + 109, + 1, + 73, + 164, + 99, + 97, + 105, + 100, + 206, + 102, + 63, + 208, + 248, + 163, + 102, + 101, + 101, + 205, + 3, + 232, + 162, + 102, + 118, + 206, + 2, + 60, + 227, + 138, + 163, + 103, + 101, + 110, + 172, + 109, + 97, + 105, + 110, + 110, + 101, + 116, + 45, + 118, + 49, + 46, + 48, + 162, + 103, + 104, + 196, + 32, + 192, + 97, + 196, + 216, + 252, + 29, + 189, + 222, + 210, + 215, + 96, + 75, + 228, + 86, + 142, + 63, + 109, + 4, + 25, + 135, + 172, + 55, + 189, + 228, + 182, + 32, + 181, + 171, + 57, + 36, + 138, + 223, + 162, + 108, + 118, + 206, + 2, + 60, + 231, + 114, + 164, + 110, + 111, + 116, + 101, + 197, + 3, + 107, + 123, + 34, + 115, + 116, + 97, + 110, + 100, + 97, + 114, + 100, + 34, + 58, + 34, + 97, + 114, + 99, + 54, + 57, + 34, + 44, + 34, + 100, + 101, + 115, + 99, + 114, + 105, + 112, + 116, + 105, + 111, + 110, + 34, + 58, + 34, + 84, + 104, + 105, + 115, + 32, + 105, + 115, + 32, + 97, + 32, + 118, + 101, + 114, + 105, + 102, + 105, + 97, + 98, + 108, + 121, + 32, + 97, + 117, + 116, + 104, + 101, + 110, + 116, + 105, + 99, + 32, + 100, + 105, + 103, + 105, + 116, + 97, + 108, + 32, + 104, + 105, + 115, + 116, + 111, + 114, + 105, + 99, + 97, + 108, + 32, + 97, + 114, + 116, + 105, + 102, + 97, + 99, + 116, + 32, + 109, + 105, + 110, + 116, + 101, + 100, + 32, + 98, + 121, + 32, + 84, + 104, + 101, + 32, + 68, + 97, + 116, + 97, + 32, + 72, + 105, + 115, + 116, + 111, + 114, + 121, + 32, + 77, + 117, + 115, + 101, + 117, + 109, + 46, + 32, + 73, + 116, + 32, + 114, + 101, + 112, + 114, + 101, + 115, + 101, + 110, + 116, + 115, + 32, + 97, + 32, + 77, + 97, + 103, + 110, + 105, + 116, + 117, + 100, + 101, + 32, + 53, + 46, + 51, + 32, + 101, + 97, + 114, + 116, + 104, + 113, + 117, + 97, + 107, + 101, + 32, + 119, + 105, + 116, + 104, + 32, + 73, + 68, + 32, + 117, + 115, + 55, + 48, + 48, + 48, + 109, + 57, + 55, + 54, + 32, + 119, + 104, + 105, + 99, + 104, + 32, + 104, + 97, + 115, + 32, + 97, + 110, + 32, + 101, + 112, + 105, + 99, + 101, + 110, + 116, + 114, + 101, + 32, + 110, + 111, + 114, + 116, + 104, + 101, + 114, + 110, + 32, + 69, + 97, + 115, + 116, + 32, + 80, + 97, + 99, + 105, + 102, + 105, + 99, + 32, + 82, + 105, + 115, + 101, + 32, + 97, + 110, + 100, + 32, + 111, + 99, + 99, + 117, + 114, + 114, + 101, + 100, + 32, + 97, + 116, + 32, + 77, + 111, + 110, + 44, + 32, + 48, + 49, + 32, + 65, + 112, + 114, + 32, + 50, + 48, + 50, + 52, + 32, + 49, + 52, + 58, + 52, + 53, + 58, + 49, + 54, + 32, + 71, + 77, + 84, + 46, + 32, + 84, + 104, + 101, + 32, + 118, + 101, + 114, + 105, + 102, + 105, + 101, + 100, + 32, + 115, + 111, + 117, + 114, + 99, + 101, + 32, + 111, + 102, + 32, + 116, + 104, + 105, + 115, + 32, + 100, + 97, + 116, + 97, + 32, + 97, + 114, + 116, + 105, + 102, + 97, + 99, + 116, + 32, + 119, + 97, + 115, + 32, + 116, + 104, + 101, + 32, + 85, + 110, + 105, + 116, + 101, + 100, + 32, + 83, + 116, + 97, + 116, + 101, + 115, + 32, + 71, + 101, + 111, + 108, + 111, + 103, + 105, + 99, + 97, + 108, + 32, + 83, + 117, + 114, + 118, + 101, + 121, + 32, + 40, + 85, + 83, + 71, + 83, + 41, + 46, + 32, + 70, + 111, + 114, + 32, + 109, + 111, + 114, + 101, + 32, + 105, + 110, + 102, + 111, + 114, + 109, + 97, + 116, + 105, + 111, + 110, + 32, + 118, + 105, + 115, + 105, + 116, + 32, + 104, + 116, + 116, + 112, + 115, + 58, + 47, + 47, + 100, + 97, + 116, + 97, + 104, + 105, + 115, + 116, + 111, + 114, + 121, + 46, + 111, + 114, + 103, + 47, + 46, + 34, + 44, + 34, + 101, + 120, + 116, + 101, + 114, + 110, + 97, + 108, + 95, + 117, + 114, + 108, + 34, + 58, + 34, + 104, + 116, + 116, + 112, + 115, + 58, + 47, + 47, + 109, + 117, + 115, + 101, + 117, + 109, + 46, + 100, + 97, + 116, + 97, + 104, + 105, + 115, + 116, + 111, + 114, + 121, + 46, + 111, + 114, + 103, + 47, + 101, + 118, + 101, + 110, + 116, + 47, + 81, + 85, + 65, + 75, + 69, + 47, + 117, + 115, + 55, + 48, + 48, + 48, + 109, + 57, + 55, + 54, + 34, + 44, + 34, + 112, + 114, + 111, + 112, + 101, + 114, + 116, + 105, + 101, + 115, + 34, + 58, + 123, + 34, + 109, + 97, + 103, + 110, + 105, + 116, + 117, + 100, + 101, + 34, + 58, + 53, + 46, + 51, + 44, + 34, + 99, + 108, + 97, + 115, + 115, + 34, + 58, + 34, + 77, + 53, + 34, + 44, + 34, + 100, + 101, + 112, + 116, + 104, + 34, + 58, + 49, + 48, + 44, + 34, + 108, + 97, + 116, + 105, + 116, + 117, + 100, + 101, + 34, + 58, + 56, + 46, + 50, + 53, + 49, + 44, + 34, + 108, + 111, + 110, + 103, + 105, + 116, + 117, + 100, + 101, + 34, + 58, + 45, + 49, + 48, + 51, + 46, + 50, + 50, + 54, + 44, + 34, + 112, + 108, + 97, + 99, + 101, + 34, + 58, + 34, + 110, + 111, + 114, + 116, + 104, + 101, + 114, + 110, + 32, + 69, + 97, + 115, + 116, + 32, + 80, + 97, + 99, + 105, + 102, + 105, + 99, + 32, + 82, + 105, + 115, + 101, + 34, + 44, + 34, + 115, + 111, + 117, + 114, + 99, + 101, + 34, + 58, + 34, + 85, + 83, + 71, + 83, + 34, + 44, + 34, + 115, + 117, + 98, + 84, + 121, + 112, + 101, + 34, + 58, + 34, + 101, + 97, + 114, + 116, + 104, + 113, + 117, + 97, + 107, + 101, + 34, + 44, + 34, + 116, + 105, + 109, + 101, + 34, + 58, + 34, + 50, + 48, + 50, + 52, + 45, + 48, + 52, + 45, + 48, + 49, + 84, + 49, + 52, + 58, + 52, + 53, + 58, + 49, + 54, + 46, + 49, + 48, + 57, + 90, + 34, + 44, + 34, + 116, + 121, + 112, + 101, + 34, + 58, + 34, + 113, + 117, + 97, + 107, + 101, + 34, + 44, + 34, + 117, + 114, + 108, + 34, + 58, + 34, + 104, + 116, + 116, + 112, + 115, + 58, + 47, + 47, + 101, + 97, + 114, + 116, + 104, + 113, + 117, + 97, + 107, + 101, + 46, + 117, + 115, + 103, + 115, + 46, + 103, + 111, + 118, + 47, + 101, + 97, + 114, + 116, + 104, + 113, + 117, + 97, + 107, + 101, + 115, + 47, + 101, + 118, + 101, + 110, + 116, + 112, + 97, + 103, + 101, + 47, + 117, + 115, + 55, + 48, + 48, + 48, + 109, + 57, + 55, + 54, + 34, + 125, + 44, + 34, + 109, + 105, + 109, + 101, + 95, + 116, + 121, + 112, + 101, + 34, + 58, + 34, + 105, + 109, + 97, + 103, + 101, + 47, + 112, + 110, + 103, + 34, + 44, + 34, + 105, + 100, + 34, + 58, + 34, + 117, + 115, + 55, + 48, + 48, + 48, + 109, + 57, + 55, + 54, + 34, + 44, + 34, + 116, + 105, + 116, + 108, + 101, + 34, + 58, + 34, + 77, + 32, + 53, + 46, + 51, + 32, + 45, + 32, + 110, + 111, + 114, + 116, + 104, + 101, + 114, + 110, + 32, + 69, + 97, + 115, + 116, + 32, + 80, + 97, + 99, + 105, + 102, + 105, + 99, + 32, + 82, + 105, + 115, + 101, + 34, + 125, + 163, + 115, + 110, + 100, + 196, + 32, + 33, + 241, + 1, + 96, + 244, + 23, + 132, + 139, + 101, + 97, + 191, + 102, + 57, + 174, + 169, + 228, + 165, + 82, + 114, + 49, + 155, + 20, + 81, + 136, + 220, + 207, + 33, + 248, + 74, + 26, + 189, + 145, + 164, + 116, + 121, + 112, + 101, + 164, + 97, + 99, + 102, + 103 + ], + "signingPrivateKey": [ + 2, + 205, + 103, + 33, + 67, + 14, + 82, + 196, + 115, + 196, + 206, + 254, + 50, + 110, + 63, + 182, + 149, + 229, + 184, + 216, + 93, + 11, + 13, + 99, + 69, + 213, + 218, + 165, + 134, + 118, + 47, + 44 + ], + "transaction": { + "assetConfig": { + "assetId": 1715458296, + "manager": "EHYQCYHUC6CIWZLBX5TDTLVJ4SSVE4RRTMKFDCG4Z4Q7QSQ2XWIQPMKBPU", + "reserve": "POMY37RQ5PYG2NHKEFVDVDKGWZLZ4NHUWUW57CVGZVIPZCTNAFE2JM7XQU" + }, + "fee": 1000, + "firstValid": 37544842, + "genesisHash": [ + 192, + 97, + 196, + 216, + 252, + 29, + 189, + 222, + 210, + 215, + 96, + 75, + 228, + 86, + 142, + 63, + 109, + 4, + 25, + 135, + 172, + 55, + 189, + 228, + 182, + 32, + 181, + 171, + 57, + 36, + 138, + 223 + ], + "genesisId": "mainnet-v1.0", + "lastValid": 37545842, + "note": [ + 123, + 34, + 115, + 116, + 97, + 110, + 100, + 97, + 114, + 100, + 34, + 58, + 34, + 97, + 114, + 99, + 54, + 57, + 34, + 44, + 34, + 100, + 101, + 115, + 99, + 114, + 105, + 112, + 116, + 105, + 111, + 110, + 34, + 58, + 34, + 84, + 104, + 105, + 115, + 32, + 105, + 115, + 32, + 97, + 32, + 118, + 101, + 114, + 105, + 102, + 105, + 97, + 98, + 108, + 121, + 32, + 97, + 117, + 116, + 104, + 101, + 110, + 116, + 105, + 99, + 32, + 100, + 105, + 103, + 105, + 116, + 97, + 108, + 32, + 104, + 105, + 115, + 116, + 111, + 114, + 105, + 99, + 97, + 108, + 32, + 97, + 114, + 116, + 105, + 102, + 97, + 99, + 116, + 32, + 109, + 105, + 110, + 116, + 101, + 100, + 32, + 98, + 121, + 32, + 84, + 104, + 101, + 32, + 68, + 97, + 116, + 97, + 32, + 72, + 105, + 115, + 116, + 111, + 114, + 121, + 32, + 77, + 117, + 115, + 101, + 117, + 109, + 46, + 32, + 73, + 116, + 32, + 114, + 101, + 112, + 114, + 101, + 115, + 101, + 110, + 116, + 115, + 32, + 97, + 32, + 77, + 97, + 103, + 110, + 105, + 116, + 117, + 100, + 101, + 32, + 53, + 46, + 51, + 32, + 101, + 97, + 114, + 116, + 104, + 113, + 117, + 97, + 107, + 101, + 32, + 119, + 105, + 116, + 104, + 32, + 73, + 68, + 32, + 117, + 115, + 55, + 48, + 48, + 48, + 109, + 57, + 55, + 54, + 32, + 119, + 104, + 105, + 99, + 104, + 32, + 104, + 97, + 115, + 32, + 97, + 110, + 32, + 101, + 112, + 105, + 99, + 101, + 110, + 116, + 114, + 101, + 32, + 110, + 111, + 114, + 116, + 104, + 101, + 114, + 110, + 32, + 69, + 97, + 115, + 116, + 32, + 80, + 97, + 99, + 105, + 102, + 105, + 99, + 32, + 82, + 105, + 115, + 101, + 32, + 97, + 110, + 100, + 32, + 111, + 99, + 99, + 117, + 114, + 114, + 101, + 100, + 32, + 97, + 116, + 32, + 77, + 111, + 110, + 44, + 32, + 48, + 49, + 32, + 65, + 112, + 114, + 32, + 50, + 48, + 50, + 52, + 32, + 49, + 52, + 58, + 52, + 53, + 58, + 49, + 54, + 32, + 71, + 77, + 84, + 46, + 32, + 84, + 104, + 101, + 32, + 118, + 101, + 114, + 105, + 102, + 105, + 101, + 100, + 32, + 115, + 111, + 117, + 114, + 99, + 101, + 32, + 111, + 102, + 32, + 116, + 104, + 105, + 115, + 32, + 100, + 97, + 116, + 97, + 32, + 97, + 114, + 116, + 105, + 102, + 97, + 99, + 116, + 32, + 119, + 97, + 115, + 32, + 116, + 104, + 101, + 32, + 85, + 110, + 105, + 116, + 101, + 100, + 32, + 83, + 116, + 97, + 116, + 101, + 115, + 32, + 71, + 101, + 111, + 108, + 111, + 103, + 105, + 99, + 97, + 108, + 32, + 83, + 117, + 114, + 118, + 101, + 121, + 32, + 40, + 85, + 83, + 71, + 83, + 41, + 46, + 32, + 70, + 111, + 114, + 32, + 109, + 111, + 114, + 101, + 32, + 105, + 110, + 102, + 111, + 114, + 109, + 97, + 116, + 105, + 111, + 110, + 32, + 118, + 105, + 115, + 105, + 116, + 32, + 104, + 116, + 116, + 112, + 115, + 58, + 47, + 47, + 100, + 97, + 116, + 97, + 104, + 105, + 115, + 116, + 111, + 114, + 121, + 46, + 111, + 114, + 103, + 47, + 46, + 34, + 44, + 34, + 101, + 120, + 116, + 101, + 114, + 110, + 97, + 108, + 95, + 117, + 114, + 108, + 34, + 58, + 34, + 104, + 116, + 116, + 112, + 115, + 58, + 47, + 47, + 109, + 117, + 115, + 101, + 117, + 109, + 46, + 100, + 97, + 116, + 97, + 104, + 105, + 115, + 116, + 111, + 114, + 121, + 46, + 111, + 114, + 103, + 47, + 101, + 118, + 101, + 110, + 116, + 47, + 81, + 85, + 65, + 75, + 69, + 47, + 117, + 115, + 55, + 48, + 48, + 48, + 109, + 57, + 55, + 54, + 34, + 44, + 34, + 112, + 114, + 111, + 112, + 101, + 114, + 116, + 105, + 101, + 115, + 34, + 58, + 123, + 34, + 109, + 97, + 103, + 110, + 105, + 116, + 117, + 100, + 101, + 34, + 58, + 53, + 46, + 51, + 44, + 34, + 99, + 108, + 97, + 115, + 115, + 34, + 58, + 34, + 77, + 53, + 34, + 44, + 34, + 100, + 101, + 112, + 116, + 104, + 34, + 58, + 49, + 48, + 44, + 34, + 108, + 97, + 116, + 105, + 116, + 117, + 100, + 101, + 34, + 58, + 56, + 46, + 50, + 53, + 49, + 44, + 34, + 108, + 111, + 110, + 103, + 105, + 116, + 117, + 100, + 101, + 34, + 58, + 45, + 49, + 48, + 51, + 46, + 50, + 50, + 54, + 44, + 34, + 112, + 108, + 97, + 99, + 101, + 34, + 58, + 34, + 110, + 111, + 114, + 116, + 104, + 101, + 114, + 110, + 32, + 69, + 97, + 115, + 116, + 32, + 80, + 97, + 99, + 105, + 102, + 105, + 99, + 32, + 82, + 105, + 115, + 101, + 34, + 44, + 34, + 115, + 111, + 117, + 114, + 99, + 101, + 34, + 58, + 34, + 85, + 83, + 71, + 83, + 34, + 44, + 34, + 115, + 117, + 98, + 84, + 121, + 112, + 101, + 34, + 58, + 34, + 101, + 97, + 114, + 116, + 104, + 113, + 117, + 97, + 107, + 101, + 34, + 44, + 34, + 116, + 105, + 109, + 101, + 34, + 58, + 34, + 50, + 48, + 50, + 52, + 45, + 48, + 52, + 45, + 48, + 49, + 84, + 49, + 52, + 58, + 52, + 53, + 58, + 49, + 54, + 46, + 49, + 48, + 57, + 90, + 34, + 44, + 34, + 116, + 121, + 112, + 101, + 34, + 58, + 34, + 113, + 117, + 97, + 107, + 101, + 34, + 44, + 34, + 117, + 114, + 108, + 34, + 58, + 34, + 104, + 116, + 116, + 112, + 115, + 58, + 47, + 47, + 101, + 97, + 114, + 116, + 104, + 113, + 117, + 97, + 107, + 101, + 46, + 117, + 115, + 103, + 115, + 46, + 103, + 111, + 118, + 47, + 101, + 97, + 114, + 116, + 104, + 113, + 117, + 97, + 107, + 101, + 115, + 47, + 101, + 118, + 101, + 110, + 116, + 112, + 97, + 103, + 101, + 47, + 117, + 115, + 55, + 48, + 48, + 48, + 109, + 57, + 55, + 54, + 34, + 125, + 44, + 34, + 109, + 105, + 109, + 101, + 95, + 116, + 121, + 112, + 101, + 34, + 58, + 34, + 105, + 109, + 97, + 103, + 101, + 47, + 112, + 110, + 103, + 34, + 44, + 34, + 105, + 100, + 34, + 58, + 34, + 117, + 115, + 55, + 48, + 48, + 48, + 109, + 57, + 55, + 54, + 34, + 44, + 34, + 116, + 105, + 116, + 108, + 101, + 34, + 58, + 34, + 77, + 32, + 53, + 46, + 51, + 32, + 45, + 32, + 110, + 111, + 114, + 116, + 104, + 101, + 114, + 110, + 32, + 69, + 97, + 115, + 116, + 32, + 80, + 97, + 99, + 105, + 102, + 105, + 99, + 32, + 82, + 105, + 115, + 101, + 34, + 125 + ], + "sender": "EHYQCYHUC6CIWZLBX5TDTLVJ4SSVE4RRTMKFDCG4Z4Q7QSQ2XWIQPMKBPU", + "transactionType": "AssetConfig" + }, + "unsignedBytes": [ + 84, + 88, + 138, + 164, + 97, + 112, + 97, + 114, + 130, + 161, + 109, + 196, + 32, + 33, + 241, + 1, + 96, + 244, + 23, + 132, + 139, + 101, + 97, + 191, + 102, + 57, + 174, + 169, + 228, + 165, + 82, + 114, + 49, + 155, + 20, + 81, + 136, + 220, + 207, + 33, + 248, + 74, + 26, + 189, + 145, + 161, + 114, + 196, + 32, + 123, + 153, + 141, + 254, + 48, + 235, + 240, + 109, + 52, + 234, + 33, + 106, + 58, + 141, + 70, + 182, + 87, + 158, + 52, + 244, + 181, + 45, + 223, + 138, + 166, + 205, + 80, + 252, + 138, + 109, + 1, + 73, + 164, + 99, + 97, + 105, + 100, + 206, + 102, + 63, + 208, + 248, + 163, + 102, + 101, + 101, + 205, + 3, + 232, + 162, + 102, + 118, + 206, + 2, + 60, + 227, + 138, + 163, + 103, + 101, + 110, + 172, + 109, + 97, + 105, + 110, + 110, + 101, + 116, + 45, + 118, + 49, + 46, + 48, + 162, + 103, + 104, + 196, + 32, + 192, + 97, + 196, + 216, + 252, + 29, + 189, + 222, + 210, + 215, + 96, + 75, + 228, + 86, + 142, + 63, + 109, + 4, + 25, + 135, + 172, + 55, + 189, + 228, + 182, + 32, + 181, + 171, + 57, + 36, + 138, + 223, + 162, + 108, + 118, + 206, + 2, + 60, + 231, + 114, + 164, + 110, + 111, + 116, + 101, + 197, + 3, + 107, + 123, + 34, + 115, + 116, + 97, + 110, + 100, + 97, + 114, + 100, + 34, + 58, + 34, + 97, + 114, + 99, + 54, + 57, + 34, + 44, + 34, + 100, + 101, + 115, + 99, + 114, + 105, + 112, + 116, + 105, + 111, + 110, + 34, + 58, + 34, + 84, + 104, + 105, + 115, + 32, + 105, + 115, + 32, + 97, + 32, + 118, + 101, + 114, + 105, + 102, + 105, + 97, + 98, + 108, + 121, + 32, + 97, + 117, + 116, + 104, + 101, + 110, + 116, + 105, + 99, + 32, + 100, + 105, + 103, + 105, + 116, + 97, + 108, + 32, + 104, + 105, + 115, + 116, + 111, + 114, + 105, + 99, + 97, + 108, + 32, + 97, + 114, + 116, + 105, + 102, + 97, + 99, + 116, + 32, + 109, + 105, + 110, + 116, + 101, + 100, + 32, + 98, + 121, + 32, + 84, + 104, + 101, + 32, + 68, + 97, + 116, + 97, + 32, + 72, + 105, + 115, + 116, + 111, + 114, + 121, + 32, + 77, + 117, + 115, + 101, + 117, + 109, + 46, + 32, + 73, + 116, + 32, + 114, + 101, + 112, + 114, + 101, + 115, + 101, + 110, + 116, + 115, + 32, + 97, + 32, + 77, + 97, + 103, + 110, + 105, + 116, + 117, + 100, + 101, + 32, + 53, + 46, + 51, + 32, + 101, + 97, + 114, + 116, + 104, + 113, + 117, + 97, + 107, + 101, + 32, + 119, + 105, + 116, + 104, + 32, + 73, + 68, + 32, + 117, + 115, + 55, + 48, + 48, + 48, + 109, + 57, + 55, + 54, + 32, + 119, + 104, + 105, + 99, + 104, + 32, + 104, + 97, + 115, + 32, + 97, + 110, + 32, + 101, + 112, + 105, + 99, + 101, + 110, + 116, + 114, + 101, + 32, + 110, + 111, + 114, + 116, + 104, + 101, + 114, + 110, + 32, + 69, + 97, + 115, + 116, + 32, + 80, + 97, + 99, + 105, + 102, + 105, + 99, + 32, + 82, + 105, + 115, + 101, + 32, + 97, + 110, + 100, + 32, + 111, + 99, + 99, + 117, + 114, + 114, + 101, + 100, + 32, + 97, + 116, + 32, + 77, + 111, + 110, + 44, + 32, + 48, + 49, + 32, + 65, + 112, + 114, + 32, + 50, + 48, + 50, + 52, + 32, + 49, + 52, + 58, + 52, + 53, + 58, + 49, + 54, + 32, + 71, + 77, + 84, + 46, + 32, + 84, + 104, + 101, + 32, + 118, + 101, + 114, + 105, + 102, + 105, + 101, + 100, + 32, + 115, + 111, + 117, + 114, + 99, + 101, + 32, + 111, + 102, + 32, + 116, + 104, + 105, + 115, + 32, + 100, + 97, + 116, + 97, + 32, + 97, + 114, + 116, + 105, + 102, + 97, + 99, + 116, + 32, + 119, + 97, + 115, + 32, + 116, + 104, + 101, + 32, + 85, + 110, + 105, + 116, + 101, + 100, + 32, + 83, + 116, + 97, + 116, + 101, + 115, + 32, + 71, + 101, + 111, + 108, + 111, + 103, + 105, + 99, + 97, + 108, + 32, + 83, + 117, + 114, + 118, + 101, + 121, + 32, + 40, + 85, + 83, + 71, + 83, + 41, + 46, + 32, + 70, + 111, + 114, + 32, + 109, + 111, + 114, + 101, + 32, + 105, + 110, + 102, + 111, + 114, + 109, + 97, + 116, + 105, + 111, + 110, + 32, + 118, + 105, + 115, + 105, + 116, + 32, + 104, + 116, + 116, + 112, + 115, + 58, + 47, + 47, + 100, + 97, + 116, + 97, + 104, + 105, + 115, + 116, + 111, + 114, + 121, + 46, + 111, + 114, + 103, + 47, + 46, + 34, + 44, + 34, + 101, + 120, + 116, + 101, + 114, + 110, + 97, + 108, + 95, + 117, + 114, + 108, + 34, + 58, + 34, + 104, + 116, + 116, + 112, + 115, + 58, + 47, + 47, + 109, + 117, + 115, + 101, + 117, + 109, + 46, + 100, + 97, + 116, + 97, + 104, + 105, + 115, + 116, + 111, + 114, + 121, + 46, + 111, + 114, + 103, + 47, + 101, + 118, + 101, + 110, + 116, + 47, + 81, + 85, + 65, + 75, + 69, + 47, + 117, + 115, + 55, + 48, + 48, + 48, + 109, + 57, + 55, + 54, + 34, + 44, + 34, + 112, + 114, + 111, + 112, + 101, + 114, + 116, + 105, + 101, + 115, + 34, + 58, + 123, + 34, + 109, + 97, + 103, + 110, + 105, + 116, + 117, + 100, + 101, + 34, + 58, + 53, + 46, + 51, + 44, + 34, + 99, + 108, + 97, + 115, + 115, + 34, + 58, + 34, + 77, + 53, + 34, + 44, + 34, + 100, + 101, + 112, + 116, + 104, + 34, + 58, + 49, + 48, + 44, + 34, + 108, + 97, + 116, + 105, + 116, + 117, + 100, + 101, + 34, + 58, + 56, + 46, + 50, + 53, + 49, + 44, + 34, + 108, + 111, + 110, + 103, + 105, + 116, + 117, + 100, + 101, + 34, + 58, + 45, + 49, + 48, + 51, + 46, + 50, + 50, + 54, + 44, + 34, + 112, + 108, + 97, + 99, + 101, + 34, + 58, + 34, + 110, + 111, + 114, + 116, + 104, + 101, + 114, + 110, + 32, + 69, + 97, + 115, + 116, + 32, + 80, + 97, + 99, + 105, + 102, + 105, + 99, + 32, + 82, + 105, + 115, + 101, + 34, + 44, + 34, + 115, + 111, + 117, + 114, + 99, + 101, + 34, + 58, + 34, + 85, + 83, + 71, + 83, + 34, + 44, + 34, + 115, + 117, + 98, + 84, + 121, + 112, + 101, + 34, + 58, + 34, + 101, + 97, + 114, + 116, + 104, + 113, + 117, + 97, + 107, + 101, + 34, + 44, + 34, + 116, + 105, + 109, + 101, + 34, + 58, + 34, + 50, + 48, + 50, + 52, + 45, + 48, + 52, + 45, + 48, + 49, + 84, + 49, + 52, + 58, + 52, + 53, + 58, + 49, + 54, + 46, + 49, + 48, + 57, + 90, + 34, + 44, + 34, + 116, + 121, + 112, + 101, + 34, + 58, + 34, + 113, + 117, + 97, + 107, + 101, + 34, + 44, + 34, + 117, + 114, + 108, + 34, + 58, + 34, + 104, + 116, + 116, + 112, + 115, + 58, + 47, + 47, + 101, + 97, + 114, + 116, + 104, + 113, + 117, + 97, + 107, + 101, + 46, + 117, + 115, + 103, + 115, + 46, + 103, + 111, + 118, + 47, + 101, + 97, + 114, + 116, + 104, + 113, + 117, + 97, + 107, + 101, + 115, + 47, + 101, + 118, + 101, + 110, + 116, + 112, + 97, + 103, + 101, + 47, + 117, + 115, + 55, + 48, + 48, + 48, + 109, + 57, + 55, + 54, + 34, + 125, + 44, + 34, + 109, + 105, + 109, + 101, + 95, + 116, + 121, + 112, + 101, + 34, + 58, + 34, + 105, + 109, + 97, + 103, + 101, + 47, + 112, + 110, + 103, + 34, + 44, + 34, + 105, + 100, + 34, + 58, + 34, + 117, + 115, + 55, + 48, + 48, + 48, + 109, + 57, + 55, + 54, + 34, + 44, + 34, + 116, + 105, + 116, + 108, + 101, + 34, + 58, + 34, + 77, + 32, + 53, + 46, + 51, + 32, + 45, + 32, + 110, + 111, + 114, + 116, + 104, + 101, + 114, + 110, + 32, + 69, + 97, + 115, + 116, + 32, + 80, + 97, + 99, + 105, + 102, + 105, + 99, + 32, + 82, + 105, + 115, + 101, + 34, + 125, + 163, + 115, + 110, + 100, + 196, + 32, + 33, + 241, + 1, + 96, + 244, + 23, + 132, + 139, + 101, + 97, + 191, + 102, + 57, + 174, + 169, + 228, + 165, + 82, + 114, + 49, + 155, + 20, + 81, + 136, + 220, + 207, + 33, + 248, + 74, + 26, + 189, + 145, + 164, + 116, + 121, + 112, + 101, + 164, + 97, + 99, + 102, + 103 + ] + }, + "assetCreate": { + "id": "NXAHS2NA46DJHIULXYPJV2NOJSKKFFNFFXRZP35TA5IDCZNE2MUA", + "idRaw": [ + 109, + 192, + 121, + 105, + 160, + 231, + 134, + 147, + 162, + 139, + 190, + 30, + 154, + 233, + 174, + 76, + 148, + 162, + 149, + 165, + 45, + 227, + 151, + 239, + 179, + 7, + 80, + 49, + 101, + 164, + 211, + 40 + ], + "multisigAddresses": [ + "424ZV7KBBUJ52DUKP2KLQ6I5GBOHKBXOW7Q7UQIOOYNDWYRM4EKOSMVVRI", + "NY6DHEEFW73R2NUWY562U2NNKSKBKVYY5OOQFLD3M2II5RUNKRZDEGUGEA" + ], + "multisigSignedBytes": [ + 130, + 164, + 109, + 115, + 105, + 103, + 131, + 166, + 115, + 117, + 98, + 115, + 105, + 103, + 146, + 130, + 162, + 112, + 107, + 196, + 32, + 230, + 185, + 154, + 253, + 65, + 13, + 19, + 221, + 14, + 138, + 126, + 148, + 184, + 121, + 29, + 48, + 92, + 117, + 6, + 238, + 183, + 225, + 250, + 65, + 14, + 118, + 26, + 59, + 98, + 44, + 225, + 20, + 161, + 115, + 196, + 64, + 112, + 145, + 56, + 227, + 113, + 140, + 12, + 244, + 18, + 159, + 231, + 215, + 162, + 182, + 61, + 52, + 222, + 56, + 163, + 186, + 140, + 29, + 79, + 73, + 177, + 159, + 105, + 98, + 249, + 111, + 182, + 47, + 113, + 162, + 27, + 56, + 210, + 69, + 94, + 71, + 56, + 223, + 195, + 232, + 192, + 0, + 152, + 207, + 3, + 190, + 109, + 235, + 49, + 120, + 244, + 64, + 10, + 166, + 220, + 140, + 12, + 35, + 139, + 4, + 130, + 162, + 112, + 107, + 196, + 32, + 110, + 60, + 51, + 144, + 133, + 183, + 247, + 29, + 54, + 150, + 199, + 125, + 170, + 105, + 173, + 84, + 148, + 21, + 87, + 24, + 235, + 157, + 2, + 172, + 123, + 102, + 144, + 142, + 198, + 141, + 84, + 114, + 161, + 115, + 196, + 64, + 112, + 145, + 56, + 227, + 113, + 140, + 12, + 244, + 18, + 159, + 231, + 215, + 162, + 182, + 61, + 52, + 222, + 56, + 163, + 186, + 140, + 29, + 79, + 73, + 177, + 159, + 105, + 98, + 249, + 111, + 182, + 47, + 113, + 162, + 27, + 56, + 210, + 69, + 94, + 71, + 56, + 223, + 195, + 232, + 192, + 0, + 152, + 207, + 3, + 190, + 109, + 235, + 49, + 120, + 244, + 64, + 10, + 166, + 220, + 140, + 12, + 35, + 139, + 4, + 163, + 116, + 104, + 114, + 2, + 161, + 118, + 1, + 163, + 116, + 120, + 110, + 137, + 164, + 97, + 112, + 97, + 114, + 136, + 162, + 97, + 110, + 174, + 70, + 114, + 97, + 99, + 99, + 116, + 97, + 108, + 32, + 84, + 111, + 107, + 101, + 110, + 162, + 97, + 117, + 217, + 51, + 116, + 101, + 109, + 112, + 108, + 97, + 116, + 101, + 45, + 105, + 112, + 102, + 115, + 58, + 47, + 47, + 123, + 105, + 112, + 102, + 115, + 99, + 105, + 100, + 58, + 48, + 58, + 100, + 97, + 103, + 45, + 112, + 98, + 58, + 114, + 101, + 115, + 101, + 114, + 118, + 101, + 58, + 115, + 104, + 97, + 50, + 45, + 50, + 53, + 54, + 125, + 161, + 99, + 196, + 32, + 83, + 235, + 159, + 121, + 5, + 39, + 212, + 120, + 123, + 218, + 221, + 207, + 55, + 214, + 91, + 66, + 254, + 27, + 132, + 155, + 61, + 224, + 109, + 245, + 62, + 232, + 170, + 48, + 119, + 149, + 92, + 94, + 161, + 102, + 196, + 32, + 83, + 235, + 159, + 121, + 5, + 39, + 212, + 120, + 123, + 218, + 221, + 207, + 55, + 214, + 91, + 66, + 254, + 27, + 132, + 155, + 61, + 224, + 109, + 245, + 62, + 232, + 170, + 48, + 119, + 149, + 92, + 94, + 161, + 109, + 196, + 32, + 83, + 235, + 159, + 121, + 5, + 39, + 212, + 120, + 123, + 218, + 221, + 207, + 55, + 214, + 91, + 66, + 254, + 27, + 132, + 155, + 61, + 224, + 109, + 245, + 62, + 232, + 170, + 48, + 119, + 149, + 92, + 94, + 161, + 114, + 196, + 32, + 196, + 39, + 82, + 61, + 65, + 227, + 186, + 93, + 120, + 255, + 242, + 250, + 143, + 132, + 30, + 169, + 132, + 200, + 139, + 207, + 212, + 37, + 104, + 168, + 220, + 85, + 82, + 180, + 251, + 76, + 174, + 38, + 161, + 116, + 207, + 0, + 0, + 0, + 2, + 84, + 11, + 228, + 0, + 162, + 117, + 110, + 165, + 70, + 82, + 65, + 67, + 67, + 163, + 102, + 101, + 101, + 205, + 3, + 232, + 162, + 102, + 118, + 206, + 1, + 149, + 203, + 210, + 163, + 103, + 101, + 110, + 172, + 109, + 97, + 105, + 110, + 110, + 101, + 116, + 45, + 118, + 49, + 46, + 48, + 162, + 103, + 104, + 196, + 32, + 192, + 97, + 196, + 216, + 252, + 29, + 189, + 222, + 210, + 215, + 96, + 75, + 228, + 86, + 142, + 63, + 109, + 4, + 25, + 135, + 172, + 55, + 189, + 228, + 182, + 32, + 181, + 171, + 57, + 36, + 138, + 223, + 162, + 108, + 118, + 206, + 1, + 149, + 207, + 186, + 164, + 110, + 111, + 116, + 101, + 196, + 203, + 123, + 34, + 110, + 97, + 109, + 101, + 34, + 58, + 34, + 70, + 114, + 97, + 99, + 99, + 116, + 97, + 108, + 32, + 84, + 111, + 107, + 101, + 110, + 34, + 44, + 34, + 117, + 110, + 105, + 116, + 78, + 97, + 109, + 101, + 34, + 58, + 34, + 70, + 82, + 65, + 67, + 67, + 34, + 44, + 34, + 101, + 120, + 116, + 101, + 114, + 110, + 97, + 108, + 95, + 117, + 114, + 108, + 34, + 58, + 34, + 119, + 119, + 119, + 46, + 102, + 114, + 97, + 99, + 99, + 116, + 97, + 108, + 109, + 111, + 110, + 115, + 116, + 101, + 114, + 115, + 110, + 102, + 116, + 46, + 99, + 111, + 109, + 34, + 44, + 34, + 105, + 109, + 97, + 103, + 101, + 95, + 109, + 105, + 109, + 101, + 116, + 121, + 112, + 101, + 34, + 58, + 34, + 105, + 109, + 97, + 103, + 101, + 47, + 112, + 110, + 103, + 34, + 44, + 34, + 100, + 101, + 115, + 99, + 114, + 105, + 112, + 116, + 105, + 111, + 110, + 34, + 58, + 34, + 70, + 114, + 97, + 99, + 99, + 116, + 97, + 108, + 32, + 84, + 111, + 107, + 101, + 110, + 115, + 32, + 97, + 114, + 101, + 32, + 105, + 110, + 45, + 103, + 97, + 109, + 101, + 32, + 99, + 117, + 114, + 114, + 101, + 110, + 99, + 121, + 32, + 102, + 111, + 114, + 32, + 116, + 104, + 101, + 32, + 70, + 114, + 97, + 99, + 99, + 116, + 97, + 108, + 32, + 77, + 111, + 110, + 115, + 116, + 101, + 114, + 115, + 32, + 103, + 97, + 109, + 101, + 33, + 34, + 125, + 163, + 115, + 110, + 100, + 196, + 32, + 83, + 235, + 159, + 121, + 5, + 39, + 212, + 120, + 123, + 218, + 221, + 207, + 55, + 214, + 91, + 66, + 254, + 27, + 132, + 155, + 61, + 224, + 109, + 245, + 62, + 232, + 170, + 48, + 119, + 149, + 92, + 94, + 164, + 116, + 121, + 112, + 101, + 164, + 97, + 99, + 102, + 103 + ], + "rekeyedSenderAuthAddress": "BKDYDIDVSZCP75JVCB76P3WBJRY6HWAIFDSEOKYHJY5WMNJ2UWJ65MYETU", + "rekeyedSenderSignedBytes": [ + 131, + 164, + 115, + 103, + 110, + 114, + 196, + 32, + 10, + 135, + 129, + 160, + 117, + 150, + 68, + 255, + 245, + 53, + 16, + 127, + 231, + 238, + 193, + 76, + 113, + 227, + 216, + 8, + 40, + 228, + 71, + 43, + 7, + 78, + 59, + 102, + 53, + 58, + 165, + 147, + 163, + 115, + 105, + 103, + 196, + 64, + 112, + 145, + 56, + 227, + 113, + 140, + 12, + 244, + 18, + 159, + 231, + 215, + 162, + 182, + 61, + 52, + 222, + 56, + 163, + 186, + 140, + 29, + 79, + 73, + 177, + 159, + 105, + 98, + 249, + 111, + 182, + 47, + 113, + 162, + 27, + 56, + 210, + 69, + 94, + 71, + 56, + 223, + 195, + 232, + 192, + 0, + 152, + 207, + 3, + 190, + 109, + 235, + 49, + 120, + 244, + 64, + 10, + 166, + 220, + 140, + 12, + 35, + 139, + 4, + 163, + 116, + 120, + 110, + 137, + 164, + 97, + 112, + 97, + 114, + 136, + 162, + 97, + 110, + 174, + 70, + 114, + 97, + 99, + 99, + 116, + 97, + 108, + 32, + 84, + 111, + 107, + 101, + 110, + 162, + 97, + 117, + 217, + 51, + 116, + 101, + 109, + 112, + 108, + 97, + 116, + 101, + 45, + 105, + 112, + 102, + 115, + 58, + 47, + 47, + 123, + 105, + 112, + 102, + 115, + 99, + 105, + 100, + 58, + 48, + 58, + 100, + 97, + 103, + 45, + 112, + 98, + 58, + 114, + 101, + 115, + 101, + 114, + 118, + 101, + 58, + 115, + 104, + 97, + 50, + 45, + 50, + 53, + 54, + 125, + 161, + 99, + 196, + 32, + 83, + 235, + 159, + 121, + 5, + 39, + 212, + 120, + 123, + 218, + 221, + 207, + 55, + 214, + 91, + 66, + 254, + 27, + 132, + 155, + 61, + 224, + 109, + 245, + 62, + 232, + 170, + 48, + 119, + 149, + 92, + 94, + 161, + 102, + 196, + 32, + 83, + 235, + 159, + 121, + 5, + 39, + 212, + 120, + 123, + 218, + 221, + 207, + 55, + 214, + 91, + 66, + 254, + 27, + 132, + 155, + 61, + 224, + 109, + 245, + 62, + 232, + 170, + 48, + 119, + 149, + 92, + 94, + 161, + 109, + 196, + 32, + 83, + 235, + 159, + 121, + 5, + 39, + 212, + 120, + 123, + 218, + 221, + 207, + 55, + 214, + 91, + 66, + 254, + 27, + 132, + 155, + 61, + 224, + 109, + 245, + 62, + 232, + 170, + 48, + 119, + 149, + 92, + 94, + 161, + 114, + 196, + 32, + 196, + 39, + 82, + 61, + 65, + 227, + 186, + 93, + 120, + 255, + 242, + 250, + 143, + 132, + 30, + 169, + 132, + 200, + 139, + 207, + 212, + 37, + 104, + 168, + 220, + 85, + 82, + 180, + 251, + 76, + 174, + 38, + 161, + 116, + 207, + 0, + 0, + 0, + 2, + 84, + 11, + 228, + 0, + 162, + 117, + 110, + 165, + 70, + 82, + 65, + 67, + 67, + 163, + 102, + 101, + 101, + 205, + 3, + 232, + 162, + 102, + 118, + 206, + 1, + 149, + 203, + 210, + 163, + 103, + 101, + 110, + 172, + 109, + 97, + 105, + 110, + 110, + 101, + 116, + 45, + 118, + 49, + 46, + 48, + 162, + 103, + 104, + 196, + 32, + 192, + 97, + 196, + 216, + 252, + 29, + 189, + 222, + 210, + 215, + 96, + 75, + 228, + 86, + 142, + 63, + 109, + 4, + 25, + 135, + 172, + 55, + 189, + 228, + 182, + 32, + 181, + 171, + 57, + 36, + 138, + 223, + 162, + 108, + 118, + 206, + 1, + 149, + 207, + 186, + 164, + 110, + 111, + 116, + 101, + 196, + 203, + 123, + 34, + 110, + 97, + 109, + 101, + 34, + 58, + 34, + 70, + 114, + 97, + 99, + 99, + 116, + 97, + 108, + 32, + 84, + 111, + 107, + 101, + 110, + 34, + 44, + 34, + 117, + 110, + 105, + 116, + 78, + 97, + 109, + 101, + 34, + 58, + 34, + 70, + 82, + 65, + 67, + 67, + 34, + 44, + 34, + 101, + 120, + 116, + 101, + 114, + 110, + 97, + 108, + 95, + 117, + 114, + 108, + 34, + 58, + 34, + 119, + 119, + 119, + 46, + 102, + 114, + 97, + 99, + 99, + 116, + 97, + 108, + 109, + 111, + 110, + 115, + 116, + 101, + 114, + 115, + 110, + 102, + 116, + 46, + 99, + 111, + 109, + 34, + 44, + 34, + 105, + 109, + 97, + 103, + 101, + 95, + 109, + 105, + 109, + 101, + 116, + 121, + 112, + 101, + 34, + 58, + 34, + 105, + 109, + 97, + 103, + 101, + 47, + 112, + 110, + 103, + 34, + 44, + 34, + 100, + 101, + 115, + 99, + 114, + 105, + 112, + 116, + 105, + 111, + 110, + 34, + 58, + 34, + 70, + 114, + 97, + 99, + 99, + 116, + 97, + 108, + 32, + 84, + 111, + 107, + 101, + 110, + 115, + 32, + 97, + 114, + 101, + 32, + 105, + 110, + 45, + 103, + 97, + 109, + 101, + 32, + 99, + 117, + 114, + 114, + 101, + 110, + 99, + 121, + 32, + 102, + 111, + 114, + 32, + 116, + 104, + 101, + 32, + 70, + 114, + 97, + 99, + 99, + 116, + 97, + 108, + 32, + 77, + 111, + 110, + 115, + 116, + 101, + 114, + 115, + 32, + 103, + 97, + 109, + 101, + 33, + 34, + 125, + 163, + 115, + 110, + 100, + 196, + 32, + 83, + 235, + 159, + 121, + 5, + 39, + 212, + 120, + 123, + 218, + 221, + 207, + 55, + 214, + 91, + 66, + 254, + 27, + 132, + 155, + 61, + 224, + 109, + 245, + 62, + 232, + 170, + 48, + 119, + 149, + 92, + 94, + 164, + 116, + 121, + 112, + 101, + 164, + 97, + 99, + 102, + 103 + ], + "signedBytes": [ + 130, + 163, + 115, + 105, + 103, + 196, + 64, + 112, + 145, + 56, + 227, + 113, + 140, + 12, + 244, + 18, + 159, + 231, + 215, + 162, + 182, + 61, + 52, + 222, + 56, + 163, + 186, + 140, + 29, + 79, + 73, + 177, + 159, + 105, + 98, + 249, + 111, + 182, + 47, + 113, + 162, + 27, + 56, + 210, + 69, + 94, + 71, + 56, + 223, + 195, + 232, + 192, + 0, + 152, + 207, + 3, + 190, + 109, + 235, + 49, + 120, + 244, + 64, + 10, + 166, + 220, + 140, + 12, + 35, + 139, + 4, + 163, + 116, + 120, + 110, + 137, + 164, + 97, + 112, + 97, + 114, + 136, + 162, + 97, + 110, + 174, + 70, + 114, + 97, + 99, + 99, + 116, + 97, + 108, + 32, + 84, + 111, + 107, + 101, + 110, + 162, + 97, + 117, + 217, + 51, + 116, + 101, + 109, + 112, + 108, + 97, + 116, + 101, + 45, + 105, + 112, + 102, + 115, + 58, + 47, + 47, + 123, + 105, + 112, + 102, + 115, + 99, + 105, + 100, + 58, + 48, + 58, + 100, + 97, + 103, + 45, + 112, + 98, + 58, + 114, + 101, + 115, + 101, + 114, + 118, + 101, + 58, + 115, + 104, + 97, + 50, + 45, + 50, + 53, + 54, + 125, + 161, + 99, + 196, + 32, + 83, + 235, + 159, + 121, + 5, + 39, + 212, + 120, + 123, + 218, + 221, + 207, + 55, + 214, + 91, + 66, + 254, + 27, + 132, + 155, + 61, + 224, + 109, + 245, + 62, + 232, + 170, + 48, + 119, + 149, + 92, + 94, + 161, + 102, + 196, + 32, + 83, + 235, + 159, + 121, + 5, + 39, + 212, + 120, + 123, + 218, + 221, + 207, + 55, + 214, + 91, + 66, + 254, + 27, + 132, + 155, + 61, + 224, + 109, + 245, + 62, + 232, + 170, + 48, + 119, + 149, + 92, + 94, + 161, + 109, + 196, + 32, + 83, + 235, + 159, + 121, + 5, + 39, + 212, + 120, + 123, + 218, + 221, + 207, + 55, + 214, + 91, + 66, + 254, + 27, + 132, + 155, + 61, + 224, + 109, + 245, + 62, + 232, + 170, + 48, + 119, + 149, + 92, + 94, + 161, + 114, + 196, + 32, + 196, + 39, + 82, + 61, + 65, + 227, + 186, + 93, + 120, + 255, + 242, + 250, + 143, + 132, + 30, + 169, + 132, + 200, + 139, + 207, + 212, + 37, + 104, + 168, + 220, + 85, + 82, + 180, + 251, + 76, + 174, + 38, + 161, + 116, + 207, + 0, + 0, + 0, + 2, + 84, + 11, + 228, + 0, + 162, + 117, + 110, + 165, + 70, + 82, + 65, + 67, + 67, + 163, + 102, + 101, + 101, + 205, + 3, + 232, + 162, + 102, + 118, + 206, + 1, + 149, + 203, + 210, + 163, + 103, + 101, + 110, + 172, + 109, + 97, + 105, + 110, + 110, + 101, + 116, + 45, + 118, + 49, + 46, + 48, + 162, + 103, + 104, + 196, + 32, + 192, + 97, + 196, + 216, + 252, + 29, + 189, + 222, + 210, + 215, + 96, + 75, + 228, + 86, + 142, + 63, + 109, + 4, + 25, + 135, + 172, + 55, + 189, + 228, + 182, + 32, + 181, + 171, + 57, + 36, + 138, + 223, + 162, + 108, + 118, + 206, + 1, + 149, + 207, + 186, + 164, + 110, + 111, + 116, + 101, + 196, + 203, + 123, + 34, + 110, + 97, + 109, + 101, + 34, + 58, + 34, + 70, + 114, + 97, + 99, + 99, + 116, + 97, + 108, + 32, + 84, + 111, + 107, + 101, + 110, + 34, + 44, + 34, + 117, + 110, + 105, + 116, + 78, + 97, + 109, + 101, + 34, + 58, + 34, + 70, + 82, + 65, + 67, + 67, + 34, + 44, + 34, + 101, + 120, + 116, + 101, + 114, + 110, + 97, + 108, + 95, + 117, + 114, + 108, + 34, + 58, + 34, + 119, + 119, + 119, + 46, + 102, + 114, + 97, + 99, + 99, + 116, + 97, + 108, + 109, + 111, + 110, + 115, + 116, + 101, + 114, + 115, + 110, + 102, + 116, + 46, + 99, + 111, + 109, + 34, + 44, + 34, + 105, + 109, + 97, + 103, + 101, + 95, + 109, + 105, + 109, + 101, + 116, + 121, + 112, + 101, + 34, + 58, + 34, + 105, + 109, + 97, + 103, + 101, + 47, + 112, + 110, + 103, + 34, + 44, + 34, + 100, + 101, + 115, + 99, + 114, + 105, + 112, + 116, + 105, + 111, + 110, + 34, + 58, + 34, + 70, + 114, + 97, + 99, + 99, + 116, + 97, + 108, + 32, + 84, + 111, + 107, + 101, + 110, + 115, + 32, + 97, + 114, + 101, + 32, + 105, + 110, + 45, + 103, + 97, + 109, + 101, + 32, + 99, + 117, + 114, + 114, + 101, + 110, + 99, + 121, + 32, + 102, + 111, + 114, + 32, + 116, + 104, + 101, + 32, + 70, + 114, + 97, + 99, + 99, + 116, + 97, + 108, + 32, + 77, + 111, + 110, + 115, + 116, + 101, + 114, + 115, + 32, + 103, + 97, + 109, + 101, + 33, + 34, + 125, + 163, + 115, + 110, + 100, + 196, + 32, + 83, + 235, + 159, + 121, + 5, + 39, + 212, + 120, + 123, + 218, + 221, + 207, + 55, + 214, + 91, + 66, + 254, + 27, + 132, + 155, + 61, + 224, + 109, + 245, + 62, + 232, + 170, + 48, + 119, + 149, + 92, + 94, + 164, + 116, + 121, + 112, + 101, + 164, + 97, + 99, + 102, + 103 + ], + "signingPrivateKey": [ + 2, + 205, + 103, + 33, + 67, + 14, + 82, + 196, + 115, + 196, + 206, + 254, + 50, + 110, + 63, + 182, + 149, + 229, + 184, + 216, + 93, + 11, + 13, + 99, + 69, + 213, + 218, + 165, + 134, + 118, + 47, + 44 + ], + "transaction": { + "assetConfig": { + "assetId": 0, + "assetName": "Fracctal Token", + "clawback": "KPVZ66IFE7KHQ6623XHTPVS3IL7BXBE3HXQG35J65CVDA54VLRPP4SVOU4", + "freeze": "KPVZ66IFE7KHQ6623XHTPVS3IL7BXBE3HXQG35J65CVDA54VLRPP4SVOU4", + "manager": "KPVZ66IFE7KHQ6623XHTPVS3IL7BXBE3HXQG35J65CVDA54VLRPP4SVOU4", + "reserve": "YQTVEPKB4O5F26H76L5I7BA6VGCMRC6P2QSWRKG4KVJLJ62MVYTDJPM6KE", + "total": 10000000000, + "unitName": "FRACC", + "url": "template-ipfs://{ipfscid:0:dag-pb:reserve:sha2-256}" + }, + "fee": 1000, + "firstValid": 26594258, + "genesisHash": [ + 192, + 97, + 196, + 216, + 252, + 29, + 189, + 222, + 210, + 215, + 96, + 75, + 228, + 86, + 142, + 63, + 109, + 4, + 25, + 135, + 172, + 55, + 189, + 228, + 182, + 32, + 181, + 171, + 57, + 36, + 138, + 223 + ], + "genesisId": "mainnet-v1.0", + "lastValid": 26595258, + "note": [ + 123, + 34, + 110, + 97, + 109, + 101, + 34, + 58, + 34, + 70, + 114, + 97, + 99, + 99, + 116, + 97, + 108, + 32, + 84, + 111, + 107, + 101, + 110, + 34, + 44, + 34, + 117, + 110, + 105, + 116, + 78, + 97, + 109, + 101, + 34, + 58, + 34, + 70, + 82, + 65, + 67, + 67, + 34, + 44, + 34, + 101, + 120, + 116, + 101, + 114, + 110, + 97, + 108, + 95, + 117, + 114, + 108, + 34, + 58, + 34, + 119, + 119, + 119, + 46, + 102, + 114, + 97, + 99, + 99, + 116, + 97, + 108, + 109, + 111, + 110, + 115, + 116, + 101, + 114, + 115, + 110, + 102, + 116, + 46, + 99, + 111, + 109, + 34, + 44, + 34, + 105, + 109, + 97, + 103, + 101, + 95, + 109, + 105, + 109, + 101, + 116, + 121, + 112, + 101, + 34, + 58, + 34, + 105, + 109, + 97, + 103, + 101, + 47, + 112, + 110, + 103, + 34, + 44, + 34, + 100, + 101, + 115, + 99, + 114, + 105, + 112, + 116, + 105, + 111, + 110, + 34, + 58, + 34, + 70, + 114, + 97, + 99, + 99, + 116, + 97, + 108, + 32, + 84, + 111, + 107, + 101, + 110, + 115, + 32, + 97, + 114, + 101, + 32, + 105, + 110, + 45, + 103, + 97, + 109, + 101, + 32, + 99, + 117, + 114, + 114, + 101, + 110, + 99, + 121, + 32, + 102, + 111, + 114, + 32, + 116, + 104, + 101, + 32, + 70, + 114, + 97, + 99, + 99, + 116, + 97, + 108, + 32, + 77, + 111, + 110, + 115, + 116, + 101, + 114, + 115, + 32, + 103, + 97, + 109, + 101, + 33, + 34, + 125 + ], + "sender": "KPVZ66IFE7KHQ6623XHTPVS3IL7BXBE3HXQG35J65CVDA54VLRPP4SVOU4", + "transactionType": "AssetConfig" + }, + "unsignedBytes": [ + 84, + 88, + 137, + 164, + 97, + 112, + 97, + 114, + 136, + 162, + 97, + 110, + 174, + 70, + 114, + 97, + 99, + 99, + 116, + 97, + 108, + 32, + 84, + 111, + 107, + 101, + 110, + 162, + 97, + 117, + 217, + 51, + 116, + 101, + 109, + 112, + 108, + 97, + 116, + 101, + 45, + 105, + 112, + 102, + 115, + 58, + 47, + 47, + 123, + 105, + 112, + 102, + 115, + 99, + 105, + 100, + 58, + 48, + 58, + 100, + 97, + 103, + 45, + 112, + 98, + 58, + 114, + 101, + 115, + 101, + 114, + 118, + 101, + 58, + 115, + 104, + 97, + 50, + 45, + 50, + 53, + 54, + 125, + 161, + 99, + 196, + 32, + 83, + 235, + 159, + 121, + 5, + 39, + 212, + 120, + 123, + 218, + 221, + 207, + 55, + 214, + 91, + 66, + 254, + 27, + 132, + 155, + 61, + 224, + 109, + 245, + 62, + 232, + 170, + 48, + 119, + 149, + 92, + 94, + 161, + 102, + 196, + 32, + 83, + 235, + 159, + 121, + 5, + 39, + 212, + 120, + 123, + 218, + 221, + 207, + 55, + 214, + 91, + 66, + 254, + 27, + 132, + 155, + 61, + 224, + 109, + 245, + 62, + 232, + 170, + 48, + 119, + 149, + 92, + 94, + 161, + 109, + 196, + 32, + 83, + 235, + 159, + 121, + 5, + 39, + 212, + 120, + 123, + 218, + 221, + 207, + 55, + 214, + 91, + 66, + 254, + 27, + 132, + 155, + 61, + 224, + 109, + 245, + 62, + 232, + 170, + 48, + 119, + 149, + 92, + 94, + 161, + 114, + 196, + 32, + 196, + 39, + 82, + 61, + 65, + 227, + 186, + 93, + 120, + 255, + 242, + 250, + 143, + 132, + 30, + 169, + 132, + 200, + 139, + 207, + 212, + 37, + 104, + 168, + 220, + 85, + 82, + 180, + 251, + 76, + 174, + 38, + 161, + 116, + 207, + 0, + 0, + 0, + 2, + 84, + 11, + 228, + 0, + 162, + 117, + 110, + 165, + 70, + 82, + 65, + 67, + 67, + 163, + 102, + 101, + 101, + 205, + 3, + 232, + 162, + 102, + 118, + 206, + 1, + 149, + 203, + 210, + 163, + 103, + 101, + 110, + 172, + 109, + 97, + 105, + 110, + 110, + 101, + 116, + 45, + 118, + 49, + 46, + 48, + 162, + 103, + 104, + 196, + 32, + 192, + 97, + 196, + 216, + 252, + 29, + 189, + 222, + 210, + 215, + 96, + 75, + 228, + 86, + 142, + 63, + 109, + 4, + 25, + 135, + 172, + 55, + 189, + 228, + 182, + 32, + 181, + 171, + 57, + 36, + 138, + 223, + 162, + 108, + 118, + 206, + 1, + 149, + 207, + 186, + 164, + 110, + 111, + 116, + 101, + 196, + 203, + 123, + 34, + 110, + 97, + 109, + 101, + 34, + 58, + 34, + 70, + 114, + 97, + 99, + 99, + 116, + 97, + 108, + 32, + 84, + 111, + 107, + 101, + 110, + 34, + 44, + 34, + 117, + 110, + 105, + 116, + 78, + 97, + 109, + 101, + 34, + 58, + 34, + 70, + 82, + 65, + 67, + 67, + 34, + 44, + 34, + 101, + 120, + 116, + 101, + 114, + 110, + 97, + 108, + 95, + 117, + 114, + 108, + 34, + 58, + 34, + 119, + 119, + 119, + 46, + 102, + 114, + 97, + 99, + 99, + 116, + 97, + 108, + 109, + 111, + 110, + 115, + 116, + 101, + 114, + 115, + 110, + 102, + 116, + 46, + 99, + 111, + 109, + 34, + 44, + 34, + 105, + 109, + 97, + 103, + 101, + 95, + 109, + 105, + 109, + 101, + 116, + 121, + 112, + 101, + 34, + 58, + 34, + 105, + 109, + 97, + 103, + 101, + 47, + 112, + 110, + 103, + 34, + 44, + 34, + 100, + 101, + 115, + 99, + 114, + 105, + 112, + 116, + 105, + 111, + 110, + 34, + 58, + 34, + 70, + 114, + 97, + 99, + 99, + 116, + 97, + 108, + 32, + 84, + 111, + 107, + 101, + 110, + 115, + 32, + 97, + 114, + 101, + 32, + 105, + 110, + 45, + 103, + 97, + 109, + 101, + 32, + 99, + 117, + 114, + 114, + 101, + 110, + 99, + 121, + 32, + 102, + 111, + 114, + 32, + 116, + 104, + 101, + 32, + 70, + 114, + 97, + 99, + 99, + 116, + 97, + 108, + 32, + 77, + 111, + 110, + 115, + 116, + 101, + 114, + 115, + 32, + 103, + 97, + 109, + 101, + 33, + 34, + 125, + 163, + 115, + 110, + 100, + 196, + 32, + 83, + 235, + 159, + 121, + 5, + 39, + 212, + 120, + 123, + 218, + 221, + 207, + 55, + 214, + 91, + 66, + 254, + 27, + 132, + 155, + 61, + 224, + 109, + 245, + 62, + 232, + 170, + 48, + 119, + 149, + 92, + 94, + 164, + 116, + 121, + 112, + 101, + 164, + 97, + 99, + 102, + 103 + ] + }, + "assetDestroy": { + "id": "U4XH6AS5UUYQI4IZ3E5JSUEIU64Y3FGNYKLH26W4HRY7T6PK745A", + "idRaw": [ + 167, + 46, + 127, + 2, + 93, + 165, + 49, + 4, + 113, + 25, + 217, + 58, + 153, + 80, + 136, + 167, + 185, + 141, + 148, + 205, + 194, + 150, + 125, + 122, + 220, + 60, + 113, + 249, + 249, + 234, + 255, + 58 + ], + "multisigAddresses": [ + "424ZV7KBBUJ52DUKP2KLQ6I5GBOHKBXOW7Q7UQIOOYNDWYRM4EKOSMVVRI", + "NY6DHEEFW73R2NUWY562U2NNKSKBKVYY5OOQFLD3M2II5RUNKRZDEGUGEA" + ], + "multisigSignedBytes": [ + 130, + 164, + 109, + 115, + 105, + 103, + 131, + 166, + 115, + 117, + 98, + 115, + 105, + 103, + 146, + 130, + 162, + 112, + 107, + 196, + 32, + 230, + 185, + 154, + 253, + 65, + 13, + 19, + 221, + 14, + 138, + 126, + 148, + 184, + 121, + 29, + 48, + 92, + 117, + 6, + 238, + 183, + 225, + 250, + 65, + 14, + 118, + 26, + 59, + 98, + 44, + 225, + 20, + 161, + 115, + 196, + 64, + 80, + 28, + 172, + 151, + 14, + 10, + 101, + 35, + 20, + 249, + 133, + 145, + 208, + 250, + 58, + 50, + 189, + 27, + 188, + 227, + 215, + 52, + 163, + 238, + 124, + 170, + 90, + 150, + 95, + 255, + 190, + 1, + 50, + 108, + 130, + 148, + 29, + 45, + 168, + 42, + 202, + 170, + 37, + 63, + 191, + 171, + 220, + 16, + 26, + 232, + 40, + 254, + 110, + 152, + 70, + 95, + 95, + 166, + 243, + 90, + 93, + 46, + 70, + 2, + 130, + 162, + 112, + 107, + 196, + 32, + 110, + 60, + 51, + 144, + 133, + 183, + 247, + 29, + 54, + 150, + 199, + 125, + 170, + 105, + 173, + 84, + 148, + 21, + 87, + 24, + 235, + 157, + 2, + 172, + 123, + 102, + 144, + 142, + 198, + 141, + 84, + 114, + 161, + 115, + 196, + 64, + 80, + 28, + 172, + 151, + 14, + 10, + 101, + 35, + 20, + 249, + 133, + 145, + 208, + 250, + 58, + 50, + 189, + 27, + 188, + 227, + 215, + 52, + 163, + 238, + 124, + 170, + 90, + 150, + 95, + 255, + 190, + 1, + 50, + 108, + 130, + 148, + 29, + 45, + 168, + 42, + 202, + 170, + 37, + 63, + 191, + 171, + 220, + 16, + 26, + 232, + 40, + 254, + 110, + 152, + 70, + 95, + 95, + 166, + 243, + 90, + 93, + 46, + 70, + 2, + 163, + 116, + 104, + 114, + 2, + 161, + 118, + 1, + 163, + 116, + 120, + 110, + 136, + 164, + 99, + 97, + 105, + 100, + 206, + 0, + 14, + 0, + 55, + 163, + 102, + 101, + 101, + 205, + 3, + 232, + 162, + 102, + 118, + 206, + 0, + 96, + 246, + 191, + 162, + 103, + 104, + 196, + 32, + 192, + 97, + 196, + 216, + 252, + 29, + 189, + 222, + 210, + 215, + 96, + 75, + 228, + 86, + 142, + 63, + 109, + 4, + 25, + 135, + 172, + 55, + 189, + 228, + 182, + 32, + 181, + 171, + 57, + 36, + 138, + 223, + 162, + 108, + 118, + 206, + 0, + 96, + 250, + 167, + 164, + 110, + 111, + 116, + 101, + 196, + 8, + 125, + 38, + 141, + 238, + 86, + 74, + 14, + 133, + 163, + 115, + 110, + 100, + 196, + 32, + 96, + 111, + 166, + 121, + 60, + 226, + 225, + 173, + 47, + 101, + 139, + 177, + 16, + 170, + 128, + 55, + 11, + 98, + 53, + 242, + 91, + 230, + 143, + 144, + 49, + 225, + 5, + 13, + 1, + 227, + 98, + 61, + 164, + 116, + 121, + 112, + 101, + 164, + 97, + 99, + 102, + 103 + ], + "rekeyedSenderAuthAddress": "BKDYDIDVSZCP75JVCB76P3WBJRY6HWAIFDSEOKYHJY5WMNJ2UWJ65MYETU", + "rekeyedSenderSignedBytes": [ + 131, + 164, + 115, + 103, + 110, + 114, + 196, + 32, + 10, + 135, + 129, + 160, + 117, + 150, + 68, + 255, + 245, + 53, + 16, + 127, + 231, + 238, + 193, + 76, + 113, + 227, + 216, + 8, + 40, + 228, + 71, + 43, + 7, + 78, + 59, + 102, + 53, + 58, + 165, + 147, + 163, + 115, + 105, + 103, + 196, + 64, + 80, + 28, + 172, + 151, + 14, + 10, + 101, + 35, + 20, + 249, + 133, + 145, + 208, + 250, + 58, + 50, + 189, + 27, + 188, + 227, + 215, + 52, + 163, + 238, + 124, + 170, + 90, + 150, + 95, + 255, + 190, + 1, + 50, + 108, + 130, + 148, + 29, + 45, + 168, + 42, + 202, + 170, + 37, + 63, + 191, + 171, + 220, + 16, + 26, + 232, + 40, + 254, + 110, + 152, + 70, + 95, + 95, + 166, + 243, + 90, + 93, + 46, + 70, + 2, + 163, + 116, + 120, + 110, + 136, + 164, + 99, + 97, + 105, + 100, + 206, + 0, + 14, + 0, + 55, + 163, + 102, + 101, + 101, + 205, + 3, + 232, + 162, + 102, + 118, + 206, + 0, + 96, + 246, + 191, + 162, + 103, + 104, + 196, + 32, + 192, + 97, + 196, + 216, + 252, + 29, + 189, + 222, + 210, + 215, + 96, + 75, + 228, + 86, + 142, + 63, + 109, + 4, + 25, + 135, + 172, + 55, + 189, + 228, + 182, + 32, + 181, + 171, + 57, + 36, + 138, + 223, + 162, + 108, + 118, + 206, + 0, + 96, + 250, + 167, + 164, + 110, + 111, + 116, + 101, + 196, + 8, + 125, + 38, + 141, + 238, + 86, + 74, + 14, + 133, + 163, + 115, + 110, + 100, + 196, + 32, + 96, + 111, + 166, + 121, + 60, + 226, + 225, + 173, + 47, + 101, + 139, + 177, + 16, + 170, + 128, + 55, + 11, + 98, + 53, + 242, + 91, + 230, + 143, + 144, + 49, + 225, + 5, + 13, + 1, + 227, + 98, + 61, + 164, + 116, + 121, + 112, + 101, + 164, + 97, + 99, + 102, + 103 + ], + "signedBytes": [ + 130, + 163, + 115, + 105, + 103, + 196, + 64, + 80, + 28, + 172, + 151, + 14, + 10, + 101, + 35, + 20, + 249, + 133, + 145, + 208, + 250, + 58, + 50, + 189, + 27, + 188, + 227, + 215, + 52, + 163, + 238, + 124, + 170, + 90, + 150, + 95, + 255, + 190, + 1, + 50, + 108, + 130, + 148, + 29, + 45, + 168, + 42, + 202, + 170, + 37, + 63, + 191, + 171, + 220, + 16, + 26, + 232, + 40, + 254, + 110, + 152, + 70, + 95, + 95, + 166, + 243, + 90, + 93, + 46, + 70, + 2, + 163, + 116, + 120, + 110, + 136, + 164, + 99, + 97, + 105, + 100, + 206, + 0, + 14, + 0, + 55, + 163, + 102, + 101, + 101, + 205, + 3, + 232, + 162, + 102, + 118, + 206, + 0, + 96, + 246, + 191, + 162, + 103, + 104, + 196, + 32, + 192, + 97, + 196, + 216, + 252, + 29, + 189, + 222, + 210, + 215, + 96, + 75, + 228, + 86, + 142, + 63, + 109, + 4, + 25, + 135, + 172, + 55, + 189, + 228, + 182, + 32, + 181, + 171, + 57, + 36, + 138, + 223, + 162, + 108, + 118, + 206, + 0, + 96, + 250, + 167, + 164, + 110, + 111, + 116, + 101, + 196, + 8, + 125, + 38, + 141, + 238, + 86, + 74, + 14, + 133, + 163, + 115, + 110, + 100, + 196, + 32, + 96, + 111, + 166, + 121, + 60, + 226, + 225, + 173, + 47, + 101, + 139, + 177, + 16, + 170, + 128, + 55, + 11, + 98, + 53, + 242, + 91, + 230, + 143, + 144, + 49, + 225, + 5, + 13, + 1, + 227, + 98, + 61, + 164, + 116, + 121, + 112, + 101, + 164, + 97, + 99, + 102, + 103 + ], + "signingPrivateKey": [ + 2, + 205, + 103, + 33, + 67, + 14, + 82, + 196, + 115, + 196, + 206, + 254, + 50, + 110, + 63, + 182, + 149, + 229, + 184, + 216, + 93, + 11, + 13, + 99, + 69, + 213, + 218, + 165, + 134, + 118, + 47, + 44 + ], + "transaction": { + "assetConfig": { + "assetId": 917559 + }, + "fee": 1000, + "firstValid": 6354623, + "genesisHash": [ + 192, + 97, + 196, + 216, + 252, + 29, + 189, + 222, + 210, + 215, + 96, + 75, + 228, + 86, + 142, + 63, + 109, + 4, + 25, + 135, + 172, + 55, + 189, + 228, + 182, + 32, + 181, + 171, + 57, + 36, + 138, + 223 + ], + "lastValid": 6355623, + "note": [ + 125, + 38, + 141, + 238, + 86, + 74, + 14, + 133 + ], + "sender": "MBX2M6J44LQ22L3FROYRBKUAG4FWENPSLPTI7EBR4ECQ2APDMI6XTENHWQ", + "transactionType": "AssetConfig" + }, + "unsignedBytes": [ + 84, + 88, + 136, + 164, + 99, + 97, + 105, + 100, + 206, + 0, + 14, + 0, + 55, + 163, + 102, + 101, + 101, + 205, + 3, + 232, + 162, + 102, + 118, + 206, + 0, + 96, + 246, + 191, + 162, + 103, + 104, + 196, + 32, + 192, + 97, + 196, + 216, + 252, + 29, + 189, + 222, + 210, + 215, + 96, + 75, + 228, + 86, + 142, + 63, + 109, + 4, + 25, + 135, + 172, + 55, + 189, + 228, + 182, + 32, + 181, + 171, + 57, + 36, + 138, + 223, + 162, + 108, + 118, + 206, + 0, + 96, + 250, + 167, + 164, + 110, + 111, + 116, + 101, + 196, + 8, + 125, + 38, + 141, + 238, + 86, + 74, + 14, + 133, + 163, + 115, + 110, + 100, + 196, + 32, + 96, + 111, + 166, + 121, + 60, + 226, + 225, + 173, + 47, + 101, + 139, + 177, + 16, + 170, + 128, + 55, + 11, + 98, + 53, + 242, + 91, + 230, + 143, + 144, + 49, + 225, + 5, + 13, + 1, + 227, + 98, + 61, + 164, + 116, + 121, + 112, + 101, + 164, + 97, + 99, + 102, + 103 + ] + }, + "assetFreeze": { + "id": "2XFGVOHMFYLAWBHOSIOI67PBT5LDRHBTD3VLX5EYBDTFNVKMCJIA", + "idRaw": [ + 213, + 202, + 106, + 184, + 236, + 46, + 22, + 11, + 4, + 238, + 146, + 28, + 143, + 125, + 225, + 159, + 86, + 56, + 156, + 51, + 30, + 234, + 187, + 244, + 152, + 8, + 230, + 86, + 213, + 76, + 18, + 80 + ], + "multisigAddresses": [ + "424ZV7KBBUJ52DUKP2KLQ6I5GBOHKBXOW7Q7UQIOOYNDWYRM4EKOSMVVRI", + "NY6DHEEFW73R2NUWY562U2NNKSKBKVYY5OOQFLD3M2II5RUNKRZDEGUGEA" + ], + "multisigSignedBytes": [ + 130, + 164, + 109, + 115, + 105, + 103, + 131, + 166, + 115, + 117, + 98, + 115, + 105, + 103, + 146, + 130, + 162, + 112, + 107, + 196, + 32, + 230, + 185, + 154, + 253, + 65, + 13, + 19, + 221, + 14, + 138, + 126, + 148, + 184, + 121, + 29, + 48, + 92, + 117, + 6, + 238, + 183, + 225, + 250, + 65, + 14, + 118, + 26, + 59, + 98, + 44, + 225, + 20, + 161, + 115, + 196, + 64, + 186, + 172, + 16, + 41, + 122, + 236, + 112, + 9, + 71, + 227, + 42, + 80, + 110, + 63, + 129, + 246, + 181, + 134, + 30, + 201, + 255, + 233, + 161, + 56, + 160, + 176, + 171, + 222, + 102, + 145, + 36, + 16, + 16, + 8, + 136, + 76, + 37, + 61, + 75, + 133, + 176, + 95, + 245, + 132, + 31, + 244, + 74, + 160, + 106, + 229, + 22, + 165, + 209, + 32, + 8, + 248, + 49, + 79, + 175, + 104, + 206, + 8, + 40, + 10, + 130, + 162, + 112, + 107, + 196, + 32, + 110, + 60, + 51, + 144, + 133, + 183, + 247, + 29, + 54, + 150, + 199, + 125, + 170, + 105, + 173, + 84, + 148, + 21, + 87, + 24, + 235, + 157, + 2, + 172, + 123, + 102, + 144, + 142, + 198, + 141, + 84, + 114, + 161, + 115, + 196, + 64, + 186, + 172, + 16, + 41, + 122, + 236, + 112, + 9, + 71, + 227, + 42, + 80, + 110, + 63, + 129, + 246, + 181, + 134, + 30, + 201, + 255, + 233, + 161, + 56, + 160, + 176, + 171, + 222, + 102, + 145, + 36, + 16, + 16, + 8, + 136, + 76, + 37, + 61, + 75, + 133, + 176, + 95, + 245, + 132, + 31, + 244, + 74, + 160, + 106, + 229, + 22, + 165, + 209, + 32, + 8, + 248, + 49, + 79, + 175, + 104, + 206, + 8, + 40, + 10, + 163, + 116, + 104, + 114, + 2, + 161, + 118, + 1, + 163, + 116, + 120, + 110, + 140, + 164, + 97, + 102, + 114, + 122, + 195, + 164, + 102, + 97, + 100, + 100, + 196, + 32, + 202, + 105, + 187, + 232, + 58, + 131, + 118, + 26, + 5, + 9, + 247, + 19, + 158, + 251, + 181, + 223, + 182, + 6, + 152, + 52, + 27, + 151, + 112, + 36, + 227, + 185, + 144, + 134, + 97, + 94, + 181, + 118, + 164, + 102, + 97, + 105, + 100, + 206, + 101, + 193, + 4, + 207, + 163, + 102, + 101, + 101, + 205, + 3, + 232, + 162, + 102, + 118, + 206, + 2, + 59, + 166, + 10, + 163, + 103, + 101, + 110, + 172, + 109, + 97, + 105, + 110, + 110, + 101, + 116, + 45, + 118, + 49, + 46, + 48, + 162, + 103, + 104, + 196, + 32, + 192, + 97, + 196, + 216, + 252, + 29, + 189, + 222, + 210, + 215, + 96, + 75, + 228, + 86, + 142, + 63, + 109, + 4, + 25, + 135, + 172, + 55, + 189, + 228, + 182, + 32, + 181, + 171, + 57, + 36, + 138, + 223, + 163, + 103, + 114, + 112, + 196, + 32, + 196, + 68, + 99, + 197, + 84, + 229, + 53, + 191, + 35, + 120, + 118, + 181, + 234, + 169, + 169, + 196, + 51, + 33, + 227, + 231, + 92, + 12, + 42, + 36, + 59, + 175, + 80, + 156, + 209, + 18, + 108, + 89, + 162, + 108, + 118, + 206, + 2, + 59, + 169, + 242, + 164, + 110, + 111, + 116, + 101, + 196, + 23, + 78, + 70, + 84, + 32, + 102, + 114, + 101, + 101, + 122, + 101, + 100, + 32, + 98, + 121, + 32, + 108, + 111, + 102, + 116, + 121, + 46, + 97, + 105, + 163, + 115, + 110, + 100, + 196, + 32, + 39, + 1, + 226, + 213, + 7, + 188, + 179, + 178, + 254, + 23, + 136, + 157, + 60, + 12, + 104, + 93, + 97, + 130, + 4, + 167, + 239, + 143, + 129, + 161, + 24, + 191, + 37, + 91, + 203, + 80, + 191, + 77, + 164, + 116, + 121, + 112, + 101, + 164, + 97, + 102, + 114, + 122 + ], + "rekeyedSenderAuthAddress": "BKDYDIDVSZCP75JVCB76P3WBJRY6HWAIFDSEOKYHJY5WMNJ2UWJ65MYETU", + "rekeyedSenderSignedBytes": [ + 131, + 164, + 115, + 103, + 110, + 114, + 196, + 32, + 10, + 135, + 129, + 160, + 117, + 150, + 68, + 255, + 245, + 53, + 16, + 127, + 231, + 238, + 193, + 76, + 113, + 227, + 216, + 8, + 40, + 228, + 71, + 43, + 7, + 78, + 59, + 102, + 53, + 58, + 165, + 147, + 163, + 115, + 105, + 103, + 196, + 64, + 186, + 172, + 16, + 41, + 122, + 236, + 112, + 9, + 71, + 227, + 42, + 80, + 110, + 63, + 129, + 246, + 181, + 134, + 30, + 201, + 255, + 233, + 161, + 56, + 160, + 176, + 171, + 222, + 102, + 145, + 36, + 16, + 16, + 8, + 136, + 76, + 37, + 61, + 75, + 133, + 176, + 95, + 245, + 132, + 31, + 244, + 74, + 160, + 106, + 229, + 22, + 165, + 209, + 32, + 8, + 248, + 49, + 79, + 175, + 104, + 206, + 8, + 40, + 10, + 163, + 116, + 120, + 110, + 140, + 164, + 97, + 102, + 114, + 122, + 195, + 164, + 102, + 97, + 100, + 100, + 196, + 32, + 202, + 105, + 187, + 232, + 58, + 131, + 118, + 26, + 5, + 9, + 247, + 19, + 158, + 251, + 181, + 223, + 182, + 6, + 152, + 52, + 27, + 151, + 112, + 36, + 227, + 185, + 144, + 134, + 97, + 94, + 181, + 118, + 164, + 102, + 97, + 105, + 100, + 206, + 101, + 193, + 4, + 207, + 163, + 102, + 101, + 101, + 205, + 3, + 232, + 162, + 102, + 118, + 206, + 2, + 59, + 166, + 10, + 163, + 103, + 101, + 110, + 172, + 109, + 97, + 105, + 110, + 110, + 101, + 116, + 45, + 118, + 49, + 46, + 48, + 162, + 103, + 104, + 196, + 32, + 192, + 97, + 196, + 216, + 252, + 29, + 189, + 222, + 210, + 215, + 96, + 75, + 228, + 86, + 142, + 63, + 109, + 4, + 25, + 135, + 172, + 55, + 189, + 228, + 182, + 32, + 181, + 171, + 57, + 36, + 138, + 223, + 163, + 103, + 114, + 112, + 196, + 32, + 196, + 68, + 99, + 197, + 84, + 229, + 53, + 191, + 35, + 120, + 118, + 181, + 234, + 169, + 169, + 196, + 51, + 33, + 227, + 231, + 92, + 12, + 42, + 36, + 59, + 175, + 80, + 156, + 209, + 18, + 108, + 89, + 162, + 108, + 118, + 206, + 2, + 59, + 169, + 242, + 164, + 110, + 111, + 116, + 101, + 196, + 23, + 78, + 70, + 84, + 32, + 102, + 114, + 101, + 101, + 122, + 101, + 100, + 32, + 98, + 121, + 32, + 108, + 111, + 102, + 116, + 121, + 46, + 97, + 105, + 163, + 115, + 110, + 100, + 196, + 32, + 39, + 1, + 226, + 213, + 7, + 188, + 179, + 178, + 254, + 23, + 136, + 157, + 60, + 12, + 104, + 93, + 97, + 130, + 4, + 167, + 239, + 143, + 129, + 161, + 24, + 191, + 37, + 91, + 203, + 80, + 191, + 77, + 164, + 116, + 121, + 112, + 101, + 164, + 97, + 102, + 114, + 122 + ], + "signedBytes": [ + 130, + 163, + 115, + 105, + 103, + 196, + 64, + 186, + 172, + 16, + 41, + 122, + 236, + 112, + 9, + 71, + 227, + 42, + 80, + 110, + 63, + 129, + 246, + 181, + 134, + 30, + 201, + 255, + 233, + 161, + 56, + 160, + 176, + 171, + 222, + 102, + 145, + 36, + 16, + 16, + 8, + 136, + 76, + 37, + 61, + 75, + 133, + 176, + 95, + 245, + 132, + 31, + 244, + 74, + 160, + 106, + 229, + 22, + 165, + 209, + 32, + 8, + 248, + 49, + 79, + 175, + 104, + 206, + 8, + 40, + 10, + 163, + 116, + 120, + 110, + 140, + 164, + 97, + 102, + 114, + 122, + 195, + 164, + 102, + 97, + 100, + 100, + 196, + 32, + 202, + 105, + 187, + 232, + 58, + 131, + 118, + 26, + 5, + 9, + 247, + 19, + 158, + 251, + 181, + 223, + 182, + 6, + 152, + 52, + 27, + 151, + 112, + 36, + 227, + 185, + 144, + 134, + 97, + 94, + 181, + 118, + 164, + 102, + 97, + 105, + 100, + 206, + 101, + 193, + 4, + 207, + 163, + 102, + 101, + 101, + 205, + 3, + 232, + 162, + 102, + 118, + 206, + 2, + 59, + 166, + 10, + 163, + 103, + 101, + 110, + 172, + 109, + 97, + 105, + 110, + 110, + 101, + 116, + 45, + 118, + 49, + 46, + 48, + 162, + 103, + 104, + 196, + 32, + 192, + 97, + 196, + 216, + 252, + 29, + 189, + 222, + 210, + 215, + 96, + 75, + 228, + 86, + 142, + 63, + 109, + 4, + 25, + 135, + 172, + 55, + 189, + 228, + 182, + 32, + 181, + 171, + 57, + 36, + 138, + 223, + 163, + 103, + 114, + 112, + 196, + 32, + 196, + 68, + 99, + 197, + 84, + 229, + 53, + 191, + 35, + 120, + 118, + 181, + 234, + 169, + 169, + 196, + 51, + 33, + 227, + 231, + 92, + 12, + 42, + 36, + 59, + 175, + 80, + 156, + 209, + 18, + 108, + 89, + 162, + 108, + 118, + 206, + 2, + 59, + 169, + 242, + 164, + 110, + 111, + 116, + 101, + 196, + 23, + 78, + 70, + 84, + 32, + 102, + 114, + 101, + 101, + 122, + 101, + 100, + 32, + 98, + 121, + 32, + 108, + 111, + 102, + 116, + 121, + 46, + 97, + 105, + 163, + 115, + 110, + 100, + 196, + 32, + 39, + 1, + 226, + 213, + 7, + 188, + 179, + 178, + 254, + 23, + 136, + 157, + 60, + 12, + 104, + 93, + 97, + 130, + 4, + 167, + 239, + 143, + 129, + 161, + 24, + 191, + 37, + 91, + 203, + 80, + 191, + 77, + 164, + 116, + 121, + 112, + 101, + 164, + 97, + 102, + 114, + 122 + ], + "signingPrivateKey": [ + 2, + 205, + 103, + 33, + 67, + 14, + 82, + 196, + 115, + 196, + 206, + 254, + 50, + 110, + 63, + 182, + 149, + 229, + 184, + 216, + 93, + 11, + 13, + 99, + 69, + 213, + 218, + 165, + 134, + 118, + 47, + 44 + ], + "transaction": { + "assetFreeze": { + "assetId": 1707148495, + "freezeTarget": "ZJU3X2B2QN3BUBIJ64JZ565V363ANGBUDOLXAJHDXGIIMYK6WV3NSNCBQQ", + "frozen": true + }, + "fee": 1000, + "firstValid": 37463562, + "genesisHash": [ + 192, + 97, + 196, + 216, + 252, + 29, + 189, + 222, + 210, + 215, + 96, + 75, + 228, + 86, + 142, + 63, + 109, + 4, + 25, + 135, + 172, + 55, + 189, + 228, + 182, + 32, + 181, + 171, + 57, + 36, + 138, + 223 + ], + "genesisId": "mainnet-v1.0", + "group": [ + 196, + 68, + 99, + 197, + 84, + 229, + 53, + 191, + 35, + 120, + 118, + 181, + 234, + 169, + 169, + 196, + 51, + 33, + 227, + 231, + 92, + 12, + 42, + 36, + 59, + 175, + 80, + 156, + 209, + 18, + 108, + 89 + ], + "lastValid": 37464562, + "note": [ + 78, + 70, + 84, + 32, + 102, + 114, + 101, + 101, + 122, + 101, + 100, + 32, + 98, + 121, + 32, + 108, + 111, + 102, + 116, + 121, + 46, + 97, + 105 + ], + "sender": "E4A6FVIHXSZ3F7QXRCOTYDDILVQYEBFH56HYDIIYX4SVXS2QX5GUTBVZHY", + "transactionType": "AssetFreeze" + }, + "unsignedBytes": [ + 84, + 88, + 140, + 164, + 97, + 102, + 114, + 122, + 195, + 164, + 102, + 97, + 100, + 100, + 196, + 32, + 202, + 105, + 187, + 232, + 58, + 131, + 118, + 26, + 5, + 9, + 247, + 19, + 158, + 251, + 181, + 223, + 182, + 6, + 152, + 52, + 27, + 151, + 112, + 36, + 227, + 185, + 144, + 134, + 97, + 94, + 181, + 118, + 164, + 102, + 97, + 105, + 100, + 206, + 101, + 193, + 4, + 207, + 163, + 102, + 101, + 101, + 205, + 3, + 232, + 162, + 102, + 118, + 206, + 2, + 59, + 166, + 10, + 163, + 103, + 101, + 110, + 172, + 109, + 97, + 105, + 110, + 110, + 101, + 116, + 45, + 118, + 49, + 46, + 48, + 162, + 103, + 104, + 196, + 32, + 192, + 97, + 196, + 216, + 252, + 29, + 189, + 222, + 210, + 215, + 96, + 75, + 228, + 86, + 142, + 63, + 109, + 4, + 25, + 135, + 172, + 55, + 189, + 228, + 182, + 32, + 181, + 171, + 57, + 36, + 138, + 223, + 163, + 103, + 114, + 112, + 196, + 32, + 196, + 68, + 99, + 197, + 84, + 229, + 53, + 191, + 35, + 120, + 118, + 181, + 234, + 169, + 169, + 196, + 51, + 33, + 227, + 231, + 92, + 12, + 42, + 36, + 59, + 175, + 80, + 156, + 209, + 18, + 108, + 89, + 162, + 108, + 118, + 206, + 2, + 59, + 169, + 242, + 164, + 110, + 111, + 116, + 101, + 196, + 23, + 78, + 70, + 84, + 32, + 102, + 114, + 101, + 101, + 122, + 101, + 100, + 32, + 98, + 121, + 32, + 108, + 111, + 102, + 116, + 121, + 46, + 97, + 105, + 163, + 115, + 110, + 100, + 196, + 32, + 39, + 1, + 226, + 213, + 7, + 188, + 179, + 178, + 254, + 23, + 136, + 157, + 60, + 12, + 104, + 93, + 97, + 130, + 4, + 167, + 239, + 143, + 129, + 161, + 24, + 191, + 37, + 91, + 203, + 80, + 191, + 77, + 164, + 116, + 121, + 112, + 101, + 164, + 97, + 102, + 114, + 122 + ] + }, + "assetUnfreeze": { + "id": "LZ2ODDAT4ATAVJUEQW34DIKMPCMBXCCHOSIYKMWGBPEVNHLSEV2A", + "idRaw": [ + 94, + 116, + 225, + 140, + 19, + 224, + 38, + 10, + 166, + 132, + 133, + 183, + 193, + 161, + 76, + 120, + 152, + 27, + 136, + 71, + 116, + 145, + 133, + 50, + 198, + 11, + 201, + 86, + 157, + 114, + 37, + 116 + ], + "multisigAddresses": [ + "424ZV7KBBUJ52DUKP2KLQ6I5GBOHKBXOW7Q7UQIOOYNDWYRM4EKOSMVVRI", + "NY6DHEEFW73R2NUWY562U2NNKSKBKVYY5OOQFLD3M2II5RUNKRZDEGUGEA" + ], + "multisigSignedBytes": [ + 130, + 164, + 109, + 115, + 105, + 103, + 131, + 166, + 115, + 117, + 98, + 115, + 105, + 103, + 146, + 130, + 162, + 112, + 107, + 196, + 32, + 230, + 185, + 154, + 253, + 65, + 13, + 19, + 221, + 14, + 138, + 126, + 148, + 184, + 121, + 29, + 48, + 92, + 117, + 6, + 238, + 183, + 225, + 250, + 65, + 14, + 118, + 26, + 59, + 98, + 44, + 225, + 20, + 161, + 115, + 196, + 64, + 175, + 9, + 1, + 124, + 13, + 49, + 32, + 162, + 169, + 7, + 82, + 195, + 84, + 149, + 184, + 204, + 117, + 124, + 46, + 20, + 212, + 5, + 21, + 84, + 156, + 55, + 141, + 161, + 174, + 195, + 198, + 182, + 244, + 221, + 131, + 94, + 148, + 224, + 189, + 92, + 177, + 217, + 119, + 76, + 186, + 85, + 196, + 66, + 174, + 114, + 177, + 238, + 129, + 97, + 196, + 46, + 221, + 15, + 108, + 226, + 227, + 238, + 11, + 4, + 130, + 162, + 112, + 107, + 196, + 32, + 110, + 60, + 51, + 144, + 133, + 183, + 247, + 29, + 54, + 150, + 199, + 125, + 170, + 105, + 173, + 84, + 148, + 21, + 87, + 24, + 235, + 157, + 2, + 172, + 123, + 102, + 144, + 142, + 198, + 141, + 84, + 114, + 161, + 115, + 196, + 64, + 175, + 9, + 1, + 124, + 13, + 49, + 32, + 162, + 169, + 7, + 82, + 195, + 84, + 149, + 184, + 204, + 117, + 124, + 46, + 20, + 212, + 5, + 21, + 84, + 156, + 55, + 141, + 161, + 174, + 195, + 198, + 182, + 244, + 221, + 131, + 94, + 148, + 224, + 189, + 92, + 177, + 217, + 119, + 76, + 186, + 85, + 196, + 66, + 174, + 114, + 177, + 238, + 129, + 97, + 196, + 46, + 221, + 15, + 108, + 226, + 227, + 238, + 11, + 4, + 163, + 116, + 104, + 114, + 2, + 161, + 118, + 1, + 163, + 116, + 120, + 110, + 137, + 164, + 102, + 97, + 100, + 100, + 196, + 32, + 206, + 33, + 127, + 135, + 62, + 89, + 166, + 63, + 208, + 82, + 250, + 123, + 26, + 144, + 10, + 61, + 18, + 245, + 108, + 173, + 73, + 115, + 93, + 25, + 244, + 196, + 181, + 50, + 160, + 3, + 169, + 78, + 164, + 102, + 97, + 105, + 100, + 204, + 185, + 163, + 102, + 101, + 101, + 205, + 3, + 232, + 162, + 102, + 118, + 206, + 0, + 50, + 3, + 15, + 162, + 103, + 104, + 196, + 32, + 72, + 99, + 181, + 24, + 164, + 179, + 200, + 78, + 200, + 16, + 242, + 45, + 79, + 16, + 129, + 203, + 15, + 113, + 240, + 89, + 167, + 172, + 32, + 222, + 198, + 47, + 127, + 112, + 229, + 9, + 58, + 34, + 162, + 108, + 118, + 206, + 0, + 50, + 6, + 247, + 164, + 110, + 111, + 116, + 101, + 196, + 8, + 182, + 30, + 9, + 15, + 17, + 81, + 57, + 12, + 163, + 115, + 110, + 100, + 196, + 32, + 178, + 207, + 213, + 145, + 117, + 145, + 43, + 5, + 243, + 171, + 12, + 97, + 129, + 45, + 32, + 191, + 149, + 7, + 154, + 212, + 199, + 108, + 116, + 222, + 177, + 174, + 154, + 252, + 102, + 129, + 128, + 10, + 164, + 116, + 121, + 112, + 101, + 164, + 97, + 102, + 114, + 122 + ], + "rekeyedSenderAuthAddress": "BKDYDIDVSZCP75JVCB76P3WBJRY6HWAIFDSEOKYHJY5WMNJ2UWJ65MYETU", + "rekeyedSenderSignedBytes": [ + 131, + 164, + 115, + 103, + 110, + 114, + 196, + 32, + 10, + 135, + 129, + 160, + 117, + 150, + 68, + 255, + 245, + 53, + 16, + 127, + 231, + 238, + 193, + 76, + 113, + 227, + 216, + 8, + 40, + 228, + 71, + 43, + 7, + 78, + 59, + 102, + 53, + 58, + 165, + 147, + 163, + 115, + 105, + 103, + 196, + 64, + 175, + 9, + 1, + 124, + 13, + 49, + 32, + 162, + 169, + 7, + 82, + 195, + 84, + 149, + 184, + 204, + 117, + 124, + 46, + 20, + 212, + 5, + 21, + 84, + 156, + 55, + 141, + 161, + 174, + 195, + 198, + 182, + 244, + 221, + 131, + 94, + 148, + 224, + 189, + 92, + 177, + 217, + 119, + 76, + 186, + 85, + 196, + 66, + 174, + 114, + 177, + 238, + 129, + 97, + 196, + 46, + 221, + 15, + 108, + 226, + 227, + 238, + 11, + 4, + 163, + 116, + 120, + 110, + 137, + 164, + 102, + 97, + 100, + 100, + 196, + 32, + 206, + 33, + 127, + 135, + 62, + 89, + 166, + 63, + 208, + 82, + 250, + 123, + 26, + 144, + 10, + 61, + 18, + 245, + 108, + 173, + 73, + 115, + 93, + 25, + 244, + 196, + 181, + 50, + 160, + 3, + 169, + 78, + 164, + 102, + 97, + 105, + 100, + 204, + 185, + 163, + 102, + 101, + 101, + 205, + 3, + 232, + 162, + 102, + 118, + 206, + 0, + 50, + 3, + 15, + 162, + 103, + 104, + 196, + 32, + 72, + 99, + 181, + 24, + 164, + 179, + 200, + 78, + 200, + 16, + 242, + 45, + 79, + 16, + 129, + 203, + 15, + 113, + 240, + 89, + 167, + 172, + 32, + 222, + 198, + 47, + 127, + 112, + 229, + 9, + 58, + 34, + 162, + 108, + 118, + 206, + 0, + 50, + 6, + 247, + 164, + 110, + 111, + 116, + 101, + 196, + 8, + 182, + 30, + 9, + 15, + 17, + 81, + 57, + 12, + 163, + 115, + 110, + 100, + 196, + 32, + 178, + 207, + 213, + 145, + 117, + 145, + 43, + 5, + 243, + 171, + 12, + 97, + 129, + 45, + 32, + 191, + 149, + 7, + 154, + 212, + 199, + 108, + 116, + 222, + 177, + 174, + 154, + 252, + 102, + 129, + 128, + 10, + 164, + 116, + 121, + 112, + 101, + 164, + 97, + 102, + 114, + 122 + ], + "signedBytes": [ + 130, + 163, + 115, + 105, + 103, + 196, + 64, + 175, + 9, + 1, + 124, + 13, + 49, + 32, + 162, + 169, + 7, + 82, + 195, + 84, + 149, + 184, + 204, + 117, + 124, + 46, + 20, + 212, + 5, + 21, + 84, + 156, + 55, + 141, + 161, + 174, + 195, + 198, + 182, + 244, + 221, + 131, + 94, + 148, + 224, + 189, + 92, + 177, + 217, + 119, + 76, + 186, + 85, + 196, + 66, + 174, + 114, + 177, + 238, + 129, + 97, + 196, + 46, + 221, + 15, + 108, + 226, + 227, + 238, + 11, + 4, + 163, + 116, + 120, + 110, + 137, + 164, + 102, + 97, + 100, + 100, + 196, + 32, + 206, + 33, + 127, + 135, + 62, + 89, + 166, + 63, + 208, + 82, + 250, + 123, + 26, + 144, + 10, + 61, + 18, + 245, + 108, + 173, + 73, + 115, + 93, + 25, + 244, + 196, + 181, + 50, + 160, + 3, + 169, + 78, + 164, + 102, + 97, + 105, + 100, + 204, + 185, + 163, + 102, + 101, + 101, + 205, + 3, + 232, + 162, + 102, + 118, + 206, + 0, + 50, + 3, + 15, + 162, + 103, + 104, + 196, + 32, + 72, + 99, + 181, + 24, + 164, + 179, + 200, + 78, + 200, + 16, + 242, + 45, + 79, + 16, + 129, + 203, + 15, + 113, + 240, + 89, + 167, + 172, + 32, + 222, + 198, + 47, + 127, + 112, + 229, + 9, + 58, + 34, + 162, + 108, + 118, + 206, + 0, + 50, + 6, + 247, + 164, + 110, + 111, + 116, + 101, + 196, + 8, + 182, + 30, + 9, + 15, + 17, + 81, + 57, + 12, + 163, + 115, + 110, + 100, + 196, + 32, + 178, + 207, + 213, + 145, + 117, + 145, + 43, + 5, + 243, + 171, + 12, + 97, + 129, + 45, + 32, + 191, + 149, + 7, + 154, + 212, + 199, + 108, + 116, + 222, + 177, + 174, + 154, + 252, + 102, + 129, + 128, + 10, + 164, + 116, + 121, + 112, + 101, + 164, + 97, + 102, + 114, + 122 + ], + "signingPrivateKey": [ + 2, + 205, + 103, + 33, + 67, + 14, + 82, + 196, + 115, + 196, + 206, + 254, + 50, + 110, + 63, + 182, + 149, + 229, + 184, + 216, + 93, + 11, + 13, + 99, + 69, + 213, + 218, + 165, + 134, + 118, + 47, + 44 + ], + "transaction": { + "assetFreeze": { + "assetId": 185, + "freezeTarget": "ZYQX7BZ6LGTD7UCS7J5RVEAKHUJPK3FNJFZV2GPUYS2TFIADVFHDBKTN7I" + }, + "fee": 1000, + "firstValid": 3277583, + "genesisHash": [ + 72, + 99, + 181, + 24, + 164, + 179, + 200, + 78, + 200, + 16, + 242, + 45, + 79, + 16, + 129, + 203, + 15, + 113, + 240, + 89, + 167, + 172, + 32, + 222, + 198, + 47, + 127, + 112, + 229, + 9, + 58, + 34 + ], + "lastValid": 3278583, + "note": [ + 182, + 30, + 9, + 15, + 17, + 81, + 57, + 12 + ], + "sender": "WLH5LELVSEVQL45LBRQYCLJAX6KQPGWUY5WHJXVRV2NPYZUBQAFPH22Q7A", + "transactionType": "AssetFreeze" + }, + "unsignedBytes": [ + 84, + 88, + 137, + 164, + 102, + 97, + 100, + 100, + 196, + 32, + 206, + 33, + 127, + 135, + 62, + 89, + 166, + 63, + 208, + 82, + 250, + 123, + 26, + 144, + 10, + 61, + 18, + 245, + 108, + 173, + 73, + 115, + 93, + 25, + 244, + 196, + 181, + 50, + 160, + 3, + 169, + 78, + 164, + 102, + 97, + 105, + 100, + 204, + 185, + 163, + 102, + 101, + 101, + 205, + 3, + 232, + 162, + 102, + 118, + 206, + 0, + 50, + 3, + 15, + 162, + 103, + 104, + 196, + 32, + 72, + 99, + 181, + 24, + 164, + 179, + 200, + 78, + 200, + 16, + 242, + 45, + 79, + 16, + 129, + 203, + 15, + 113, + 240, + 89, + 167, + 172, + 32, + 222, + 198, + 47, + 127, + 112, + 229, + 9, + 58, + 34, + 162, + 108, + 118, + 206, + 0, + 50, + 6, + 247, + 164, + 110, + 111, + 116, + 101, + 196, + 8, + 182, + 30, + 9, + 15, + 17, + 81, + 57, + 12, + 163, + 115, + 110, + 100, + 196, + 32, + 178, + 207, + 213, + 145, + 117, + 145, + 43, + 5, + 243, + 171, + 12, + 97, + 129, + 45, + 32, + 191, + 149, + 7, + 154, + 212, + 199, + 108, + 116, + 222, + 177, + 174, + 154, + 252, + 102, + 129, + 128, + 10, + 164, + 116, + 121, + 112, + 101, + 164, + 97, + 102, + 114, + 122 + ] + }, + "nonParticipationKeyRegistration": { + "id": "ACAP6ZGMGNTLUO3IQ26P22SRKYWTQQO3MF64GX7QO6NICDUFPM5A", + "idRaw": [ + 0, + 128, + 255, + 100, + 204, + 51, + 102, + 186, + 59, + 104, + 134, + 188, + 253, + 106, + 81, + 86, + 45, + 56, + 65, + 219, + 97, + 125, + 195, + 95, + 240, + 119, + 154, + 129, + 14, + 133, + 123, + 58 + ], + "multisigAddresses": [ + "424ZV7KBBUJ52DUKP2KLQ6I5GBOHKBXOW7Q7UQIOOYNDWYRM4EKOSMVVRI", + "NY6DHEEFW73R2NUWY562U2NNKSKBKVYY5OOQFLD3M2II5RUNKRZDEGUGEA" + ], + "multisigSignedBytes": [ + 130, + 164, + 109, + 115, + 105, + 103, + 131, + 166, + 115, + 117, + 98, + 115, + 105, + 103, + 146, + 130, + 162, + 112, + 107, + 196, + 32, + 230, + 185, + 154, + 253, + 65, + 13, + 19, + 221, + 14, + 138, + 126, + 148, + 184, + 121, + 29, + 48, + 92, + 117, + 6, + 238, + 183, + 225, + 250, + 65, + 14, + 118, + 26, + 59, + 98, + 44, + 225, + 20, + 161, + 115, + 196, + 64, + 82, + 219, + 125, + 199, + 43, + 23, + 55, + 250, + 27, + 182, + 198, + 240, + 29, + 21, + 227, + 132, + 188, + 92, + 117, + 134, + 111, + 97, + 2, + 28, + 162, + 119, + 40, + 118, + 206, + 98, + 71, + 85, + 161, + 26, + 57, + 205, + 43, + 50, + 227, + 199, + 221, + 180, + 51, + 61, + 126, + 226, + 104, + 247, + 160, + 149, + 223, + 68, + 192, + 149, + 96, + 199, + 233, + 4, + 140, + 3, + 203, + 84, + 242, + 3, + 130, + 162, + 112, + 107, + 196, + 32, + 110, + 60, + 51, + 144, + 133, + 183, + 247, + 29, + 54, + 150, + 199, + 125, + 170, + 105, + 173, + 84, + 148, + 21, + 87, + 24, + 235, + 157, + 2, + 172, + 123, + 102, + 144, + 142, + 198, + 141, + 84, + 114, + 161, + 115, + 196, + 64, + 82, + 219, + 125, + 199, + 43, + 23, + 55, + 250, + 27, + 182, + 198, + 240, + 29, + 21, + 227, + 132, + 188, + 92, + 117, + 134, + 111, + 97, + 2, + 28, + 162, + 119, + 40, + 118, + 206, + 98, + 71, + 85, + 161, + 26, + 57, + 205, + 43, + 50, + 227, + 199, + 221, + 180, + 51, + 61, + 126, + 226, + 104, + 247, + 160, + 149, + 223, + 68, + 192, + 149, + 96, + 199, + 233, + 4, + 140, + 3, + 203, + 84, + 242, + 3, + 163, + 116, + 104, + 114, + 2, + 161, + 118, + 1, + 163, + 116, + 120, + 110, + 135, + 163, + 102, + 101, + 101, + 205, + 3, + 232, + 162, + 102, + 118, + 206, + 0, + 50, + 175, + 200, + 162, + 103, + 104, + 196, + 32, + 72, + 99, + 181, + 24, + 164, + 179, + 200, + 78, + 200, + 16, + 242, + 45, + 79, + 16, + 129, + 203, + 15, + 113, + 240, + 89, + 167, + 172, + 32, + 222, + 198, + 47, + 127, + 112, + 229, + 9, + 58, + 34, + 162, + 108, + 118, + 206, + 0, + 50, + 179, + 176, + 167, + 110, + 111, + 110, + 112, + 97, + 114, + 116, + 195, + 163, + 115, + 110, + 100, + 196, + 32, + 229, + 25, + 125, + 21, + 89, + 246, + 253, + 82, + 47, + 252, + 180, + 125, + 236, + 245, + 242, + 141, + 70, + 45, + 64, + 7, + 241, + 162, + 247, + 232, + 115, + 172, + 130, + 247, + 128, + 97, + 30, + 52, + 164, + 116, + 121, + 112, + 101, + 166, + 107, + 101, + 121, + 114, + 101, + 103 + ], + "rekeyedSenderAuthAddress": "BKDYDIDVSZCP75JVCB76P3WBJRY6HWAIFDSEOKYHJY5WMNJ2UWJ65MYETU", + "rekeyedSenderSignedBytes": [ + 131, + 164, + 115, + 103, + 110, + 114, + 196, + 32, + 10, + 135, + 129, + 160, + 117, + 150, + 68, + 255, + 245, + 53, + 16, + 127, + 231, + 238, + 193, + 76, + 113, + 227, + 216, + 8, + 40, + 228, + 71, + 43, + 7, + 78, + 59, + 102, + 53, + 58, + 165, + 147, + 163, + 115, + 105, + 103, + 196, + 64, + 82, + 219, + 125, + 199, + 43, + 23, + 55, + 250, + 27, + 182, + 198, + 240, + 29, + 21, + 227, + 132, + 188, + 92, + 117, + 134, + 111, + 97, + 2, + 28, + 162, + 119, + 40, + 118, + 206, + 98, + 71, + 85, + 161, + 26, + 57, + 205, + 43, + 50, + 227, + 199, + 221, + 180, + 51, + 61, + 126, + 226, + 104, + 247, + 160, + 149, + 223, + 68, + 192, + 149, + 96, + 199, + 233, + 4, + 140, + 3, + 203, + 84, + 242, + 3, + 163, + 116, + 120, + 110, + 135, + 163, + 102, + 101, + 101, + 205, + 3, + 232, + 162, + 102, + 118, + 206, + 0, + 50, + 175, + 200, + 162, + 103, + 104, + 196, + 32, + 72, + 99, + 181, + 24, + 164, + 179, + 200, + 78, + 200, + 16, + 242, + 45, + 79, + 16, + 129, + 203, + 15, + 113, + 240, + 89, + 167, + 172, + 32, + 222, + 198, + 47, + 127, + 112, + 229, + 9, + 58, + 34, + 162, + 108, + 118, + 206, + 0, + 50, + 179, + 176, + 167, + 110, + 111, + 110, + 112, + 97, + 114, + 116, + 195, + 163, + 115, + 110, + 100, + 196, + 32, + 229, + 25, + 125, + 21, + 89, + 246, + 253, + 82, + 47, + 252, + 180, + 125, + 236, + 245, + 242, + 141, + 70, + 45, + 64, + 7, + 241, + 162, + 247, + 232, + 115, + 172, + 130, + 247, + 128, + 97, + 30, + 52, + 164, + 116, + 121, + 112, + 101, + 166, + 107, + 101, + 121, + 114, + 101, + 103 + ], + "signedBytes": [ + 130, + 163, + 115, + 105, + 103, + 196, + 64, + 82, + 219, + 125, + 199, + 43, + 23, + 55, + 250, + 27, + 182, + 198, + 240, + 29, + 21, + 227, + 132, + 188, + 92, + 117, + 134, + 111, + 97, + 2, + 28, + 162, + 119, + 40, + 118, + 206, + 98, + 71, + 85, + 161, + 26, + 57, + 205, + 43, + 50, + 227, + 199, + 221, + 180, + 51, + 61, + 126, + 226, + 104, + 247, + 160, + 149, + 223, + 68, + 192, + 149, + 96, + 199, + 233, + 4, + 140, + 3, + 203, + 84, + 242, + 3, + 163, + 116, + 120, + 110, + 135, + 163, + 102, + 101, + 101, + 205, + 3, + 232, + 162, + 102, + 118, + 206, + 0, + 50, + 175, + 200, + 162, + 103, + 104, + 196, + 32, + 72, + 99, + 181, + 24, + 164, + 179, + 200, + 78, + 200, + 16, + 242, + 45, + 79, + 16, + 129, + 203, + 15, + 113, + 240, + 89, + 167, + 172, + 32, + 222, + 198, + 47, + 127, + 112, + 229, + 9, + 58, + 34, + 162, + 108, + 118, + 206, + 0, + 50, + 179, + 176, + 167, + 110, + 111, + 110, + 112, + 97, + 114, + 116, + 195, + 163, + 115, + 110, + 100, + 196, + 32, + 229, + 25, + 125, + 21, + 89, + 246, + 253, + 82, + 47, + 252, + 180, + 125, + 236, + 245, + 242, + 141, + 70, + 45, + 64, + 7, + 241, + 162, + 247, + 232, + 115, + 172, + 130, + 247, + 128, + 97, + 30, + 52, + 164, + 116, + 121, + 112, + 101, + 166, + 107, + 101, + 121, + 114, + 101, + 103 + ], + "signingPrivateKey": [ + 2, + 205, + 103, + 33, + 67, + 14, + 82, + 196, + 115, + 196, + 206, + 254, + 50, + 110, + 63, + 182, + 149, + 229, + 184, + 216, + 93, + 11, + 13, + 99, + 69, + 213, + 218, + 165, + 134, + 118, + 47, + 44 + ], + "transaction": { + "fee": 1000, + "firstValid": 3321800, + "genesisHash": [ + 72, + 99, + 181, + 24, + 164, + 179, + 200, + 78, + 200, + 16, + 242, + 45, + 79, + 16, + 129, + 203, + 15, + 113, + 240, + 89, + 167, + 172, + 32, + 222, + 198, + 47, + 127, + 112, + 229, + 9, + 58, + 34 + ], + "keyRegistration": { + "nonParticipation": true + }, + "lastValid": 3322800, + "sender": "4UMX2FKZ636VEL74WR66Z5PSRVDC2QAH6GRPP2DTVSBPPADBDY2JB3PN2U", + "transactionType": "KeyRegistration" + }, + "unsignedBytes": [ + 84, + 88, + 135, + 163, + 102, + 101, + 101, + 205, + 3, + 232, + 162, + 102, + 118, + 206, + 0, + 50, + 175, + 200, + 162, + 103, + 104, + 196, + 32, + 72, + 99, + 181, + 24, + 164, + 179, + 200, + 78, + 200, + 16, + 242, + 45, + 79, + 16, + 129, + 203, + 15, + 113, + 240, + 89, + 167, + 172, + 32, + 222, + 198, + 47, + 127, + 112, + 229, + 9, + 58, + 34, + 162, + 108, + 118, + 206, + 0, + 50, + 179, + 176, + 167, + 110, + 111, + 110, + 112, + 97, + 114, + 116, + 195, + 163, + 115, + 110, + 100, + 196, + 32, + 229, + 25, + 125, + 21, + 89, + 246, + 253, + 82, + 47, + 252, + 180, + 125, + 236, + 245, + 242, + 141, + 70, + 45, + 64, + 7, + 241, + 162, + 247, + 232, + 115, + 172, + 130, + 247, + 128, + 97, + 30, + 52, + 164, + 116, + 121, + 112, + 101, + 166, + 107, + 101, + 121, + 114, + 101, + 103 + ] + }, + "offlineKeyRegistration": { + "id": "WAXJLC44RILOSYX73PJULCAWC43DNBU4AXMWHIRARXK4GO2LHEDQ", + "idRaw": [ + 176, + 46, + 149, + 139, + 156, + 138, + 22, + 233, + 98, + 255, + 219, + 211, + 69, + 136, + 22, + 23, + 54, + 54, + 134, + 156, + 5, + 217, + 99, + 162, + 32, + 141, + 213, + 195, + 59, + 75, + 57, + 7 + ], + "multisigAddresses": [ + "424ZV7KBBUJ52DUKP2KLQ6I5GBOHKBXOW7Q7UQIOOYNDWYRM4EKOSMVVRI", + "NY6DHEEFW73R2NUWY562U2NNKSKBKVYY5OOQFLD3M2II5RUNKRZDEGUGEA" + ], + "multisigSignedBytes": [ + 130, + 164, + 109, + 115, + 105, + 103, + 131, + 166, + 115, + 117, + 98, + 115, + 105, + 103, + 146, + 130, + 162, + 112, + 107, + 196, + 32, + 230, + 185, + 154, + 253, + 65, + 13, + 19, + 221, + 14, + 138, + 126, + 148, + 184, + 121, + 29, + 48, + 92, + 117, + 6, + 238, + 183, + 225, + 250, + 65, + 14, + 118, + 26, + 59, + 98, + 44, + 225, + 20, + 161, + 115, + 196, + 64, + 189, + 220, + 32, + 136, + 199, + 234, + 169, + 51, + 214, + 17, + 225, + 131, + 94, + 247, + 38, + 92, + 187, + 153, + 195, + 116, + 217, + 131, + 87, + 16, + 197, + 148, + 162, + 211, + 218, + 172, + 114, + 3, + 153, + 153, + 178, + 253, + 11, + 15, + 221, + 204, + 161, + 37, + 110, + 102, + 187, + 50, + 12, + 155, + 27, + 150, + 191, + 131, + 42, + 174, + 90, + 46, + 10, + 90, + 50, + 43, + 250, + 149, + 205, + 9, + 130, + 162, + 112, + 107, + 196, + 32, + 110, + 60, + 51, + 144, + 133, + 183, + 247, + 29, + 54, + 150, + 199, + 125, + 170, + 105, + 173, + 84, + 148, + 21, + 87, + 24, + 235, + 157, + 2, + 172, + 123, + 102, + 144, + 142, + 198, + 141, + 84, + 114, + 161, + 115, + 196, + 64, + 189, + 220, + 32, + 136, + 199, + 234, + 169, + 51, + 214, + 17, + 225, + 131, + 94, + 247, + 38, + 92, + 187, + 153, + 195, + 116, + 217, + 131, + 87, + 16, + 197, + 148, + 162, + 211, + 218, + 172, + 114, + 3, + 153, + 153, + 178, + 253, + 11, + 15, + 221, + 204, + 161, + 37, + 110, + 102, + 187, + 50, + 12, + 155, + 27, + 150, + 191, + 131, + 42, + 174, + 90, + 46, + 10, + 90, + 50, + 43, + 250, + 149, + 205, + 9, + 163, + 116, + 104, + 114, + 2, + 161, + 118, + 1, + 163, + 116, + 120, + 110, + 134, + 163, + 102, + 101, + 101, + 205, + 3, + 232, + 162, + 102, + 118, + 206, + 3, + 33, + 244, + 82, + 162, + 103, + 104, + 196, + 32, + 72, + 99, + 181, + 24, + 164, + 179, + 200, + 78, + 200, + 16, + 242, + 45, + 79, + 16, + 129, + 203, + 15, + 113, + 240, + 89, + 167, + 172, + 32, + 222, + 198, + 47, + 127, + 112, + 229, + 9, + 58, + 34, + 162, + 108, + 118, + 206, + 3, + 33, + 248, + 58, + 163, + 115, + 110, + 100, + 196, + 32, + 183, + 86, + 171, + 147, + 129, + 55, + 220, + 209, + 253, + 79, + 52, + 174, + 241, + 185, + 216, + 128, + 209, + 55, + 182, + 95, + 108, + 135, + 79, + 251, + 250, + 155, + 188, + 142, + 68, + 109, + 145, + 11, + 164, + 116, + 121, + 112, + 101, + 166, + 107, + 101, + 121, + 114, + 101, + 103 + ], + "rekeyedSenderAuthAddress": "BKDYDIDVSZCP75JVCB76P3WBJRY6HWAIFDSEOKYHJY5WMNJ2UWJ65MYETU", + "rekeyedSenderSignedBytes": [ + 131, + 164, + 115, + 103, + 110, + 114, + 196, + 32, + 10, + 135, + 129, + 160, + 117, + 150, + 68, + 255, + 245, + 53, + 16, + 127, + 231, + 238, + 193, + 76, + 113, + 227, + 216, + 8, + 40, + 228, + 71, + 43, + 7, + 78, + 59, + 102, + 53, + 58, + 165, + 147, + 163, + 115, + 105, + 103, + 196, + 64, + 189, + 220, + 32, + 136, + 199, + 234, + 169, + 51, + 214, + 17, + 225, + 131, + 94, + 247, + 38, + 92, + 187, + 153, + 195, + 116, + 217, + 131, + 87, + 16, + 197, + 148, + 162, + 211, + 218, + 172, + 114, + 3, + 153, + 153, + 178, + 253, + 11, + 15, + 221, + 204, + 161, + 37, + 110, + 102, + 187, + 50, + 12, + 155, + 27, + 150, + 191, + 131, + 42, + 174, + 90, + 46, + 10, + 90, + 50, + 43, + 250, + 149, + 205, + 9, + 163, + 116, + 120, + 110, + 134, + 163, + 102, + 101, + 101, + 205, + 3, + 232, + 162, + 102, + 118, + 206, + 3, + 33, + 244, + 82, + 162, + 103, + 104, + 196, + 32, + 72, + 99, + 181, + 24, + 164, + 179, + 200, + 78, + 200, + 16, + 242, + 45, + 79, + 16, + 129, + 203, + 15, + 113, + 240, + 89, + 167, + 172, + 32, + 222, + 198, + 47, + 127, + 112, + 229, + 9, + 58, + 34, + 162, + 108, + 118, + 206, + 3, + 33, + 248, + 58, + 163, + 115, + 110, + 100, + 196, + 32, + 183, + 86, + 171, + 147, + 129, + 55, + 220, + 209, + 253, + 79, + 52, + 174, + 241, + 185, + 216, + 128, + 209, + 55, + 182, + 95, + 108, + 135, + 79, + 251, + 250, + 155, + 188, + 142, + 68, + 109, + 145, + 11, + 164, + 116, + 121, + 112, + 101, + 166, + 107, + 101, + 121, + 114, + 101, + 103 + ], + "signedBytes": [ + 130, + 163, + 115, + 105, + 103, + 196, + 64, + 189, + 220, + 32, + 136, + 199, + 234, + 169, + 51, + 214, + 17, + 225, + 131, + 94, + 247, + 38, + 92, + 187, + 153, + 195, + 116, + 217, + 131, + 87, + 16, + 197, + 148, + 162, + 211, + 218, + 172, + 114, + 3, + 153, + 153, + 178, + 253, + 11, + 15, + 221, + 204, + 161, + 37, + 110, + 102, + 187, + 50, + 12, + 155, + 27, + 150, + 191, + 131, + 42, + 174, + 90, + 46, + 10, + 90, + 50, + 43, + 250, + 149, + 205, + 9, + 163, + 116, + 120, + 110, + 134, + 163, + 102, + 101, + 101, + 205, + 3, + 232, + 162, + 102, + 118, + 206, + 3, + 33, + 244, + 82, + 162, + 103, + 104, + 196, + 32, + 72, + 99, + 181, + 24, + 164, + 179, + 200, + 78, + 200, + 16, + 242, + 45, + 79, + 16, + 129, + 203, + 15, + 113, + 240, + 89, + 167, + 172, + 32, + 222, + 198, + 47, + 127, + 112, + 229, + 9, + 58, + 34, + 162, + 108, + 118, + 206, + 3, + 33, + 248, + 58, + 163, + 115, + 110, + 100, + 196, + 32, + 183, + 86, + 171, + 147, + 129, + 55, + 220, + 209, + 253, + 79, + 52, + 174, + 241, + 185, + 216, + 128, + 209, + 55, + 182, + 95, + 108, + 135, + 79, + 251, + 250, + 155, + 188, + 142, + 68, + 109, + 145, + 11, + 164, + 116, + 121, + 112, + 101, + 166, + 107, + 101, + 121, + 114, + 101, + 103 + ], + "signingPrivateKey": [ + 2, + 205, + 103, + 33, + 67, + 14, + 82, + 196, + 115, + 196, + 206, + 254, + 50, + 110, + 63, + 182, + 149, + 229, + 184, + 216, + 93, + 11, + 13, + 99, + 69, + 213, + 218, + 165, + 134, + 118, + 47, + 44 + ], + "transaction": { + "fee": 1000, + "firstValid": 52556882, + "genesisHash": [ + 72, + 99, + 181, + 24, + 164, + 179, + 200, + 78, + 200, + 16, + 242, + 45, + 79, + 16, + 129, + 203, + 15, + 113, + 240, + 89, + 167, + 172, + 32, + 222, + 198, + 47, + 127, + 112, + 229, + 9, + 58, + 34 + ], + "keyRegistration": {}, + "lastValid": 52557882, + "sender": "W5LKXE4BG7OND7KPGSXPDOOYQDITPNS7NSDU7672TO6I4RDNSEFWXRPISQ", + "transactionType": "KeyRegistration" + }, + "unsignedBytes": [ + 84, + 88, + 134, + 163, + 102, + 101, + 101, + 205, + 3, + 232, + 162, + 102, + 118, + 206, + 3, + 33, + 244, + 82, + 162, + 103, + 104, + 196, + 32, + 72, + 99, + 181, + 24, + 164, + 179, + 200, + 78, + 200, + 16, + 242, + 45, + 79, + 16, + 129, + 203, + 15, + 113, + 240, + 89, + 167, + 172, + 32, + 222, + 198, + 47, + 127, + 112, + 229, + 9, + 58, + 34, + 162, + 108, + 118, + 206, + 3, + 33, + 248, + 58, + 163, + 115, + 110, + 100, + 196, + 32, + 183, + 86, + 171, + 147, + 129, + 55, + 220, + 209, + 253, + 79, + 52, + 174, + 241, + 185, + 216, + 128, + 209, + 55, + 182, + 95, + 108, + 135, + 79, + 251, + 250, + 155, + 188, + 142, + 68, + 109, + 145, + 11, + 164, + 116, + 121, + 112, + 101, + 166, + 107, + 101, + 121, + 114, + 101, + 103 + ] + }, + "onlineKeyRegistration": { + "id": "UCWQQKWB3CMPVK6EU2ML7CN5IDYZJVVSVS3RXYEOLJUURX44SUKQ", + "idRaw": [ + 160, + 173, + 8, + 42, + 193, + 216, + 152, + 250, + 171, + 196, + 166, + 152, + 191, + 137, + 189, + 64, + 241, + 148, + 214, + 178, + 172, + 183, + 27, + 224, + 142, + 90, + 105, + 72, + 223, + 156, + 149, + 21 + ], + "multisigAddresses": [ + "424ZV7KBBUJ52DUKP2KLQ6I5GBOHKBXOW7Q7UQIOOYNDWYRM4EKOSMVVRI", + "NY6DHEEFW73R2NUWY562U2NNKSKBKVYY5OOQFLD3M2II5RUNKRZDEGUGEA" + ], + "multisigSignedBytes": [ + 130, + 164, + 109, + 115, + 105, + 103, + 131, + 166, + 115, + 117, + 98, + 115, + 105, + 103, + 146, + 130, + 162, + 112, + 107, + 196, + 32, + 230, + 185, + 154, + 253, + 65, + 13, + 19, + 221, + 14, + 138, + 126, + 148, + 184, + 121, + 29, + 48, + 92, + 117, + 6, + 238, + 183, + 225, + 250, + 65, + 14, + 118, + 26, + 59, + 98, + 44, + 225, + 20, + 161, + 115, + 196, + 64, + 20, + 166, + 252, + 4, + 86, + 193, + 231, + 220, + 171, + 119, + 139, + 25, + 206, + 212, + 40, + 150, + 27, + 230, + 32, + 71, + 87, + 45, + 14, + 68, + 99, + 44, + 36, + 190, + 155, + 232, + 11, + 159, + 241, + 72, + 208, + 164, + 157, + 34, + 29, + 16, + 32, + 72, + 77, + 247, + 225, + 144, + 96, + 250, + 110, + 200, + 51, + 169, + 194, + 205, + 250, + 38, + 92, + 191, + 82, + 247, + 239, + 161, + 180, + 4, + 130, + 162, + 112, + 107, + 196, + 32, + 110, + 60, + 51, + 144, + 133, + 183, + 247, + 29, + 54, + 150, + 199, + 125, + 170, + 105, + 173, + 84, + 148, + 21, + 87, + 24, + 235, + 157, + 2, + 172, + 123, + 102, + 144, + 142, + 198, + 141, + 84, + 114, + 161, + 115, + 196, + 64, + 20, + 166, + 252, + 4, + 86, + 193, + 231, + 220, + 171, + 119, + 139, + 25, + 206, + 212, + 40, + 150, + 27, + 230, + 32, + 71, + 87, + 45, + 14, + 68, + 99, + 44, + 36, + 190, + 155, + 232, + 11, + 159, + 241, + 72, + 208, + 164, + 157, + 34, + 29, + 16, + 32, + 72, + 77, + 247, + 225, + 144, + 96, + 250, + 110, + 200, + 51, + 169, + 194, + 205, + 250, + 38, + 92, + 191, + 82, + 247, + 239, + 161, + 180, + 4, + 163, + 116, + 104, + 114, + 2, + 161, + 118, + 1, + 163, + 116, + 120, + 110, + 140, + 163, + 102, + 101, + 101, + 206, + 0, + 30, + 132, + 128, + 162, + 102, + 118, + 206, + 3, + 45, + 27, + 200, + 162, + 103, + 104, + 196, + 32, + 72, + 99, + 181, + 24, + 164, + 179, + 200, + 78, + 200, + 16, + 242, + 45, + 79, + 16, + 129, + 203, + 15, + 113, + 240, + 89, + 167, + 172, + 32, + 222, + 198, + 47, + 127, + 112, + 229, + 9, + 58, + 34, + 162, + 108, + 118, + 206, + 3, + 45, + 31, + 176, + 166, + 115, + 101, + 108, + 107, + 101, + 121, + 196, + 32, + 166, + 47, + 46, + 216, + 120, + 87, + 123, + 170, + 129, + 228, + 130, + 12, + 77, + 41, + 246, + 188, + 168, + 150, + 144, + 56, + 76, + 8, + 233, + 53, + 27, + 97, + 183, + 163, + 38, + 158, + 74, + 80, + 163, + 115, + 110, + 100, + 196, + 32, + 122, + 129, + 42, + 29, + 41, + 249, + 192, + 177, + 248, + 55, + 10, + 28, + 184, + 78, + 37, + 56, + 31, + 227, + 151, + 83, + 6, + 33, + 253, + 240, + 155, + 215, + 74, + 97, + 196, + 62, + 241, + 9, + 167, + 115, + 112, + 114, + 102, + 107, + 101, + 121, + 196, + 64, + 250, + 29, + 21, + 206, + 160, + 201, + 32, + 225, + 26, + 97, + 54, + 130, + 24, + 54, + 76, + 87, + 72, + 217, + 41, + 14, + 18, + 134, + 197, + 107, + 135, + 44, + 142, + 108, + 235, + 190, + 179, + 124, + 133, + 215, + 234, + 11, + 167, + 102, + 248, + 151, + 245, + 134, + 12, + 90, + 117, + 250, + 67, + 155, + 85, + 92, + 168, + 53, + 192, + 152, + 202, + 225, + 53, + 228, + 235, + 50, + 2, + 22, + 25, + 198, + 164, + 116, + 121, + 112, + 101, + 166, + 107, + 101, + 121, + 114, + 101, + 103, + 167, + 118, + 111, + 116, + 101, + 102, + 115, + 116, + 206, + 3, + 45, + 26, + 255, + 166, + 118, + 111, + 116, + 101, + 107, + 100, + 205, + 6, + 197, + 167, + 118, + 111, + 116, + 101, + 107, + 101, + 121, + 196, + 32, + 141, + 124, + 240, + 196, + 205, + 175, + 82, + 157, + 63, + 193, + 214, + 179, + 130, + 238, + 155, + 123, + 176, + 94, + 176, + 57, + 253, + 52, + 160, + 131, + 104, + 71, + 239, + 192, + 163, + 38, + 133, + 49, + 167, + 118, + 111, + 116, + 101, + 108, + 115, + 116, + 206, + 3, + 90, + 225, + 191 + ], + "rekeyedSenderAuthAddress": "BKDYDIDVSZCP75JVCB76P3WBJRY6HWAIFDSEOKYHJY5WMNJ2UWJ65MYETU", + "rekeyedSenderSignedBytes": [ + 131, + 164, + 115, + 103, + 110, + 114, + 196, + 32, + 10, + 135, + 129, + 160, + 117, + 150, + 68, + 255, + 245, + 53, + 16, + 127, + 231, + 238, + 193, + 76, + 113, + 227, + 216, + 8, + 40, + 228, + 71, + 43, + 7, + 78, + 59, + 102, + 53, + 58, + 165, + 147, + 163, + 115, + 105, + 103, + 196, + 64, + 20, + 166, + 252, + 4, + 86, + 193, + 231, + 220, + 171, + 119, + 139, + 25, + 206, + 212, + 40, + 150, + 27, + 230, + 32, + 71, + 87, + 45, + 14, + 68, + 99, + 44, + 36, + 190, + 155, + 232, + 11, + 159, + 241, + 72, + 208, + 164, + 157, + 34, + 29, + 16, + 32, + 72, + 77, + 247, + 225, + 144, + 96, + 250, + 110, + 200, + 51, + 169, + 194, + 205, + 250, + 38, + 92, + 191, + 82, + 247, + 239, + 161, + 180, + 4, + 163, + 116, + 120, + 110, + 140, + 163, + 102, + 101, + 101, + 206, + 0, + 30, + 132, + 128, + 162, + 102, + 118, + 206, + 3, + 45, + 27, + 200, + 162, + 103, + 104, + 196, + 32, + 72, + 99, + 181, + 24, + 164, + 179, + 200, + 78, + 200, + 16, + 242, + 45, + 79, + 16, + 129, + 203, + 15, + 113, + 240, + 89, + 167, + 172, + 32, + 222, + 198, + 47, + 127, + 112, + 229, + 9, + 58, + 34, + 162, + 108, + 118, + 206, + 3, + 45, + 31, + 176, + 166, + 115, + 101, + 108, + 107, + 101, + 121, + 196, + 32, + 166, + 47, + 46, + 216, + 120, + 87, + 123, + 170, + 129, + 228, + 130, + 12, + 77, + 41, + 246, + 188, + 168, + 150, + 144, + 56, + 76, + 8, + 233, + 53, + 27, + 97, + 183, + 163, + 38, + 158, + 74, + 80, + 163, + 115, + 110, + 100, + 196, + 32, + 122, + 129, + 42, + 29, + 41, + 249, + 192, + 177, + 248, + 55, + 10, + 28, + 184, + 78, + 37, + 56, + 31, + 227, + 151, + 83, + 6, + 33, + 253, + 240, + 155, + 215, + 74, + 97, + 196, + 62, + 241, + 9, + 167, + 115, + 112, + 114, + 102, + 107, + 101, + 121, + 196, + 64, + 250, + 29, + 21, + 206, + 160, + 201, + 32, + 225, + 26, + 97, + 54, + 130, + 24, + 54, + 76, + 87, + 72, + 217, + 41, + 14, + 18, + 134, + 197, + 107, + 135, + 44, + 142, + 108, + 235, + 190, + 179, + 124, + 133, + 215, + 234, + 11, + 167, + 102, + 248, + 151, + 245, + 134, + 12, + 90, + 117, + 250, + 67, + 155, + 85, + 92, + 168, + 53, + 192, + 152, + 202, + 225, + 53, + 228, + 235, + 50, + 2, + 22, + 25, + 198, + 164, + 116, + 121, + 112, + 101, + 166, + 107, + 101, + 121, + 114, + 101, + 103, + 167, + 118, + 111, + 116, + 101, + 102, + 115, + 116, + 206, + 3, + 45, + 26, + 255, + 166, + 118, + 111, + 116, + 101, + 107, + 100, + 205, + 6, + 197, + 167, + 118, + 111, + 116, + 101, + 107, + 101, + 121, + 196, + 32, + 141, + 124, + 240, + 196, + 205, + 175, + 82, + 157, + 63, + 193, + 214, + 179, + 130, + 238, + 155, + 123, + 176, + 94, + 176, + 57, + 253, + 52, + 160, + 131, + 104, + 71, + 239, + 192, + 163, + 38, + 133, + 49, + 167, + 118, + 111, + 116, + 101, + 108, + 115, + 116, + 206, + 3, + 90, + 225, + 191 + ], + "signedBytes": [ + 130, + 163, + 115, + 105, + 103, + 196, + 64, + 20, + 166, + 252, + 4, + 86, + 193, + 231, + 220, + 171, + 119, + 139, + 25, + 206, + 212, + 40, + 150, + 27, + 230, + 32, + 71, + 87, + 45, + 14, + 68, + 99, + 44, + 36, + 190, + 155, + 232, + 11, + 159, + 241, + 72, + 208, + 164, + 157, + 34, + 29, + 16, + 32, + 72, + 77, + 247, + 225, + 144, + 96, + 250, + 110, + 200, + 51, + 169, + 194, + 205, + 250, + 38, + 92, + 191, + 82, + 247, + 239, + 161, + 180, + 4, + 163, + 116, + 120, + 110, + 140, + 163, + 102, + 101, + 101, + 206, + 0, + 30, + 132, + 128, + 162, + 102, + 118, + 206, + 3, + 45, + 27, + 200, + 162, + 103, + 104, + 196, + 32, + 72, + 99, + 181, + 24, + 164, + 179, + 200, + 78, + 200, + 16, + 242, + 45, + 79, + 16, + 129, + 203, + 15, + 113, + 240, + 89, + 167, + 172, + 32, + 222, + 198, + 47, + 127, + 112, + 229, + 9, + 58, + 34, + 162, + 108, + 118, + 206, + 3, + 45, + 31, + 176, + 166, + 115, + 101, + 108, + 107, + 101, + 121, + 196, + 32, + 166, + 47, + 46, + 216, + 120, + 87, + 123, + 170, + 129, + 228, + 130, + 12, + 77, + 41, + 246, + 188, + 168, + 150, + 144, + 56, + 76, + 8, + 233, + 53, + 27, + 97, + 183, + 163, + 38, + 158, + 74, + 80, + 163, + 115, + 110, + 100, + 196, + 32, + 122, + 129, + 42, + 29, + 41, + 249, + 192, + 177, + 248, + 55, + 10, + 28, + 184, + 78, + 37, + 56, + 31, + 227, + 151, + 83, + 6, + 33, + 253, + 240, + 155, + 215, + 74, + 97, + 196, + 62, + 241, + 9, + 167, + 115, + 112, + 114, + 102, + 107, + 101, + 121, + 196, + 64, + 250, + 29, + 21, + 206, + 160, + 201, + 32, + 225, + 26, + 97, + 54, + 130, + 24, + 54, + 76, + 87, + 72, + 217, + 41, + 14, + 18, + 134, + 197, + 107, + 135, + 44, + 142, + 108, + 235, + 190, + 179, + 124, + 133, + 215, + 234, + 11, + 167, + 102, + 248, + 151, + 245, + 134, + 12, + 90, + 117, + 250, + 67, + 155, + 85, + 92, + 168, + 53, + 192, + 152, + 202, + 225, + 53, + 228, + 235, + 50, + 2, + 22, + 25, + 198, + 164, + 116, + 121, + 112, + 101, + 166, + 107, + 101, + 121, + 114, + 101, + 103, + 167, + 118, + 111, + 116, + 101, + 102, + 115, + 116, + 206, + 3, + 45, + 26, + 255, + 166, + 118, + 111, + 116, + 101, + 107, + 100, + 205, + 6, + 197, + 167, + 118, + 111, + 116, + 101, + 107, + 101, + 121, + 196, + 32, + 141, + 124, + 240, + 196, + 205, + 175, + 82, + 157, + 63, + 193, + 214, + 179, + 130, + 238, + 155, + 123, + 176, + 94, + 176, + 57, + 253, + 52, + 160, + 131, + 104, + 71, + 239, + 192, + 163, + 38, + 133, + 49, + 167, + 118, + 111, + 116, + 101, + 108, + 115, + 116, + 206, + 3, + 90, + 225, + 191 + ], + "signingPrivateKey": [ + 2, + 205, + 103, + 33, + 67, + 14, + 82, + 196, + 115, + 196, + 206, + 254, + 50, + 110, + 63, + 182, + 149, + 229, + 184, + 216, + 93, + 11, + 13, + 99, + 69, + 213, + 218, + 165, + 134, + 118, + 47, + 44 + ], + "transaction": { + "fee": 2000000, + "firstValid": 53287880, + "genesisHash": [ + 72, + 99, + 181, + 24, + 164, + 179, + 200, + 78, + 200, + 16, + 242, + 45, + 79, + 16, + 129, + 203, + 15, + 113, + 240, + 89, + 167, + 172, + 32, + 222, + 198, + 47, + 127, + 112, + 229, + 9, + 58, + 34 + ], + "keyRegistration": { + "selectionKey": [ + 166, + 47, + 46, + 216, + 120, + 87, + 123, + 170, + 129, + 228, + 130, + 12, + 77, + 41, + 246, + 188, + 168, + 150, + 144, + 56, + 76, + 8, + 233, + 53, + 27, + 97, + 183, + 163, + 38, + 158, + 74, + 80 + ], + "stateProofKey": [ + 250, + 29, + 21, + 206, + 160, + 201, + 32, + 225, + 26, + 97, + 54, + 130, + 24, + 54, + 76, + 87, + 72, + 217, + 41, + 14, + 18, + 134, + 197, + 107, + 135, + 44, + 142, + 108, + 235, + 190, + 179, + 124, + 133, + 215, + 234, + 11, + 167, + 102, + 248, + 151, + 245, + 134, + 12, + 90, + 117, + 250, + 67, + 155, + 85, + 92, + 168, + 53, + 192, + 152, + 202, + 225, + 53, + 228, + 235, + 50, + 2, + 22, + 25, + 198 + ], + "voteFirst": 53287679, + "voteKey": [ + 141, + 124, + 240, + 196, + 205, + 175, + 82, + 157, + 63, + 193, + 214, + 179, + 130, + 238, + 155, + 123, + 176, + 94, + 176, + 57, + 253, + 52, + 160, + 131, + 104, + 71, + 239, + 192, + 163, + 38, + 133, + 49 + ], + "voteKeyDilution": 1733, + "voteLast": 56287679 + }, + "lastValid": 53288880, + "sender": "PKASUHJJ7HALD6BXBIOLQTRFHAP6HF2TAYQ734E325FGDRB66EE6MYQGTM", + "transactionType": "KeyRegistration" + }, + "unsignedBytes": [ + 84, + 88, + 140, + 163, + 102, + 101, + 101, + 206, + 0, + 30, + 132, + 128, + 162, + 102, + 118, + 206, + 3, + 45, + 27, + 200, + 162, + 103, + 104, + 196, + 32, + 72, + 99, + 181, + 24, + 164, + 179, + 200, + 78, + 200, + 16, + 242, + 45, + 79, + 16, + 129, + 203, + 15, + 113, + 240, + 89, + 167, + 172, + 32, + 222, + 198, + 47, + 127, + 112, + 229, + 9, + 58, + 34, + 162, + 108, + 118, + 206, + 3, + 45, + 31, + 176, + 166, + 115, + 101, + 108, + 107, + 101, + 121, + 196, + 32, + 166, + 47, + 46, + 216, + 120, + 87, + 123, + 170, + 129, + 228, + 130, + 12, + 77, + 41, + 246, + 188, + 168, + 150, + 144, + 56, + 76, + 8, + 233, + 53, + 27, + 97, + 183, + 163, + 38, + 158, + 74, + 80, + 163, + 115, + 110, + 100, + 196, + 32, + 122, + 129, + 42, + 29, + 41, + 249, + 192, + 177, + 248, + 55, + 10, + 28, + 184, + 78, + 37, + 56, + 31, + 227, + 151, + 83, + 6, + 33, + 253, + 240, + 155, + 215, + 74, + 97, + 196, + 62, + 241, + 9, + 167, + 115, + 112, + 114, + 102, + 107, + 101, + 121, + 196, + 64, + 250, + 29, + 21, + 206, + 160, + 201, + 32, + 225, + 26, + 97, + 54, + 130, + 24, + 54, + 76, + 87, + 72, + 217, + 41, + 14, + 18, + 134, + 197, + 107, + 135, + 44, + 142, + 108, + 235, + 190, + 179, + 124, + 133, + 215, + 234, + 11, + 167, + 102, + 248, + 151, + 245, + 134, + 12, + 90, + 117, + 250, + 67, + 155, + 85, + 92, + 168, + 53, + 192, + 152, + 202, + 225, + 53, + 228, + 235, + 50, + 2, + 22, + 25, + 198, + 164, + 116, + 121, + 112, + 101, + 166, + 107, + 101, + 121, + 114, + 101, + 103, + 167, + 118, + 111, + 116, + 101, + 102, + 115, + 116, + 206, + 3, + 45, + 26, + 255, + 166, + 118, + 111, + 116, + 101, + 107, + 100, + 205, + 6, + 197, + 167, + 118, + 111, + 116, + 101, + 107, + 101, + 121, + 196, + 32, + 141, + 124, + 240, + 196, + 205, + 175, + 82, + 157, + 63, + 193, + 214, + 179, + 130, + 238, + 155, + 123, + 176, + 94, + 176, + 57, + 253, + 52, + 160, + 131, + 104, + 71, + 239, + 192, + 163, + 38, + 133, + 49, + 167, + 118, + 111, + 116, + 101, + 108, + 115, + 116, + 206, + 3, + 90, + 225, + 191 + ] + }, + "optInAssetTransfer": { + "id": "JIDBHDPLBASULQZFI4EY5FJWR6VQRMPPFSGYBKE2XKW65N3UQJXA", + "idRaw": [ + 74, + 6, + 19, + 141, + 235, + 8, + 37, + 69, + 195, + 37, + 71, + 9, + 142, + 149, + 54, + 143, + 171, + 8, + 177, + 239, + 44, + 141, + 128, + 168, + 154, + 186, + 173, + 238, + 183, + 116, + 130, + 110 + ], + "multisigAddresses": [ + "424ZV7KBBUJ52DUKP2KLQ6I5GBOHKBXOW7Q7UQIOOYNDWYRM4EKOSMVVRI", + "NY6DHEEFW73R2NUWY562U2NNKSKBKVYY5OOQFLD3M2II5RUNKRZDEGUGEA" + ], + "multisigSignedBytes": [ + 130, + 164, + 109, + 115, + 105, + 103, + 131, + 166, + 115, + 117, + 98, + 115, + 105, + 103, + 146, + 130, + 162, + 112, + 107, + 196, + 32, + 230, + 185, + 154, + 253, + 65, + 13, + 19, + 221, + 14, + 138, + 126, + 148, + 184, + 121, + 29, + 48, + 92, + 117, + 6, + 238, + 183, + 225, + 250, + 65, + 14, + 118, + 26, + 59, + 98, + 44, + 225, + 20, + 161, + 115, + 196, + 64, + 108, + 27, + 242, + 197, + 141, + 1, + 233, + 137, + 108, + 190, + 54, + 245, + 55, + 173, + 43, + 72, + 68, + 36, + 204, + 128, + 202, + 112, + 148, + 46, + 178, + 69, + 192, + 121, + 3, + 159, + 167, + 170, + 75, + 211, + 7, + 248, + 87, + 195, + 171, + 222, + 105, + 44, + 38, + 162, + 25, + 58, + 154, + 189, + 182, + 48, + 252, + 167, + 101, + 145, + 73, + 180, + 101, + 107, + 181, + 191, + 37, + 57, + 211, + 1, + 130, + 162, + 112, + 107, + 196, + 32, + 110, + 60, + 51, + 144, + 133, + 183, + 247, + 29, + 54, + 150, + 199, + 125, + 170, + 105, + 173, + 84, + 148, + 21, + 87, + 24, + 235, + 157, + 2, + 172, + 123, + 102, + 144, + 142, + 198, + 141, + 84, + 114, + 161, + 115, + 196, + 64, + 108, + 27, + 242, + 197, + 141, + 1, + 233, + 137, + 108, + 190, + 54, + 245, + 55, + 173, + 43, + 72, + 68, + 36, + 204, + 128, + 202, + 112, + 148, + 46, + 178, + 69, + 192, + 121, + 3, + 159, + 167, + 170, + 75, + 211, + 7, + 248, + 87, + 195, + 171, + 222, + 105, + 44, + 38, + 162, + 25, + 58, + 154, + 189, + 182, + 48, + 252, + 167, + 101, + 145, + 73, + 180, + 101, + 107, + 181, + 191, + 37, + 57, + 211, + 1, + 163, + 116, + 104, + 114, + 2, + 161, + 118, + 1, + 163, + 116, + 120, + 110, + 137, + 164, + 97, + 114, + 99, + 118, + 196, + 32, + 72, + 118, + 175, + 30, + 96, + 187, + 134, + 238, + 76, + 228, + 146, + 219, + 137, + 200, + 222, + 52, + 40, + 86, + 146, + 168, + 129, + 190, + 15, + 103, + 21, + 24, + 5, + 31, + 88, + 27, + 201, + 123, + 163, + 102, + 101, + 101, + 205, + 3, + 232, + 162, + 102, + 118, + 206, + 3, + 13, + 0, + 56, + 163, + 103, + 101, + 110, + 172, + 116, + 101, + 115, + 116, + 110, + 101, + 116, + 45, + 118, + 49, + 46, + 48, + 162, + 103, + 104, + 196, + 32, + 72, + 99, + 181, + 24, + 164, + 179, + 200, + 78, + 200, + 16, + 242, + 45, + 79, + 16, + 129, + 203, + 15, + 113, + 240, + 89, + 167, + 172, + 32, + 222, + 198, + 47, + 127, + 112, + 229, + 9, + 58, + 34, + 162, + 108, + 118, + 206, + 3, + 13, + 1, + 0, + 163, + 115, + 110, + 100, + 196, + 32, + 72, + 118, + 175, + 30, + 96, + 187, + 134, + 238, + 76, + 228, + 146, + 219, + 137, + 200, + 222, + 52, + 40, + 86, + 146, + 168, + 129, + 190, + 15, + 103, + 21, + 24, + 5, + 31, + 88, + 27, + 201, + 123, + 164, + 116, + 121, + 112, + 101, + 165, + 97, + 120, + 102, + 101, + 114, + 164, + 120, + 97, + 105, + 100, + 206, + 6, + 107, + 40, + 157 + ], + "rekeyedSenderAuthAddress": "BKDYDIDVSZCP75JVCB76P3WBJRY6HWAIFDSEOKYHJY5WMNJ2UWJ65MYETU", + "rekeyedSenderSignedBytes": [ + 131, + 164, + 115, + 103, + 110, + 114, + 196, + 32, + 10, + 135, + 129, + 160, + 117, + 150, + 68, + 255, + 245, + 53, + 16, + 127, + 231, + 238, + 193, + 76, + 113, + 227, + 216, + 8, + 40, + 228, + 71, + 43, + 7, + 78, + 59, + 102, + 53, + 58, + 165, + 147, + 163, + 115, + 105, + 103, + 196, + 64, + 108, + 27, + 242, + 197, + 141, + 1, + 233, + 137, + 108, + 190, + 54, + 245, + 55, + 173, + 43, + 72, + 68, + 36, + 204, + 128, + 202, + 112, + 148, + 46, + 178, + 69, + 192, + 121, + 3, + 159, + 167, + 170, + 75, + 211, + 7, + 248, + 87, + 195, + 171, + 222, + 105, + 44, + 38, + 162, + 25, + 58, + 154, + 189, + 182, + 48, + 252, + 167, + 101, + 145, + 73, + 180, + 101, + 107, + 181, + 191, + 37, + 57, + 211, + 1, + 163, + 116, + 120, + 110, + 137, + 164, + 97, + 114, + 99, + 118, + 196, + 32, + 72, + 118, + 175, + 30, + 96, + 187, + 134, + 238, + 76, + 228, + 146, + 219, + 137, + 200, + 222, + 52, + 40, + 86, + 146, + 168, + 129, + 190, + 15, + 103, + 21, + 24, + 5, + 31, + 88, + 27, + 201, + 123, + 163, + 102, + 101, + 101, + 205, + 3, + 232, + 162, + 102, + 118, + 206, + 3, + 13, + 0, + 56, + 163, + 103, + 101, + 110, + 172, + 116, + 101, + 115, + 116, + 110, + 101, + 116, + 45, + 118, + 49, + 46, + 48, + 162, + 103, + 104, + 196, + 32, + 72, + 99, + 181, + 24, + 164, + 179, + 200, + 78, + 200, + 16, + 242, + 45, + 79, + 16, + 129, + 203, + 15, + 113, + 240, + 89, + 167, + 172, + 32, + 222, + 198, + 47, + 127, + 112, + 229, + 9, + 58, + 34, + 162, + 108, + 118, + 206, + 3, + 13, + 1, + 0, + 163, + 115, + 110, + 100, + 196, + 32, + 72, + 118, + 175, + 30, + 96, + 187, + 134, + 238, + 76, + 228, + 146, + 219, + 137, + 200, + 222, + 52, + 40, + 86, + 146, + 168, + 129, + 190, + 15, + 103, + 21, + 24, + 5, + 31, + 88, + 27, + 201, + 123, + 164, + 116, + 121, + 112, + 101, + 165, + 97, + 120, + 102, + 101, + 114, + 164, + 120, + 97, + 105, + 100, + 206, + 6, + 107, + 40, + 157 + ], + "signedBytes": [ + 130, + 163, + 115, + 105, + 103, + 196, + 64, + 108, + 27, + 242, + 197, + 141, + 1, + 233, + 137, + 108, + 190, + 54, + 245, + 55, + 173, + 43, + 72, + 68, + 36, + 204, + 128, + 202, + 112, + 148, + 46, + 178, + 69, + 192, + 121, + 3, + 159, + 167, + 170, + 75, + 211, + 7, + 248, + 87, + 195, + 171, + 222, + 105, + 44, + 38, + 162, + 25, + 58, + 154, + 189, + 182, + 48, + 252, + 167, + 101, + 145, + 73, + 180, + 101, + 107, + 181, + 191, + 37, + 57, + 211, + 1, + 163, + 116, + 120, + 110, + 137, + 164, + 97, + 114, + 99, + 118, + 196, + 32, + 72, + 118, + 175, + 30, + 96, + 187, + 134, + 238, + 76, + 228, + 146, + 219, + 137, + 200, + 222, + 52, + 40, + 86, + 146, + 168, + 129, + 190, + 15, + 103, + 21, + 24, + 5, + 31, + 88, + 27, + 201, + 123, + 163, + 102, + 101, + 101, + 205, + 3, + 232, + 162, + 102, + 118, + 206, + 3, + 13, + 0, + 56, + 163, + 103, + 101, + 110, + 172, + 116, + 101, + 115, + 116, + 110, + 101, + 116, + 45, + 118, + 49, + 46, + 48, + 162, + 103, + 104, + 196, + 32, + 72, + 99, + 181, + 24, + 164, + 179, + 200, + 78, + 200, + 16, + 242, + 45, + 79, + 16, + 129, + 203, + 15, + 113, + 240, + 89, + 167, + 172, + 32, + 222, + 198, + 47, + 127, + 112, + 229, + 9, + 58, + 34, + 162, + 108, + 118, + 206, + 3, + 13, + 1, + 0, + 163, + 115, + 110, + 100, + 196, + 32, + 72, + 118, + 175, + 30, + 96, + 187, + 134, + 238, + 76, + 228, + 146, + 219, + 137, + 200, + 222, + 52, + 40, + 86, + 146, + 168, + 129, + 190, + 15, + 103, + 21, + 24, + 5, + 31, + 88, + 27, + 201, + 123, + 164, + 116, + 121, + 112, + 101, + 165, + 97, + 120, + 102, + 101, + 114, + 164, + 120, + 97, + 105, + 100, + 206, + 6, + 107, + 40, + 157 + ], + "signingPrivateKey": [ + 2, + 205, + 103, + 33, + 67, + 14, + 82, + 196, + 115, + 196, + 206, + 254, + 50, + 110, + 63, + 182, + 149, + 229, + 184, + 216, + 93, + 11, + 13, + 99, + 69, + 213, + 218, + 165, + 134, + 118, + 47, + 44 + ], + "transaction": { + "assetTransfer": { + "amount": 0, + "assetId": 107686045, + "receiver": "JB3K6HTAXODO4THESLNYTSG6GQUFNEVIQG7A6ZYVDACR6WA3ZF52TKU5NA" + }, + "fee": 1000, + "firstValid": 51183672, + "genesisHash": [ + 72, + 99, + 181, + 24, + 164, + 179, + 200, + 78, + 200, + 16, + 242, + 45, + 79, + 16, + 129, + 203, + 15, + 113, + 240, + 89, + 167, + 172, + 32, + 222, + 198, + 47, + 127, + 112, + 229, + 9, + 58, + 34 + ], + "genesisId": "testnet-v1.0", + "lastValid": 51183872, + "sender": "JB3K6HTAXODO4THESLNYTSG6GQUFNEVIQG7A6ZYVDACR6WA3ZF52TKU5NA", + "transactionType": "AssetTransfer" + }, + "unsignedBytes": [ + 84, + 88, + 137, + 164, + 97, + 114, + 99, + 118, + 196, + 32, + 72, + 118, + 175, + 30, + 96, + 187, + 134, + 238, + 76, + 228, + 146, + 219, + 137, + 200, + 222, + 52, + 40, + 86, + 146, + 168, + 129, + 190, + 15, + 103, + 21, + 24, + 5, + 31, + 88, + 27, + 201, + 123, + 163, + 102, + 101, + 101, + 205, + 3, + 232, + 162, + 102, + 118, + 206, + 3, + 13, + 0, + 56, + 163, + 103, + 101, + 110, + 172, + 116, + 101, + 115, + 116, + 110, + 101, + 116, + 45, + 118, + 49, + 46, + 48, + 162, + 103, + 104, + 196, + 32, + 72, + 99, + 181, + 24, + 164, + 179, + 200, + 78, + 200, + 16, + 242, + 45, + 79, + 16, + 129, + 203, + 15, + 113, + 240, + 89, + 167, + 172, + 32, + 222, + 198, + 47, + 127, + 112, + 229, + 9, + 58, + 34, + 162, + 108, + 118, + 206, + 3, + 13, + 1, + 0, + 163, + 115, + 110, + 100, + 196, + 32, + 72, + 118, + 175, + 30, + 96, + 187, + 134, + 238, + 76, + 228, + 146, + 219, + 137, + 200, + 222, + 52, + 40, + 86, + 146, + 168, + 129, + 190, + 15, + 103, + 21, + 24, + 5, + 31, + 88, + 27, + 201, + 123, + 164, + 116, + 121, + 112, + 101, + 165, + 97, + 120, + 102, + 101, + 114, + 164, + 120, + 97, + 105, + 100, + 206, + 6, + 107, + 40, + 157 + ] + }, + "simplePayment": { + "id": "TZM3P4ZL4DLIEZ3WOEP67MQ6JITTO4D3NJN3RCA5YDBC3V4LA5LA", + "idRaw": [ + 158, + 89, + 183, + 243, + 43, + 224, + 214, + 130, + 103, + 118, + 113, + 31, + 239, + 178, + 30, + 74, + 39, + 55, + 112, + 123, + 106, + 91, + 184, + 136, + 29, + 192, + 194, + 45, + 215, + 139, + 7, + 86 + ], + "multisigAddresses": [ + "424ZV7KBBUJ52DUKP2KLQ6I5GBOHKBXOW7Q7UQIOOYNDWYRM4EKOSMVVRI", + "NY6DHEEFW73R2NUWY562U2NNKSKBKVYY5OOQFLD3M2II5RUNKRZDEGUGEA" + ], + "multisigSignedBytes": [ + 130, + 164, + 109, + 115, + 105, + 103, + 131, + 166, + 115, + 117, + 98, + 115, + 105, + 103, + 146, + 130, + 162, + 112, + 107, + 196, + 32, + 230, + 185, + 154, + 253, + 65, + 13, + 19, + 221, + 14, + 138, + 126, + 148, + 184, + 121, + 29, + 48, + 92, + 117, + 6, + 238, + 183, + 225, + 250, + 65, + 14, + 118, + 26, + 59, + 98, + 44, + 225, + 20, + 161, + 115, + 196, + 64, + 198, + 56, + 196, + 15, + 176, + 92, + 85, + 96, + 205, + 178, + 248, + 28, + 27, + 215, + 149, + 74, + 22, + 18, + 122, + 228, + 98, + 34, + 13, + 202, + 109, + 58, + 242, + 134, + 31, + 206, + 195, + 29, + 110, + 250, + 219, + 67, + 240, + 62, + 47, + 253, + 200, + 132, + 24, + 36, + 210, + 17, + 97, + 97, + 165, + 32, + 154, + 49, + 102, + 252, + 16, + 157, + 51, + 135, + 216, + 86, + 41, + 198, + 47, + 15, + 130, + 162, + 112, + 107, + 196, + 32, + 110, + 60, + 51, + 144, + 133, + 183, + 247, + 29, + 54, + 150, + 199, + 125, + 170, + 105, + 173, + 84, + 148, + 21, + 87, + 24, + 235, + 157, + 2, + 172, + 123, + 102, + 144, + 142, + 198, + 141, + 84, + 114, + 161, + 115, + 196, + 64, + 198, + 56, + 196, + 15, + 176, + 92, + 85, + 96, + 205, + 178, + 248, + 28, + 27, + 215, + 149, + 74, + 22, + 18, + 122, + 228, + 98, + 34, + 13, + 202, + 109, + 58, + 242, + 134, + 31, + 206, + 195, + 29, + 110, + 250, + 219, + 67, + 240, + 62, + 47, + 253, + 200, + 132, + 24, + 36, + 210, + 17, + 97, + 97, + 165, + 32, + 154, + 49, + 102, + 252, + 16, + 157, + 51, + 135, + 216, + 86, + 41, + 198, + 47, + 15, + 163, + 116, + 104, + 114, + 2, + 161, + 118, + 1, + 163, + 116, + 120, + 110, + 137, + 163, + 97, + 109, + 116, + 206, + 0, + 1, + 138, + 136, + 163, + 102, + 101, + 101, + 205, + 3, + 232, + 162, + 102, + 118, + 206, + 3, + 5, + 0, + 212, + 163, + 103, + 101, + 110, + 172, + 116, + 101, + 115, + 116, + 110, + 101, + 116, + 45, + 118, + 49, + 46, + 48, + 162, + 103, + 104, + 196, + 32, + 72, + 99, + 181, + 24, + 164, + 179, + 200, + 78, + 200, + 16, + 242, + 45, + 79, + 16, + 129, + 203, + 15, + 113, + 240, + 89, + 167, + 172, + 32, + 222, + 198, + 47, + 127, + 112, + 229, + 9, + 58, + 34, + 162, + 108, + 118, 206, - 254, - 50, - 110, + 3, + 5, + 4, + 188, + 163, + 114, + 99, + 118, + 196, + 32, + 173, + 207, + 218, 63, + 201, + 93, + 52, + 35, + 35, + 15, + 161, + 115, + 204, + 245, + 211, + 90, + 68, 182, - 149, - 229, + 3, + 164, 184, - 216, - 93, + 247, + 131, + 205, + 149, + 104, + 201, + 215, + 253, 11, - 13, - 99, - 69, - 213, - 218, - 165, - 134, - 118, - 47, - 44 - ], - "transaction": { - "assetTransfer": { - "amount": 0, - "assetId": 107686045, - "receiver": { - "address": "JB3K6HTAXODO4THESLNYTSG6GQUFNEVIQG7A6ZYVDACR6WA3ZF52TKU5NA", - "pubKey": [ - 72, - 118, - 175, - 30, - 96, - 187, - 134, - 238, - 76, - 228, - 146, - 219, - 137, - 200, - 222, - 52, - 40, - 86, - 146, - 168, - 129, - 190, - 15, - 103, - 21, - 24, - 5, - 31, - 88, - 27, - 201, - 123 - ] - } - }, - "fee": 1000, - "firstValid": 51183672, - "genesisHash": [ - 72, - 99, - 181, - 24, - 164, - 179, - 200, - 78, - 200, - 16, - 242, - 45, - 79, - 16, - 129, - 203, - 15, - 113, - 240, - 89, - 167, - 172, - 32, - 222, - 198, - 47, - 127, - 112, - 229, - 9, - 58, - 34 - ], - "genesisId": "testnet-v1.0", - "lastValid": 51183872, - "sender": { - "address": "JB3K6HTAXODO4THESLNYTSG6GQUFNEVIQG7A6ZYVDACR6WA3ZF52TKU5NA", - "pubKey": [ - 72, - 118, - 175, - 30, - 96, - 187, - 134, - 238, - 76, - 228, - 146, - 219, - 137, - 200, - 222, - 52, - 40, - 86, - 146, - 168, - 129, - 190, - 15, - 103, - 21, - 24, - 5, - 31, - 88, - 27, - 201, - 123 - ] - }, - "transactionType": "AssetTransfer" - }, - "unsignedBytes": [ - 84, - 88, + 206, + 245, + 163, + 115, + 110, + 100, + 196, + 32, + 138, + 24, + 8, + 153, + 89, + 167, + 60, + 236, + 255, + 238, + 91, + 198, + 115, + 190, 137, + 254, + 3, + 35, + 198, + 98, + 195, + 33, + 65, + 123, + 138, + 200, + 132, + 194, + 74, + 0, + 44, + 25, 164, + 116, + 121, + 112, + 101, + 163, + 112, 97, + 121 + ], + "rekeyedSenderAuthAddress": "BKDYDIDVSZCP75JVCB76P3WBJRY6HWAIFDSEOKYHJY5WMNJ2UWJ65MYETU", + "rekeyedSenderSignedBytes": [ + 131, + 164, + 115, + 103, + 110, 114, - 99, - 118, 196, 32, - 72, - 118, - 175, - 30, - 96, - 187, - 134, + 10, + 135, + 129, + 160, + 117, + 150, + 68, + 255, + 245, + 53, + 16, + 127, + 231, 238, + 193, 76, + 113, + 227, + 216, + 8, + 40, 228, - 146, + 71, + 43, + 7, + 78, + 59, + 102, + 53, + 58, + 165, + 147, + 163, + 115, + 105, + 103, + 196, + 64, + 198, + 56, + 196, + 15, + 176, + 92, + 85, + 96, + 205, + 178, + 248, + 28, + 27, + 215, + 149, + 74, + 22, + 18, + 122, + 228, + 98, + 34, + 13, + 202, + 109, + 58, + 242, + 134, + 31, + 206, + 195, + 29, + 110, + 250, 219, - 137, + 67, + 240, + 62, + 47, + 253, 200, - 222, - 52, - 40, + 132, + 24, + 36, + 210, + 17, + 97, + 97, + 165, + 32, + 154, + 49, + 102, + 252, + 16, + 157, + 51, + 135, + 216, 86, - 146, - 168, - 129, - 190, + 41, + 198, + 47, 15, - 103, - 21, - 24, - 5, - 31, - 88, - 27, - 201, - 123, + 163, + 116, + 120, + 110, + 137, + 163, + 97, + 109, + 116, + 206, + 0, + 1, + 138, + 136, 163, 102, 101, @@ -496,9 +65577,9 @@ 118, 206, 3, - 13, + 5, 0, - 56, + 212, 163, 103, 101, @@ -558,105 +65639,94 @@ 118, 206, 3, - 13, - 1, - 0, + 5, + 4, + 188, + 163, + 114, + 99, + 118, + 196, + 32, + 173, + 207, + 218, + 63, + 201, + 93, + 52, + 35, + 35, + 15, + 161, + 115, + 204, + 245, + 211, + 90, + 68, + 182, + 3, + 164, + 184, + 247, + 131, + 205, + 149, + 104, + 201, + 215, + 253, + 11, + 206, + 245, 163, 115, 110, 100, 196, 32, - 72, - 118, - 175, - 30, - 96, - 187, - 134, + 138, + 24, + 8, + 153, + 89, + 167, + 60, + 236, + 255, 238, - 76, - 228, - 146, - 219, - 137, - 200, - 222, - 52, - 40, - 86, - 146, - 168, - 129, + 91, + 198, + 115, 190, - 15, - 103, - 21, - 24, - 5, - 31, - 88, - 27, - 201, + 137, + 254, + 3, + 35, + 198, + 98, + 195, + 33, + 65, 123, + 138, + 200, + 132, + 194, + 74, + 0, + 44, + 25, 164, 116, 121, 112, 101, - 165, - 97, - 120, - 102, - 101, - 114, - 164, - 120, - 97, - 105, - 100, - 206, - 6, - 107, - 40, - 157 - ] - }, - "simplePayment": { - "id": "TZM3P4ZL4DLIEZ3WOEP67MQ6JITTO4D3NJN3RCA5YDBC3V4LA5LA", - "idRaw": [ - 158, - 89, - 183, - 243, - 43, - 224, - 214, - 130, - 103, - 118, - 113, - 31, - 239, - 178, - 30, - 74, - 39, - 55, + 163, 112, - 123, - 106, - 91, - 184, - 136, - 29, - 192, - 194, - 45, - 215, - 139, - 7, - 86 + 97, + 121 ], "signedBytes": [ 130, @@ -982,81 +66052,9 @@ "lastValid": 50660540, "payment": { "amount": 101000, - "receiver": { - "address": "VXH5UP6JLU2CGIYPUFZ4Z5OTLJCLMA5EXD3YHTMVNDE5P7ILZ324FSYSPQ", - "pubKey": [ - 173, - 207, - 218, - 63, - 201, - 93, - 52, - 35, - 35, - 15, - 161, - 115, - 204, - 245, - 211, - 90, - 68, - 182, - 3, - 164, - 184, - 247, - 131, - 205, - 149, - 104, - 201, - 215, - 253, - 11, - 206, - 245 - ] - } - }, - "sender": { - "address": "RIMARGKZU46OZ77OLPDHHPUJ7YBSHRTCYMQUC64KZCCMESQAFQMYU6SL2Q", - "pubKey": [ - 138, - 24, - 8, - 153, - 89, - 167, - 60, - 236, - 255, - 238, - 91, - 198, - 115, - 190, - 137, - 254, - 3, - 35, - 198, - 98, - 195, - 33, - 65, - 123, - 138, - 200, - 132, - 194, - 74, - 0, - 44, - 25 - ] + "receiver": "VXH5UP6JLU2CGIYPUFZ4Z5OTLJCLMA5EXD3YHTMVNDE5P7ILZ324FSYSPQ" }, + "sender": "RIMARGKZU46OZ77OLPDHHPUJ7YBSHRTCYMQUC64KZCCMESQAFQMYU6SL2Q", "transactionType": "Payment" }, "unsignedBytes": [ diff --git a/packages/swift/AlgoKitTransact/Tests/AlgoKitTransactTests/TestUtils.swift b/packages/swift/AlgoKitTransact/Tests/AlgoKitTransactTests/TestUtils.swift index a835b2493..d4bb3c775 100644 --- a/packages/swift/AlgoKitTransact/Tests/AlgoKitTransactTests/TestUtils.swift +++ b/packages/swift/AlgoKitTransact/Tests/AlgoKitTransactTests/TestUtils.swift @@ -3,77 +3,65 @@ import Foundation @testable import AlgoKitTransact struct TransactionTestData: Codable { - struct AddressData: Codable { - let address: String - let pubKey: [UInt8] - } - struct TransactionData: Codable { - let sender: AddressData - let fee: UInt64 - let transactionType: String - let firstValid: UInt64 - let lastValid: UInt64 - let genesisHash: [UInt8] - let genesisId: String - let note: [UInt8]? - let rekeyTo: AddressData? - let lease: [UInt8]? - let group: [UInt8]? - let payment: PaymentFieldsData - } + struct TransactionData: Codable { + let sender: String + let fee: UInt64 + let transactionType: String + let firstValid: UInt64 + let lastValid: UInt64 + let genesisHash: [UInt8] + let genesisId: String + let note: [UInt8]? + let rekeyTo: String? + let lease: [UInt8]? + let group: [UInt8]? + let payment: PaymentFieldsData + } - struct PaymentFieldsData: Codable { - let receiver: AddressData - let amount: UInt64 - } + struct PaymentFieldsData: Codable { + let receiver: String + let amount: UInt64 + } - let transaction: TransactionData - let id: String - let idRaw: [UInt8] - let unsignedBytes: [UInt8]; - let signedBytes: [UInt8]; - let signingPrivateKey: [UInt8]; + let transaction: TransactionData + let id: String + let idRaw: [UInt8] + let unsignedBytes: [UInt8] + let signedBytes: [UInt8] + let signingPrivateKey: [UInt8] } struct TestData: Codable { - let simplePayment: TransactionTestData + let simplePayment: TransactionTestData } func loadTestData() throws -> TestData { - let testDataURL = Bundle.module.url(forResource: "test_data", withExtension: "json")! - let data = try Data(contentsOf: testDataURL) - let decoder = JSONDecoder() - return try decoder.decode(TestData.self, from: data) + let testDataURL = Bundle.module.url(forResource: "test_data", withExtension: "json")! + let data = try Data(contentsOf: testDataURL) + let decoder = JSONDecoder() + return try decoder.decode(TestData.self, from: data) } func makeTransaction(from testData: TransactionTestData) -> Transaction { - return Transaction( - transactionType: .payment, - sender: Address( - address: testData.transaction.sender.address, - pubKey: Data(testData.transaction.sender.pubKey) - ), - fee: testData.transaction.fee, - firstValid: testData.transaction.firstValid, - lastValid: testData.transaction.lastValid, - genesisHash: Data(testData.transaction.genesisHash), - genesisId: testData.transaction.genesisId, - note: testData.transaction.note != nil ? Data(testData.transaction.note!) : nil, - rekeyTo: testData.transaction.rekeyTo != nil ? Address( - address: testData.transaction.rekeyTo!.address, - pubKey: Data(testData.transaction.rekeyTo!.pubKey) - ) : nil, - lease: testData.transaction.lease != nil ? Data(testData.transaction.lease!) : nil, - group: testData.transaction.group != nil ? Data(testData.transaction.group!) : nil, - payment: PaymentTransactionFields( - receiver: Address( - address: testData.transaction.payment.receiver.address, - pubKey: Data(testData.transaction.payment.receiver.pubKey) - ), - amount: testData.transaction.payment.amount, - closeRemainderTo: nil - ), - assetTransfer: nil - ) + return Transaction( + transactionType: .payment, + sender: testData.transaction.sender, + fee: testData.transaction.fee, + firstValid: testData.transaction.firstValid, + lastValid: testData.transaction.lastValid, + genesisHash: Data(testData.transaction.genesisHash), + genesisId: testData.transaction.genesisId, + note: testData.transaction.note != nil ? Data(testData.transaction.note!) : nil, + rekeyTo: testData.transaction.rekeyTo != nil + ? testData.transaction.rekeyTo! : nil, + lease: testData.transaction.lease != nil ? Data(testData.transaction.lease!) : nil, + group: testData.transaction.group != nil ? Data(testData.transaction.group!) : nil, + payment: PaymentTransactionFields( + receiver: testData.transaction.payment.receiver, + amount: testData.transaction.payment.amount, + closeRemainderTo: nil + ), + assetTransfer: nil + ) } diff --git a/tools/build_pkgs/src/kotlin.rs b/tools/build_pkgs/src/kotlin.rs new file mode 100644 index 000000000..c3dd27a6d --- /dev/null +++ b/tools/build_pkgs/src/kotlin.rs @@ -0,0 +1,46 @@ +use crate::{Package, get_repo_root, run}; +use color_eyre::eyre::Result; + +pub fn build(package: &Package) -> Result<()> { + let so_file_output_dir = get_repo_root() + .join("packages") + .join("android") + .join(package.to_string()) + .join(package.to_string().replace("algokit_", "")) + .join("src") + .join("main") + .join("jniLibs"); + + let kotlin_out_dir = get_repo_root() + .join("packages") + .join("android") + .join(package.to_string()) + .join(package.to_string().replace("algokit_", "")) + .join("src") + .join("main") + .join("kotlin"); + + let cargo_build_cmd = format!( + "cargo ndk -o {} --manifest-path {} -t armeabi-v7a -t arm64-v8a -t x86_64 build --release", + so_file_output_dir.display(), + package.crate_manifest().display() + ); + + run(&cargo_build_cmd, None, None)?; + + if kotlin_out_dir.exists() { + std::fs::remove_dir_all(&kotlin_out_dir)?; + } + + run( + &format!( + "cargo run -p uniffi-bindgen generate --library {} --language kotlin --out-dir {}", + package.dylib(Some("aarch64-linux-android")).display(), + kotlin_out_dir.display() + ), + None, + None, + )?; + + Ok(()) +} diff --git a/tools/build_pkgs/src/main.rs b/tools/build_pkgs/src/main.rs index be5292131..c5843707b 100644 --- a/tools/build_pkgs/src/main.rs +++ b/tools/build_pkgs/src/main.rs @@ -1,3 +1,4 @@ +mod kotlin; mod python; mod swift; mod typescript; @@ -19,6 +20,8 @@ enum Language { #[value(alias = "ts")] Typescript, Swift, + #[value(alias = "kt")] + Kotlin, } impl Display for Language { @@ -27,6 +30,7 @@ impl Display for Language { Language::Python => f.write_str("python"), Language::Typescript => f.write_str("typescript"), Language::Swift => f.write_str("swift"), + Language::Kotlin => f.write_str("kotlin"), } } } @@ -37,6 +41,7 @@ impl Language { Self::Python => python::build(pkg), Self::Typescript => typescript::build(pkg), Self::Swift => swift::build(pkg), + Self::Kotlin => kotlin::build(pkg), } } @@ -75,23 +80,29 @@ impl Package { self.crate_dir().join("Cargo.toml") } - fn dylib(&self) -> PathBuf { + fn dylib(&self, target: Option<&str>) -> PathBuf { let mut prefix = "lib"; - let ext = if cfg!(target_os = "windows") { + let ext = if target.map_or(cfg!(target_os = "windows"), |t| t.contains("windows")) { prefix = ""; "dll" - } else if cfg!(target_os = "macos") { + } else if target.map_or(cfg!(target_os = "macos"), |t| t.contains("darwin")) { "dylib" } else { "so" }; - get_repo_root().join("target").join("release").join(format!( - "{}{}.{}", - prefix, - self.crate_name(), - ext - )) + let mut lib_path = get_repo_root().join("target"); + + if let Some(target) = target { + lib_path = lib_path.join(target); + } + + lib_path = + lib_path + .join("release") + .join(format!("{}{}.{}", prefix, self.crate_name(), ext)); + + lib_path } } diff --git a/tools/build_pkgs/src/python.rs b/tools/build_pkgs/src/python.rs index 391139dab..57de192c6 100644 --- a/tools/build_pkgs/src/python.rs +++ b/tools/build_pkgs/src/python.rs @@ -20,7 +20,7 @@ pub fn build(package: &Package) -> Result<()> { run( &format!( r#"cargo --color always run -p uniffi-bindgen generate --no-format --library "{}" --language python --out-dir "{}""#, - package.dylib().display(), + package.dylib(None).display(), module_dir.display() ), None, @@ -28,8 +28,8 @@ pub fn build(package: &Package) -> Result<()> { )?; std::fs::copy( - package.dylib(), - module_dir.join(package.dylib().file_name().unwrap()), + package.dylib(None), + module_dir.join(package.dylib(None).file_name().unwrap()), )?; run("poetry install --only build", Some(&package_dir), None)?;